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

	}