FCL/sf/os/kernelhwsrv: comparison kernel/eka/euser/rpipe.cpp

equal deleted inserted replaced

--1:000000000000
+:a41df078684a
+// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+/**
+@file rpipe.cpp
+@internalTechnology
+*/
+#include <e32def.h>
+#include <e32def_private.h>
+#include "rpipe.h"
+EXPORT_C TInt RPipe::Init()
+/**
+Static method to load the pipe device driver.
+@param None
+@return KErrNone	If the pipe is successfully loaded, otherwise one of the
+					system wide error code.
+*/
+	{
+	_LIT(KDriverLddFileName,"PIPELIB");
+	return User::LoadLogicalDevice(KDriverLddFileName);
+	}
+EXPORT_C  TInt RPipe::Create( TInt aSize, RPipe& aReader, RPipe& aWriter, TOwnerType aTypeR, TOwnerType aTypeW)
+/**
+Static method to create a new, unnamed pipe.
+By default, any thread in the process can use the handle to access the Pipe. However,
+specifying EOwnerThread as the second and fourth parameter to this function, means
+that only the creating thread can use this  handle to access the Pipe.
+@param	aReader			Handle to the read end of the pipe. If the call is successful,
+						this handle will be opened for reading.
+@param aWriter			Handle to the write end of the pipe. If the call is successful,
+						this handle will be opened for writing.
+@param aTypeR, aTypeW	The type of the ownership of the handle to be created for the
+						read and write
+@param aSize			Size of the pipe to be created, in bytes.
+@return KErrNone				Pipe successfully created and the read and write handles opened,
+		KErrOverflow			Maximum number of pipes has been reached.
+		KErrNoMemory			Insufficient memory to create pipe
+		KErrArgument			If the specified size is negative or zero
+		KErrInUse				The current handle has already been opened.
+								otherwise one of the other system wide error codes
+*/
+	{
+	TInt err = aReader.Create(aSize, aTypeR);
+	if (err != KErrNone )
+		return err;
+	else
+		{
+		err = aWriter.Open(aReader, aTypeW);
+		if(err!= KErrNone)
+			aReader.Close();
+		}
+	return err;
+	}
+TInt RPipe::Create(TInt aSize, TOwnerType aType)
+/**
+Creates a Kernel side pipe and opens a handle for reading.
+By default any thread in the process can use the handle to access to Read the Pipe.
+However, specifying EOwnerThread as the second parameter to this function, means
+that only the creating thread can use this handle to access the pipe.
+@param	aSize			Size of the  pipe to create, in bytes.
+@param	aType			The type of the handle to be created for the reading
+						end of the pipe
+@return KErrNone				Pipe successfully created and handle opened for reading,
+		 KErrInUse				The current handle has already been opened.
+		 KErrOverflow	      	Maximum number of pipes has been reached.
+		 KErrNoMemory			Insufficient memory to create pipe
+	 	 KErrArgument			If the specified size is negative or zero
+								otherwise one of the other system wide error code
+*/
+	{
+	// Check if the current handle is already opened for reading/writing
+	if ( iHandle && HandleType())
+		return KErrInUse;
+	if(aSize <= 0 )
+		return KErrArgument;
+	// Perform the capability check and create the channel
+	TInt err = DoCreate(Name(), VersionRequired(), KNullUnit, NULL, NULL, aType, ETrue);
+	if (err!= KErrNone)
+			return err;
+	// Create an un-named pipe with the specified size
+	err = DoControl(ECreateUnNamedPipe, (TAny*)&aSize);
+	if (err>0)
+		{
+		iSize = DoControl(ESize);
+		iHandleType = EReadChannel;
+		iPipeHandle = err;
+		err = KErrNone;
+		}
+	else
+		{
+		Close();
+		}
+	return err;
+	}
+EXPORT_C TInt RPipe::Open(RMessagePtr2 aMessage, TInt aParam, TOwnerType aType)
+/**
+Opens a handle to pipe using a handle number sent by a client to a server.
+This function is called by the server.
+@param	aMessage		The message pointer.
+@param	aParam			An index specifying which of the four message arguments contains the handle number.
+@param	aType			An enumeration whose enumerators define the ownership of this logical channel handle.
+						If not explicitly specified, EOwnerProcess is taken as default.
+@return	KErrNone		if successful;
+		KErrArgument	if the value of aParam is outside the range 0-3;
+		KErrBadHandle	if not a valid handle;
+						otherwise one of the other system-wide error codes.
+*/
+	{
+	TInt err = RBusLogicalChannel::Open(aMessage, aParam,  aType);
+	if (err)
+		{
+		return err;
+		}
+	err = DoControl(RPipe::EGetPipeInfo,&iHandleType,&iSize);
+	return err;
+	}
+EXPORT_C TInt RPipe::Open(TInt aArgumentIndex, TOwnerType aType)
+/**
+Opens the handle to pipe which is passed by a process to child process using
+RProcess.SetParameter function call. Pipe handle type remains same(i.e. if read handle is passed
+by process then read handle will be open).
+@param	aArgumentIndex	An index that identifies the slot in the process environment
+						data that contains the handle number. This is a value relative
+						to zero, i.e. 0 is the first item/slot. This can range from 0 to 15.
+@param	aType			The type of the handle to be created for the read/write end
+@return	KErrNone		Pipe successfully created,
+						otherwise of the other system wide error code.
+*/
+	{
+	TInt err = RBusLogicalChannel::Open(aArgumentIndex,aType);
+	if (err)
+		{
+		return err;
+		}
+	err = DoControl(RPipe::EGetPipeInfo,&iHandleType,&iSize);
+	return err;
+	}
+TInt RPipe::Open(const RPipe& aReader, TOwnerType aType)
+/**
+Opens a handle to write to a pipe. The pipe must have been created previously.
+By default any thread in the process can use the handle to access to write to
+the pipe. However, specifying EOwnerThread as the second parameter to this function,
+means that only the opening thread can use this handle to write to the pipe.
+@param	aReader		Handle to the reading end of the pipe.
+@param	aType		The type of the handle to be created for the write end
+@return	KErrNone				Pipe successfully created,
+			KErrInUse			The current handle has already been opened
+			KErrAccessDenied	The read handle is not open for reading
+								otherwise of the other system wide error code.
+*/
+	{
+	// Check if the current handle is already opened for reading/writing
+	if ( iHandle && HandleType())
+		return KErrInUse;
+	// Check the read handle
+	if (aReader.HandleType() != EReadChannel)
+		return KErrAccessDenied;
+	// Perform the capability check and create the channel
+	TInt err = DoCreate(Name(),VersionRequired(), KNullUnit, NULL, NULL, aType, ETrue);
+	if (err!= KErrNone)
+		return err;
+	// Obtained the handle number
+	TInt id = aReader.PipeHandle();
+	// Set the Write channel
+	err = DoControl(EOpenUnNamedPipe,(TAny*)&id);
+	if( err == KErrNone)
+		{
+		iSize = DoControl(ESize);
+		iHandleType  = EWriteChannel;
+		iPipeHandle = id;
+		}
+	else
+		{
+		Close();
+		}
+	return err;
+	}
+// Methods to Support Named Pipe
+EXPORT_C TInt RPipe::Define(const TDesC& aName, TInt aSize)
+/**
+Static method to create a new, named pipe of a given size. Calling this method
+will create a new kernel object only. No user-side handles are created or opened.
+@param	aName		Name to be assigned to the Kernel-side pipe object.
+@param	aSize		Size of the pipe to create, in bytes.
+@return KErrNone					Pipe successfully created.
+		 KErrBadName				If the length of aName is greater than KMaxFileName
+									or Null
+		 KErrOverflow				Maximum number of pipes has been reached
+		 KErrNoMemory				Insufficient memory to create pipe.
+		 KErrArgument				if Size is negative
+		 KErrAlreadyExist			If a pipe with the specified name already exist.
+		 							otherwise one of the other system wide error code.
+*/
+	{
+	// Code to check a valid Name field as per Symbian naming convention
+	TInt err = User::ValidateName(aName);
+	if(KErrNone!=err)
+		return err;
+	if((aName.Length() > KMaxKernelName) || (aName.Length() == 0))
+		return KErrBadName;
+	if(aSize <= 0)
+		return KErrArgument;
+	// Perform the capability check and create the channel
+	RPipe temp;
+	err = temp.DoCreate(Name(),VersionRequired(), KNullUnit, NULL, NULL);
+	if (err!= KErrNone)
+		return err;
+		// Define
+	TPipeInfoBuf aInfo;
+	aInfo().isize = aSize;
+	aInfo().iName.Copy(aName);
+	// Define the Named pipe
+	err = temp.DoControl(EDefineNamedPipe, (TAny*)&aInfo);
+	temp.Close();
+	return err;
+	}
+EXPORT_C TInt RPipe::Define( const  TDesC& aName, TInt aSize, const TSecurityPolicy& aPolicy)
+/**
+Static method to create a new, named pipe of a given size. Calling this method
+will create a new kernel object only. No user-side handles are created or opened.
+@param	aName		Name to be assigned to the Kernel-side pipe object.
+@param	aSize		Size of the pipe to create, in bytes.
+@return KErrNone					Pipe successfully created.
+		 KErrBadName				If the length of aName is greater than KMaxFileName
+									or Null
+		 KErrOverflow				Maximum number of pipes has been reached
+		 KErrNoMemory				Insufficient memory to create pipe.
+		 KErrArgument				if Size is negative
+		 KErrPermissionDenied		Not sufficient capabiliites
+		 KErrAlreadyExist			If a pipe with the specified name already exist.
+		 							otherwise one of the other system wide error code.
+*/
+	{
+	// Code to check a valid Name field as per Symbian naming convention
+	TInt err = User::ValidateName(aName);
+	if(KErrNone!=err)
+		return err;
+	if((aName.Length() > KMaxKernelName) || (aName.Length() == 0))
+		return KErrBadName;
+	if(aSize <= 0)
+		return KErrArgument;
+	// Perform the capability check and create the channel
+	RPipe temp;
+	err = temp.DoCreate(Name(),VersionRequired(), KNullUnit, NULL, NULL);
+	if (err!= KErrNone)
+		return err;
+	// Define
+	TPipeInfoBuf aInfo;
+	aInfo().isize = aSize;
+	aInfo().iName.Copy(aName);
+	err = temp.DoControl(EDefineNamedPipe, (TAny*)&aInfo, (TAny*)&aPolicy);
+	temp.Close();
+	return err;
+	}
+EXPORT_C  TInt RPipe::Destroy( const TDesC& aName)
+/**
+Static method to destroy a previously created named pipe. Any data not read from
+the pipe will be discarded. This method will fail if there is any handles still
+open on the pipe or the calling thread as insufficient capabilities.
+@param	aName		Name of the Kernel-side pipe object to destroy
+@return  KErrNone					Pipe successfully destroyed
+		 KErrInUse					The pipe still has one or more handle open to it
+		 KErrPermissionDenied		Not sufficient capabiliites
+		 KErrNotFound				If no kernel pipe exist with the specified name
+		 							otherwise one of the other system wide error code.
+*/
+	{
+	// Code to check a valid Name field as per Symbian naming convention
+	TInt err = User::ValidateName(aName);
+	if(KErrNone!=err)
+		return err;
+	if((aName.Length() > KMaxKernelName) || (aName.Length() == 0))
+		return KErrBadName;
+	// Perform the capability check and create the channel
+	RPipe temp;
+	err = temp.DoCreate(Name(),VersionRequired(), KNullUnit, NULL, NULL);
+	if (err!= KErrNone)
+		return err;
+	TBuf8<KMaxKernelName> name;
+	name.Copy(aName);
+	// Destroy
+	err = temp.DoControl(EDestroyNamedPipe, (TAny*)&name, NULL);
+	temp.Close();
+	return err;
+	}
+EXPORT_C TInt RPipe::Open(const TDesC& aName, TMode aMode)
+/**
+Opens the pipe for the access mode specified. If the handle is opened to read or Write.
+The handle is opened regardless of whether or not there is a open handle at the other end.
+If the handle is opened as " Write but Fail On No Readers" the call will fail unless there
+is atleast one handle open for reading at the other end.
+@param		aName		Name of the kernel-side pipe object to destroy
+@param		aMode		Access mode for the handle.
+@return 	KErrNone				Handle successfully opened.
+			KErrBadName				If the length of aName is greater than KMaxFileName or Null
+			KErrInUse				The pipe still has one or more handle open to it.
+			KErrPermissionDenied	Not sufficient capabiliites
+			KErrNotFond				If there is no kernel instance with the specified name
+			KErrNotReady			Open Fails when no Readers is available while opening
+									With TMode = EOpenToWriteButFailOnNoReaders
+									otherwise one of the other system wide error code.
+*/
+	{
+	// Check if the current handle is already opened for reading/writing
+	if ( iHandle && HandleType())
+		return KErrInUse;
+	TInt err = User::ValidateName(aName);
+	if(KErrNone!=err)
+		return err;
+	if((aName.Length() > KMaxKernelName) || (aName.Length() == 0))
+		return KErrBadName;
+	// Perform the capability check and create the channel
+	err = DoCreate(Name(),VersionRequired(), KNullUnit, NULL, NULL);
+	if (err!= KErrNone)
+		return err;
+	TBuf8<KMaxKernelName> name;
+	name.Copy(aName);
+if (aMode == EOpenToRead)
+	{
+		err = DoControl(EOpenToReadNamedPipe,(TAny*)&name);
+		if(err == KErrNone)
+			{
+			iSize = DoControl(ESize);
+			iHandleType = EReadChannel;
+			}
+		else
+			Close();
+		}
+	else if(aMode == EOpenToWrite)
+		{
+		err = DoControl(EOpenToWriteNamedPipe, (TAny*)&name);
+		if(err == KErrNone)
+			{
+			iSize = DoControl(ESize);
+			iHandleType = EWriteChannel;
+			}
+		else
+			Close();
+	}
+	else if (aMode == EOpenToWriteNamedPipeButFailOnNoReaders)
+		{
+		err = DoControl(EOpenToWriteButFailOnNoReaderNamedPipe, (TAny*)&name);
+		if(err == KErrNone)
+			{
+			iSize = DoControl(ESize);
+			iHandleType = EWriteChannel;
+			}
+		else
+		Close();
+		}
+	else
+		{
+		Close();
+		err = KErrArgument;
+		}
+	return err;
+	}
+EXPORT_C void RPipe::Wait(const TDesC& aName, TRequestStatus& aStatus)
+/**
+Block the thread until the other end of the pipe is opened for reading. If the other end
+is already opened for reading the call will not block and status will complete immediately
+This function will be deprecated , use WaitForReader.
+Please note that Wait API will open a valid Write End of the pipe if not opened already.
+User need not open write end of the pipe again after Wait call.
+@param	aName			Name of the kernel-side pipe object to wait for
+@param  aStatus			Status request that will complete when the other end is opened
+						for reading.
+@return  KErrNone				Request is successfully registered
+		 KErrBadName			If the length of aName is greater then KMaxFileName or NULL
+		 KErrInUse				A notifier of this type has already been registered.
+		 KErrPermissionDenied	Not sufficient capabiliites
+		 						otherwise one of the other system wide error code.
+*/
+	{
+	// To wait for Reader end pass flag as EWaitForReader.
+	TInt aFlag = EWaitForReader;
+	Wait(aName, aStatus , aFlag );
+	}
+EXPORT_C  void RPipe::CancelWait()
+/**
+Cancel previous call to RPipe::Wait(), RPipe::WaitForReader (), RPipe::WaitForWriter ()
+@param	None
+@return None
+*/
+	{
+	if(!iHandle)
+		return;
+	DoCancel(ECancelWaitNotification);
+	}
+// Generic Methods
+EXPORT_C void RPipe::Close()
+/**
+Close the handle. This method exhibits different behaviour depending upon whether the pipe
+is named or unnamed.
+Named pipes are allowed to persist without any open handles. Closing the last handle on a
+named pipe will not destroy the kernel-side object. For an unnamed pipe, closing the last
+handle will destroy the kernel-side pipe object. Any unread data in the pipe will be
+discarded.
+An attempt to close an unnamed pipe will have no effect. Closing a handle will not affect
+the state of any other handles that may be open on the pipe.
+@param		None
+@return		None
+*/
+	{
+	if(!iHandle)
+		return;
+	RHandleBase::Close();
+	}
+EXPORT_C TInt RPipe::MaxSize()
+/**
+Returns the total size, in bytes, of the Pipe
+@param		None
+@return 	>= 0				Size of the pipe in bytes
+			KErrBadHandle		The handle is not open
+								otherwise one of the other system wide error code.
+*/
+	{
+	if (!iHandle )
+		 return KErrBadHandle;
+	if(iHandleType == EReadChannel || iHandleType == EWriteChannel)
+		return iSize;
+	else
+		return KErrAccessDenied;
+	}
+EXPORT_C TInt RPipe::Read(TDes8& aMsg, TInt aNumByte)
+/**
+This is non-blocking synchronous method to read aNumByte bytes from the pipe into the
+descriptor aMsg and returns the number of bytes read. If the pipe is empty the call will
+immediately return a value of zero to indicate that no data was read
+A successful RPipe::Read() operation will free up more space in the pipe.
+@param	aMsg		Descriptor to receive data
+@param	aNumByte	Number of bytes to be received.
+@return 	>0					Amount of data read from the pipe, in bytes.
+			KErrUnderFlow		The pipe was empty, no data was read
+			KErrAccessDenied	An attempt has been made to read from a handle
+								has been opened for writing.
+			KErrBadHandle		An attempt has been made to read from a handle
+								that has not been opened.
+			KErrNotReady	    Write end is closed and Pipe is empty.
+			0					No Data is available
+								otherwise one of the other system wide error code.
+*/
+	{
+	// Check for the error condition
+	if (!iHandle)
+		return KErrBadHandle;
+	// Check for KErrArgument
+	if(aNumByte > aMsg.MaxLength())
+		return KErrArgument;
+	if(iHandleType != EReadChannel)
+		return KErrAccessDenied;
+	return DoControl(ERead, (TAny*)&aMsg, (TAny*)&aNumByte);
+	}
+EXPORT_C TInt RPipe::Write( const TDesC8& aData, TInt aNumByte)
+/**
+This is non-blocking synchronous method to write data from aData. If the pipe is
+full it will return immediately with KErrOverFlow
+@param	 aData			Descriptor from which data has to be written to the pipe
+@return	>0					Amount of data written to the pipe, in bytes
+		KErrAccessDenied	An attempt has been made to write to a handle that
+							has been opened for reading.
+		KErrArgument		If the size is more then aData's length
+		KErrBadName
+		KErrOverFlow		The pipe is full. No data was inserted into the pipe.
+		KErrBadHandle		An attempt has been made to read from a handle that
+							has not been opened.
+		KErrCompletion		If the specified size is greater then the available size.
+		KErrNotReady	    Read end is closed.
+							otherwise one of the other system wide error code.
+*/
+	{
+	// Check for the error condition
+	if (!iHandle)
+		return KErrBadHandle;
+	// Check for KErrArgument
+	if(aNumByte > aData.Length())
+		return KErrArgument;
+	if(iHandleType == EReadChannel)
+		return KErrAccessDenied;
+	return DoControl(EWrite, (TAny*)&aData, (TAny*)&aNumByte);
+	}
+EXPORT_C TInt RPipe::ReadBlocking( TDes8& aMsg, TInt aNumByte)
+/**
+This is synchronous, blocking read operation. If the pipe is empty the client thread will
+be blocked until data become available. A successful RPipe::ReadBlocking() operation will
+free up more space in the pipe. This method is accompanied by data notification method to
+complete the blocking mechanism
+@param		aMsg		Descriptor to receive data
+@param		aNumByte	Number of bytes to be received
+@return 	>0					Amount of data read from the pipe in bytes.
+			KErrAccessDenied	Am attempt has been made to read from the handle that
+								has been opened for writing.
+			KErrBadHandle		Am attempt has been made to read from a handle that has
+								not been opened.
+			KErrArgument 		if the size is negative.
+			KErrInUse			If the call is active from some another thread.
+			KErrNotReady	    Write end is closed and Pipe is empty.
+								otherwise one of the system wide error code.
+*/
+	{
+	TRequestStatus stat = KRequestPending;
+	TInt err = KErrNone;
+	// Check for the error condition
+	if (!iHandle)
+		return KErrBadHandle;
+	if(aNumByte <= 0)
+		return KErrArgument;
+	if(iHandleType != EReadChannel)
+		return KErrAccessDenied;
+	// Asynchronous request to notify the data available.
+	do
+		{
+	 	stat = KRequestPending;
+		DoRequest(EReadBlocking, stat);
+		User::WaitForRequest(stat);
+		err = stat.Int();
+		if (err == KErrInUse || err == KErrNotReady)
+			{
+			return err;
+			}
+		// Synchronous read operation
+	 	err = DoControl(ERead, (TAny*)&aMsg, (TAny*)&aNumByte);
+	 	if (err == KErrNotReady)
+	 		return err;
+	 	} while (err == 0);
+	return err;
+	}
+EXPORT_C  TInt RPipe::WriteBlocking(const TDesC8& aData, TInt aNumByte)
+/**
+This is a synchronous, blocking write operation. It will attempt to
+write aNumByte's worth of data to the pipe, waiting till space is available.
+If aNumByte is less than or equal to the pipe size, MaxSize(), the write
+shall be atomic (w.r.t other threads sharing this channel), otherwise
+the data will be split into multiple atomic writes of pipe size
+(except, of course, if less than MaxSize bytes of data remain to be written).
+@param		aData		Descriptor from which data has to be written to the pipe.
+@param      aNumByte	Amount of data to be written to the pipe
+@return 	>0					Amount of data written to the pipe, in bytes.
+			KErrAccessDenied	An attempt has been made to write to a handle that
+								has been opened for reading.
+			KErrBadHandle		An attempt has been made to read from a handle that has
+								not been open.
+			KErrArgument 		if the size is negative.
+			KErrNotReady	    Read end is closed.
+								otherwise one of the other system wide error code.
+*/
+	{
+	TBool first = ETrue;
+	TRequestStatus stat = KRequestPending;
+	TInt err = 0;
+	TInt index = 0;
+	TInt writeindex =0;
+	TPtrC8 tmp;
+	TInt r = aNumByte;
+	// Check for the error condition
+	if (!iHandle)
+		return KErrBadHandle;
+	if(aNumByte <= 0)
+		return KErrArgument;
+	if(iHandleType == EReadChannel)
+		return KErrAccessDenied;
+	if (aNumByte <= iSize)
+		writeindex = aNumByte;
+	else
+		writeindex = iSize;
+	do
+		{
+		// Asynchronous request to notify the space available.
+		stat = KRequestPending;
+		DoRequest(EWriteBlocking, stat,(TAny*)&writeindex);
+		User::WaitForRequest(stat);
+		err = stat.Int();
+		if (err == KErrInUse || err == KErrNotReady)
+			{
+			return err;
+			}
+		// Synchronous write operation
+		tmp.Set(aData.Ptr()+index, writeindex);
+		err = DoControl(EWrite, (TAny*)&tmp, (TAny*)&writeindex);
+		if(err == KErrNotReady)
+			{
+			return err;
+			}
+		else
+			{
+			if ( err == aNumByte)
+				{
+				first = EFalse;
+				}
+			else
+				{
+				index  = index + err;
+				aNumByte = r - index;
+				if(aNumByte < iSize)
+					writeindex = aNumByte;
+				}
+			}
+		}while(first);
+	return r;
+	}
+EXPORT_C void RPipe::NotifyDataAvailable(TRequestStatus& aStatus)
+/**
+This method registers the request status object to be completed when data become
+available in the pipe.
+@param	aStatus			Status request that will complete when Data is available.
+@return KErrNone				Successfully registered.
+		KErrAccessDenied		Am attempt has been made to register a space available
+								notification on a handle that has not been opened for
+								reading.
+		KErrCompletion			The request was NOT registered as the condition succeeded before wait.
+		KErrBadHandle			The handle is not yet associated with a kernel pipe
+								otherwise of the other system wide error code.
+*/
+	{
+	TInt err = KErrNone;
+	if(!iHandle)
+		{
+		err = KErrBadHandle;
+		}
+	else if(iHandleType != EReadChannel)
+		{
+		err = KErrAccessDenied;
+		}
+	if(err!= KErrNone)
+		{
+		ReqComplete(aStatus, err);
+		return;
+		}
+	aStatus = KRequestPending;
+	DoRequest(EDataAvailable, aStatus);
+	}
+EXPORT_C void RPipe::NotifySpaceAvailable(TInt aSize, TRequestStatus& aStatus)
+/**
+This method registers the request status object to be completed when at least
+aSize bytes are available for writing data into the pipe.
+@param	aSize			Amount of space to wait for in the pipe.
+@param	aStatus			Status request that will complete when aSize
+						bytes become available.
+@returns KErrNone				Successfully registered.
+		 KErrAccessDenied		An attempt has been made to register a space
+								available notification on a handle that has
+								not been opened for writing.
+		 KErrArgument			If the size is negative, zero, or greater than maximum pipe size
+		 KErrBadHandle			The handle is not yet associated with a kernel pipe
+		 						otherwise one of the other system wide error code
+*/
+	{
+	TInt err = KErrNone;
+	if(!iHandle)
+		{
+		err = KErrBadHandle;
+		}
+	else if(iHandleType == EReadChannel)
+		{
+		err = KErrAccessDenied;
+		}
+	else if(aSize <= 0 || aSize > MaxSize())
+		{
+		err = KErrArgument;
+		}
+	if(err!= KErrNone)
+		{
+		ReqComplete(aStatus, err);
+		return;
+		}
+	aStatus = KRequestPending;
+	DoRequest(ESpaceAvailable, aStatus, (TAny*)&aSize);
+	}
+EXPORT_C TInt RPipe::CancelSpaceAvailable()
+/**
+Cancels an outstanding space available notifier request.
+@param		None
+@returns KErrNone			Successfully cancelled the SpaceAvailable request.
+		 KErrBadHandle		An attempt has been made to Cancel Data Available with a
+							handle which has not been associated with any kernel pipe.
+		 KErrAccessDenied	An attempt has been made to cancel a space available
+							notification on a handle that has been opened for reading.
+		 					other wise on of the other system wide error code.
+*/
+	{
+	if(!iHandle)
+		return KErrBadHandle;
+	if(iHandleType != EWriteChannel)
+		return KErrAccessDenied;
+	DoCancel(ECancelSpaceAvailable);
+	return KErrNone;
+	}
+EXPORT_C TInt RPipe::CancelDataAvailable()
+/**
+Cancels an outstanding data available notifier request.
+@param		None
+@return	KErrNone			Successfully cancelled the DataAvailable request.
+		KErrBadHandle		An attempt has been made to Cancel Data Available with a
+							handle which has not been associated with any kernel pipe.
+		KErrAccessDenied	Am attempt has been made to cancel a data available
+							notification on a handle that has been opened for writing.
+							otherwise one of the other system wide error code
+*/
+	{
+	if(!iHandle)
+		return KErrBadHandle;
+	if(iHandleType != EReadChannel)
+		return KErrAccessDenied;
+	DoCancel(ECancelDataAvailable);
+	return KErrNone;
+	}
+EXPORT_C void RPipe::Flush()
+/**
+This method will empty the pipe of all data
+@param	None
+@returns None
+*/
+	{
+		DoControl(EFlushPipe);
+	}
+EXPORT_C TInt RPipe::HandleType()const
+/**
+This method returns the Type of operation it can perform with the current handle.
+@param None
+@returns
+		EReadChannel	If the current handle is associated to the kernel-side
+						pipe object as to perform Read operations.
+		EWriteChannel	If the  current handle is associated to the kernel-side
+						pipe object as to perform Write operations.
+		KErrBadHandle   If the handle is not associated with Kernel-side object.
+						otherwise one of the other system wide error code
+*/
+	{
+	if(!iHandle)
+		return KErrBadHandle;
+	else
+		return iHandleType;
+	}
+EXPORT_C TInt RPipe::Size()
+/**
+Returns the available data in the pipe
+@param	None
+@return >= 0				Amount of data available in the pipe
+		KErrBadHandle		The handle is not yet opened
+							otherwise one of the other system wide error code.
+*/
+	{
+	if(!iHandle)
+		return KErrBadHandle;
+	return DoControl(EDataAvailableCount);
+	}
+TInt RPipe::PipeHandle()const
+/**
+Returns the id of Pipe it has created.
+*/
+	{
+	return iPipeHandle;
+	}
+void RPipe::ReqComplete(TRequestStatus& aStatus, TInt err)
+	{
+	TRequestStatus* req=(&aStatus);
+	User::RequestComplete(req,err);
+	}
+EXPORT_C void RPipe::WaitForReader(const TDesC& aName, TRequestStatus& aStatus)
+/**
+Block the thread until the other end of the pipe is opened for reading. If the other end
+is already opened for reading the call will not block and status will complete immediately.
+Please note that WaitForReader API will open a valid Write End of the pipe if not opened already.
+User need not open write end of the pipe again after WaitForReader call.
+@param	aName			Name of the kernel-side pipe object to wait for
+@param  aStatus			Status request that will complete when the other end is opened
+						for reading.
+@return  KErrNone				Request is successfully registered
+		 KErrBadName			If the length of aName is greater then KMaxFileName or NULL
+		 KErrInUse				A notifier of this type has already been registered.
+		 KErrPermissionDenied	Not sufficient capabiliites
+		 KErrAccessDenied		WaitForReader request is issued using Read handle.
+		 						otherwise one of the other system wide error code.
+*/
+	{
+	// To wait for Reader end pass flag as EWaitForReader.
+	TInt aFlag = EWaitForReader;
+	Wait(aName, aStatus , aFlag );
+	}
+EXPORT_C void RPipe::WaitForWriter(const TDesC& aName, TRequestStatus& aStatus)
+/**
+Block the thread until the other end of the pipe is opened for writing. If the other end
+is already opened for writing the call will not block and status will complete immediately
+Please note that WaitForWriter API will open a valid Read End of the pipe if not opened already.
+User need not open read end of the pipe again after WaitForWriter call.
+@param	aName			Name of the kernel-side pipe object to wait for
+@param  aStatus			Status request that will complete when the other end is opened
+						for writing.
+@return  KErrNone				Request is successfully registered
+		 KErrBadName			If the length of aName is greater then KMaxFileName or NULL
+		 KErrInUse				A notifier of this type has already been registered.
+		 KErrPermissionDenied	Not sufficient capabiliites
+		 KErrAccessDenied		WaitForWriter request is issued using Write handle.
+		 						otherwise one of the other system wide error code.
+*/
+	{
+	// To wait for Writer end pass flag as EWaitForWriter.
+	TInt aFlag = EWaitForWriter;
+	Wait(aName, aStatus , aFlag );
+	}
+void RPipe::Wait(const TDesC& aName, TRequestStatus& aStatus , TInt aChoice)
+/**
+Block the thread until the other end of the pipe is opened for reading (or writing). If the other end
+is already opened for reading (or writing) the call will not block and status will complete immediately.
+@param	aName			Name of the kernel-side pipe object to wait for
+@param  aStatus			Status request that will complete when the other end is opened
+						for reading (or Writing).
+@param  aChoice			EWaitForReader for WaitForReader.
+						EWaitForWriter for WaitForWriter.
+@return  KErrNone				Request is successfully registered
+		 KErrBadName			If the length of aName is greater then KMaxFileName or NULL
+		 KErrInUse				A notifier of this type has already been registered.
+		 KErrPermissionDenied	Not sufficient capabiliites
+		 KErrAccessDenied		WaitForReader request is issued using Read handle or
+		 						WaitForWriter request is issued using Write handle.
+		 						otherwise one of the other system wide error code.
+*/
+	{
+	// Code to check a valid Name field as per Symbian naming convention
+	TInt err = User::ValidateName(aName);
+	if(err != KErrNone)
+		{
+		ReqComplete(aStatus, err);
+		return;
+		}
+	if((aName.Length() > KMaxKernelName) || (aName.Length() == 0))
+		{
+		ReqComplete(aStatus, KErrBadName);
+		return;
+		}
+	TBuf8<KMaxKernelName> name8;
+	name8.Copy(aName);
+	aStatus = KRequestPending;
+	// Check if the current instance of RPipe is already opened.
+	if (!iHandle)
+		{
+		// Perform the capability check and create the channel
+		err = DoCreate(Name(),VersionRequired(), KNullUnit, NULL, NULL);
+		if (err!= KErrNone)
+			{
+			ReqComplete(aStatus, err);
+			return;
+			}
+		if (aChoice == EWaitForReader)
+			{
+			// Open the Write handle.
+			err = DoControl(EOpenToWriteNamedPipe, (TAny*)&name8);
+			if(err == KErrNone)
+				{
+				iSize = DoControl(ESize);
+				iHandleType = EWriteChannel;
+				}
+			}
+		else
+			{
+			// Open the Read handle.
+			err = DoControl(EOpenToReadNamedPipe, (TAny*)&name8);
+			if(err == KErrNone)
+				{
+				iSize = DoControl(ESize);
+				iHandleType = EReadChannel;
+				}
+			}
+		if ( err!= KErrNone)
+			{
+			Close();
+			ReqComplete(aStatus, err);
+			return;
+			}
+		}
+	// use the existing Logical channel to send the request.
+	DoRequest(EWaitNotification, aStatus, (TAny*)&name8,(TAny*)&aChoice);
+	}