// 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);
	}