// 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:

//

#include <kernel/kern_priv.h>

#include "dpipe.h"

//_LIT(KPipePanicCategory,"PipePanic");

const TInt KPipeGranularity   = 8;

DECLARE_STANDARD_LDD()

/** 

Standard export function for LDDs. This creates a DLogicalDevice derived

object, in this case our DPipeDevice

*/

	{

	return new DPipeDevice;

	}

DPipeDevice::DPipeDevice()

/**

DPipeDevice Constructor has minimal implementation such setting the version number

Indicate the use of unit number

@param		None

@return 	None

*/ 

	{

	iCount = 0;

    iIdindex = 0;

    iAllocated = 0;

	iVersion = RPipe::VersionRequired();

	}

DPipeDevice::~DPipeDevice()

	{

	// Delete the existing pipes

	for(TInt count = 0; count<iCount; count++)

		{

		DPipe* pipe=iDpipes[count];

		pipe->Wait();

		pipe->CloseAll();

		delete pipe;

		}

	Kern::Free(iDpipes);

	iMutex->Close(NULL);

	}

TInt DPipeDevice::Install()

/**

Second stage constructor and at least set a name for the 

driver object. Inherited from DLogicalDevice. This must at least set a name

for the driver object.

@param		None

@return 	KErrNone 	If successful, otherwise one of the system wide error codes.

*/

	{

	_LIT(KMutexName,"PipeDeviceMutex");

	TInt err = Kern::MutexCreate(iMutex, KMutexName, KMutexOrdGeneral1);

	if (err)

		{

		return err;

		}

	return SetName(&RPipe::Name());

	}

void DPipeDevice::GetCaps(TDes8& aDes) const

/**

Returns the driver capabilities. Called in the response to

an RPipe::GetCaps() request

@param  	aDes 		Descriptor into which capabilities information 

					    is to be written

@return 	None

*/

	{

	// Write it back to user memory

	TVersion version;

	version = iVersion;

	Kern::InfoCopy(aDes,(TUint8*)&version, sizeof(version));

	}

TInt DPipeDevice::Create(DLogicalChannelBase*& aChannel)

/**

Called by the kernel's device driver framework to create a Logical Channel. 

This is called in the context of the user thread (client) which requested the

creation of the Logical Channel. 

 @param 	aChannel 	Set to point to the created logical channel

 @return 	KErrNone 	If successful, otherwise system one of the other

 						wide error codes.

 */

	{

	aChannel = new DPipeChannel;

	if (!aChannel)

		return KErrNoMemory;

	return KErrNone;

	}

TInt  DPipeDevice::CreatePipe(const TDesC& aName, TInt aSize, DPipe*& aPipe, TAny* aCap)

/**

Called by DPipeChannel instance to create named DPipe object and 

associate itself with the newly created named DPipe instance.

@param aName			name need to be attached to the newly created DPipe object.

@param aSize			size of the DPipe object.

@param aPipe	 		Pointer to DPipe, If successful set the pointer to newly created DPipe					instance else NULL						

@param aCap				Pointer to TSecuritypolicy passed as void pointer

@return  KErrNone 		If successful, otherwise one of the other system wide error code	

@pre    Calling thread must be in a critical section.

@pre    Mutex must be held

*/	

	{	

	__ASSERT_MUTEX(iMutex);

	__KTRACE_OPT(KPIPE, Kern::Printf(">DPipeDevice::CreatePipe")); 

	TInt err = KErrNone;

	DPipe** pS = iDpipes;

	DPipe** pE = pS + iCount;

	while(pS < pE)

		{

		DPipe* pO = *pS++;

		if((pO->MatchName(&aName)))

			{ 

			err = KErrAlreadyExists;

			break;

			}

		}

	if(err == KErrNone)

		{

		DPipe* pipe = DPipe::CreatePipe(aName, aSize, aCap);	

		if(pipe)

			{

		 	err = AddPipe(pipe);

			if(err!= KErrNone)

				{

				delete pipe;

				}

			else

				{

				aPipe = pipe;		

				}

			}

		else

			{

			err = KErrNoMemory;

			}

		}

	__KTRACE_OPT(KPIPE, Kern::Printf("<DPipeDevice::CreatePipe ret=%d", err)); 

	return err;

	}

DPipe*  DPipeDevice::CreatePipe(TInt aSize)

/**

Called by DPipeChannel instance to create un-named DPipe instance and 

associate itself with the newly created un-named DPipe instance.

@param aSize		size of the DPipe object.

@return  DPipe*	    If successful, otherwise NULL

@pre    Mutex must be held

@pre	In critical section

*/

	{

	__ASSERT_CRITICAL;

	__ASSERT_MUTEX(iMutex);

	TKName aName;

	DPipe* pipe =  DPipe::CreatePipe(aName, aSize);

	if(!pipe)

		{

		return NULL;

		}

	TInt r = AddPipe(pipe);

	if (r != KErrNone)

		{

		delete pipe;

		return NULL;

		}		

	return pipe;	

	}

TInt DPipeDevice::AddPipe(DPipe* aObj)

/**

Add an instance of Dpipe to the array. 

@param aObj			Pointer to  DPipe object

@return KErrNone 	If the call is successful otherwise  one of the other

					system wide error code.

@pre    Calling thread must be in a critical section.

@pre    Mutex to be held

*/

	{

	__ASSERT_CRITICAL; //otherwise iDPipes and iCount could go out of sync

	__ASSERT_MUTEX(iMutex);

	// store the current instance to the array

	if(iCount == iAllocated)

		{

		TInt newAlloc = iAllocated + KPipeGranularity;

		TInt r = Kern::SafeReAlloc((TAny*&)iDpipes, iCount * sizeof(DPipe*), newAlloc * sizeof(DPipe*));

		if (r!= KErrNone)

			{

			return r;

			}

		iAllocated = newAlloc;

		}

	TInt id = GenerateId();	

	aObj->SetId(id);

	iDpipes[iCount++]= aObj;

	__KTRACE_OPT(KPIPE, Kern::Printf("DPipeDevice::AddPipe Pipe added ID=%d", id)); 

	return KErrNone;

	}

void DPipeDevice::RemovePipe(DPipe** aObj)

/**

Remove an instance of DPipe from the array

@param	Pointer to Dpipe Array

@return None

@pre    Calling thread must not be in a critical section.

@pre    Mutex to be held

*/

	{

	__ASSERT_MUTEX(iMutex);

	__ASSERT_CRITICAL; //we don't want to leave the array inconsistant

 	DPipe**	pE = (iDpipes + iCount) - 1;

 	if(aObj<pE)

		{

		//bump along array elements to close the gap

		wordmove((TAny*)aObj, (TAny*)(aObj+1), TInt(pE)- TInt(aObj));

		}

	--iCount;

	if(iCount % KPipeGranularity == 0)

		{

			Kern::SafeReAlloc((TAny*&)iDpipes, iAllocated*sizeof(DPipe*), iCount* sizeof(DPipe*));

			iAllocated = iCount;

		}

	}

DPipe* DPipeDevice::FindNamedPipe(const TDesC* aName)

/**

Called by the DPipeChannel to check if a named DPipe instance exist with a name

as specified by aName parameter.

@param aName		The name of the DPipe instance to search for. 

@return  DPipe*	    If successful, otherwise NULL

@pre Device mutex to be held

*/

	{

	__ASSERT_MUTEX(iMutex);

	DPipe** pS = iDpipes;

	DPipe** pE = pS + iCount;

	while(pS < pE)

		{

		DPipe* pO = *pS++;

		if(pO->MatchName(aName))

			{ 

			return pO;

			}

		}

	return NULL;

	}

DPipe* DPipeDevice::FindUnnamedPipe(const TInt aId)

/**

Called by the DPipeChannel to check if an un-named DPipe instance exist with an ID

as specified by aId parameter.

@param aId			The ID of the DPipe instance to search for. 

@return  DPipe*	   If successful, otherwise NULL

@pre Device mutex to be held

*/

	{

	__ASSERT_MUTEX(iMutex);

	DPipe** pS = iDpipes;

	DPipe** pE = pS + iCount;	

	while(pS < pE)

		{

		DPipe* pO = *pS++;

		if(pO->MatchId(aId))

			{

			return pO;

			}

		}

	return NULL;

	}

TInt DPipeDevice::Destroy(const TDesC* aName)

/**

This method is called to destroy a named DPipe instance. The caller needs to have 

sufficient capabilities to delete a named pipe. This method will fail if there are

any handles still open on the pipe. 

@param	aName		Name of the DPipe instance to be deleted.

@return	KErrNone 	If successful, otherwise one of the other system wide error.

*/

	{

	TAutoWait<DMutex> autoMutex(*iMutex);

	DPipe** pS = iDpipes;

	DPipe**	pE = pS + iCount;

	TInt err = KErrNotFound;

	TInt count = 0;

	while(pS < pE)

		{

		DPipe** pO = pS++;

		DPipe* pipe = *pO;

		if(((*pO)->MatchName(aName)))

			{

			//! Check capability 

			if(pipe->GetCap())

				{

				if(!(pipe->GetCap()->CheckPolicy(&Kern::CurrentThread())))

					{

					err = KErrPermissionDenied;

					break;

					}

				}

			// Check if any handles still opened on the pipe.

			pipe->Wait();

			if (!pipe->IsPipeClosed())

				{

				err = KErrInUse;

				pipe->Signal(); //need to signal if we won't be destroying pipe

				break;

				}

			__KTRACE_OPT(KPIPE, Kern::Printf("DPipeDevice::Destroy remove ID=%d", pipe->OpenId())); 

			delete iDpipes[count];

			RemovePipe(pO);

			err = KErrNone;

			break;

			}

		count ++;

		}

	return err;

	}

TInt DPipeDevice::Close(TInt aId)

/**

This method is called to close both named and un-named DPipe. In case of un-named DPipe

if there is no further reference of a DPipeChannel exist, the corresponding un-named DPipe

will be deleted. 

@param aId		 	ID of the pipe that need to be closed.

@return KErrNone 	If successful otherwise one of the other system wide error.

*/

	{

	TAutoWait<DMutex> autoMutex(*iMutex);

	DPipe** pS = iDpipes;

	DPipe**	pE = pS + iCount;

	TInt err = KErrNotFound;

	while(pS < pE)

		{

		DPipe** pO = pS++;

		DPipe* pipe = *pO;

		if(pipe->MatchId(aId))

			{

			__KTRACE_OPT(KPIPE, Kern::Printf("DPipeDevice::Close found ID=%d", pipe->OpenId())); 

			//even if we can't delete the pipe, we have

			//found it so don't return KErrNotFound

			err = KErrNone;

			pipe->Wait();

			// we can only delete an unamed pipe with both ends closed

		 	if(!pipe->IsNamedPipe() && pipe->IsPipeClosed())

		 		{

				__KTRACE_OPT(KPIPE, Kern::Printf("DPipeDevice::Close remove ID=%d", pipe->OpenId())); 

				delete pipe;

				RemovePipe(pO); 

				break;

		 		}

			pipe->Signal(); 

			}

		}

	return err;

	}

TInt DPipeDevice::GenerateId()

/**

Generate a ID  and store for a Named pipe while creating.

@param 	 None

@return  TInt	ID for the name pipe

@pre    Mutex to be held

*/

	{

	__ASSERT_MUTEX(iMutex);

	iIdindex++;

	return (KIdBase + iIdindex);		

	}

DPipeChannel::DPipeChannel()

	:iClientRequest(NULL), iData(NULL), iChannelType(RPipe::EChannelUnset)

/**

Constructor

*/

	{

	}

DPipeChannel::~DPipeChannel()

/**

Destructor

*/

	{

	CloseHandle();

	Kern::DestroyClientRequest(iClientRequest); //null ptr is safe

	}

TInt DPipeChannel::RequestUserHandle (DThread* aThread, TOwnerType aType)

/**

Inherited from DObject. This method is called when a user thread requests

a handle to this channel. Minimal implantation here is capability check

@param aThread		DThread instance reference that requests a handle to this channel.

@param aType		Ownership type for the handle.

@return  KErrNone  If successful otherwise one the system wide error.

*/

	{

	(void)aThread;

	(void)aType;

 	return KErrNone;

	}

TInt DPipeChannel::DoCreate (TInt aUnit, const TDesC8* aInfo, const TVersion& aVer)

/**

Inherited from DLogicalChannelBase class.  This method represents the second stage

constructor called by the kernel's device driver framework. This is called in the

context of the user thread (client) which requested the creation of the Logical

Channel. The thread is in critical section.

@param aUnit		The unit argument supplied by the client

@param aInfo		The info argument supplied by the client 

@param aVer			The version argument supplied by the client 

@return KErrNone 	If successful, otherwise one of the other system wide error codes.

*/

	{

	(void)aInfo;

	(void)aUnit;

  	// Check version

    if (!Kern::QueryVersionSupported(RPipe::VersionRequired(),aVer))

        return KErrNotSupported;

	TInt r = Kern::CreateClientRequest(iClientRequest);

	if(r != KErrNone)

		{

		return r;

		}

	// Done 

	return KErrNone;

	}

TInt DPipeChannel::Request(TInt aReqNo, TAny* a1, TAny* a2)

/**

Called by the Device driver framework upon user request. Stores the 

Thread pointer under whose context this function is called. 

@param aFunction	A number identifying the  message type

@param a1			A 32-bit Value passed by the user

@param a2			A 32-bit Value passed by the user

@return	KErrNone	If successful, otherwise one of the system wide error code

*/	

	{

	TInt err = KErrNone;

	DATAPAGING_TEST

		(

		err = Kern::HalFunction(EHalGroupVM, EVMHalFlushCache, 0, 0);

		if(err != KErrNone)

			{

			return err;

			}

		)

	if(aReqNo == KMaxTInt)

		{

			CancelRequest((TInt)a1);

			return err;

		}

	if(aReqNo < 0)

		{

		// DoRequest

		TAny *array[2] = {0,0};

		TRequestStatus * pStat = (TRequestStatus*)a1;

		kumemget32(&array[0], a2, 2*sizeof(TAny*));

		err = DoRequest(~aReqNo, pStat, array[0], array[1]);

		if(err!= KErrNone)

			Kern::RequestComplete(pStat, err);

		}

	else

		{

		// DoControl

		err = DoControl(aReqNo, a1, a2);

		}

		return err;

	}

TInt DPipeChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2)

/**

Processes Synchronous 'control' requests. This function is called to service

any synchronous calls through the  user side RPipe handle. 

@param aFunction		A number identifying the  message type

@param a1				A 32-bit Value passed by the user

@param a2				A 32-bit Value passed by the user

@return KErrNone 		If the call is successful, otherwise one of the other

						system wide error

*/

	{

	TInt aSize = 0;

	TInt aId = 0;

    switch(aFunction)

		{

		case RPipe::EDefineNamedPipe:

			return PipeCreate(a1, a2);

		case RPipe::EOpenToReadNamedPipe:

			return PipeOpen((const TDesC*)a1, RPipe::EReadChannel);

		case RPipe::EOpenToWriteNamedPipe:

			return PipeOpen((const TDesC*)a1, RPipe::EWriteChannel);

		case RPipe::EOpenToWriteButFailOnNoReaderNamedPipe:

			return OpenOnReader((const TDesC*)a1);

		case RPipe::EDestroyNamedPipe:

			return PipeDestroy((const TDesC*)a1);	

		case RPipe::ECreateUnNamedPipe:

			kumemget((TAny*)&aSize, a1, sizeof(TInt));

			return PipeCreate( aSize);

		case RPipe::EOpenUnNamedPipe:

			kumemget((TAny*)&aId, a1, sizeof(TInt));

			return PipeOpen(aId);

		case RPipe::ERead:

			kumemget((TAny*)&aSize, a2, sizeof(TInt));

			return Read (a1, aSize);

		case RPipe::EWrite:

			kumemget((TAny*)&aSize, a2, sizeof(TInt));

			return Write (a1, aSize);

		case RPipe::ESize:

			 return Size();

		case RPipe::EDataAvailableCount:

			 {		

			 TAutoWait<DMutex> autoMutex(iData->Mutex());

			 return iData->AvailableDataCount();

			 }

		case RPipe::EFlushPipe:

			 Flush();

			 return KErrNone;

		case RPipe::EGetPipeInfo:

			 umemput(a1,(TAny*)&iChannelType, sizeof(TInt));

			 aSize = Size();

			 umemput(a2,(TAny*)&aSize, sizeof(TInt));

			 return KErrNone;

		default:

			 return KErrNotSupported;

		}

	}

TInt DPipeChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)

/**

Processes Asynchronous requests This function is called to service

any asynchronous calls through the  user side RPipe handle. 

@param aFunction		A number identifying the  message type

@param aStatus 			Status request to be completed. 

@param a1				A 32-bit Value passed by the user

@param a2				A 32-bit Value passed by the user

@return  KErrNone 		If the call is successful, else one of the system wide error

*/

	{

	(void)a2;

	TInt aSize = 0;

	TInt aChoice = 0;

    switch(aReqNo)

		{

		case RPipe::EDataAvailable:

				return NotifyDataAvailable(aStatus, ETrue);	

		case RPipe::ESpaceAvailable:

				umemget(&aSize, a1, sizeof(aSize));

				return NotifySpaceAvailable(aSize, aStatus, ETrue);

		case RPipe::EWaitNotification:

				// a2 == RPipe::EWaitForReader is for WaitForReader.

				// a2 == RPipe::EWaitForWriter is for WaitForWriter.

				umemget(&aChoice, a2, sizeof(aChoice));

				return WaitNotification(aStatus, a1, aChoice);

		case RPipe::EReadBlocking:

			{

				return NotifyDataAvailable(aStatus, EFalse);

			}

		case RPipe::EWriteBlocking:

			{

				umemget(&aSize, a1, sizeof(aSize));

				return NotifySpaceAvailable(aSize, aStatus, EFalse);

			}

		default:

				return KErrNotSupported;

		}

	}

TInt DPipeChannel::PipeCreate(TAny* a1,  TAny* a2)

/**

Creates named pipes with the specified name  and size. It calls Pipe Device 

object to create the pipe and obtained the pointer to it. The pointer is then

stored in its iData member data.

@param a1		Pointer to TPipeInfo class

@param a2		Pointer to TSecurityPolicy class

@return KErrNone	If successful, otherwise one of the other system wide error code.

*/

	{

	if(iData)

		{

		//this channel already has a pipe

		return KErrInUse;

		}

	// The following code safely gets the 3 arguments into kernel memory.

	// (The user side API is badly designed,)

	RPipe::TPipeInfo& info = (*(RPipe::TPipeInfoBuf*)a1)(); // reference to user side 'TPipeInfo'

	TInt size;

	kumemget(&size,&info.isize,sizeof(size));

	TKName name;

	Kern::KUDesGet(name,info.iName);

	TSecurityPolicy* securityPolicy = 0;

	TSecurityPolicy securityPolicyBuffer;

	if(a2)

		{

		kumemget(&securityPolicyBuffer,a2,sizeof(securityPolicyBuffer));

		securityPolicy = &securityPolicyBuffer;

		}

	DPipe * pipe = NULL;

	DPipeDevice& device = *static_cast<DPipeDevice*>(iDevice);

	//must wait on device since after creation

	//the pipe becomes globably findable 

	//and destroyable

	TAutoWait<DMutex> outerAutoMutex(device.Mutex());

	TInt err = ((DPipeDevice*)iDevice)->CreatePipe(name, size, pipe, securityPolicy);

	if(err!= KErrNone)

		{

		return err;

		}

	TAutoWait<DMutex> innerAutoMutex(pipe->Mutex());

	pipe->SetReadEnd(this);

	iData = pipe;

	iChannelType = RPipe::EReadChannel;

	return err;

	}

TInt DPipeChannel::PipeCreate(const TInt aSize)

/**

Creates unnamed pipes with the specified Id and size. It calls Pipe Device 

object to create the pipe and obtained the pointer to it. The pointer is then

stored in its iData member data. Marked the current channel as read end.  

@param aSize		Size of the unnamed pipe to be created.

@return	Handle ID if successful, otherwise one of the other system wide error code.

*/

	{

	if(iData)

		{

		//this channel already has a pipe

		return KErrInUse;

		}

	DPipeDevice& device = *static_cast<DPipeDevice*>(iDevice);

	TAutoWait<DMutex> outerAutoMutex(device.Mutex());

	DPipe* pipe = device.CreatePipe(aSize);

	if(pipe == NULL)

		{

		return KErrNoMemory;

		}

	TAutoWait<DMutex> innerAutoMutex(pipe->Mutex());

	pipe->SetReadEnd(this);

	iData = pipe;

	iChannelType = RPipe::EReadChannel;

	return iData->OpenId();

	}

TInt DPipeChannel::OpenOnReader(const TDesC* aName)

/**

Opens a named pipe identified by the name parameter. It calls Pipe Device object

to open the Pipe identified by the name and obtained the pointer to the pipe. The

pointer is them stored in its iData member data. Marked the current channel as write

end. 

@param 	aName		The name of the pipe to be opened.

@return KErrNone	If successful, otherwise one of the other system wide error code. 

*/

	{

	if(iData)

		{

		//this channel already has a pipe

		return KErrInUse;

		}

	TKName PName;

	Kern::KUDesGet(PName, *aName);

	DPipeDevice& device = *static_cast<DPipeDevice*>(iDevice);

	//need to hold the device mutex to

	//prevent the pipe getting deleted before we can call

	//SetWriteEnd

	TAutoWait<DMutex> outerAutoMutex(device.Mutex());

	DPipe* pipe = device.FindNamedPipe(&PName);

	if(pipe == NULL)

		{

		return KErrNotFound;

		}

	TAutoWait<DMutex> innerAutoMutex(pipe->Mutex());

	if (!pipe->IsReadEndOpened())

		{

		return KErrNotReady;

		}

	iData = pipe;

	if(!CheckCap())

		{

		iData = NULL;

		return KErrPermissionDenied;

		}

	if(pipe->IsWriteEndOpened())

		{

		iData = NULL;

		return KErrInUse;

		}	

	iData->SetWriteEnd(this);

	iChannelType = RPipe::EWriteChannel;

	return KErrNone;

	}

TInt DPipeChannel::PipeDestroy(const TDesC* aName)

/**

Destroys the named pipe.

@param	aName 			Name of the Kernel pipe to be destroyed.

@return KErrNone		If the pipe is successfully destroyed, otherwise one of the

						other system wide error codes

*/

	{	

	TKName PName;

	Kern::KUDesGet(PName, *aName);

	return ((DPipeDevice*)iDevice)->Destroy(&PName);

	}

TInt DPipeChannel::PipeOpen(const TInt aId)

/**

Opens a unnamed pipe identified by the specified id. It calls Pipe Device object

to open a unnamed pipe identified by the specified id and obtain the pointer to the

pipe. The pipe reference is then stored in its iData member data and marked the 

current channel as write end. 

@param 	aId 		Id of the unnamed pipe to be opened.

@return KErrNone	If successful, otherwise one of the system wide error code. 

*/

	{

	if(iData)

		{

		//this channel already has a pipe

		return KErrInUse;

		}

	DPipeDevice& device = *static_cast<DPipeDevice*>(iDevice);

	TAutoWait<DMutex> outerAutoMutex(device.Mutex());

	DPipe* pipe = device.FindUnnamedPipe(aId);

	if(pipe == NULL)

		{

		return KErrNotFound;

		}

	TAutoWait<DMutex> innerAutoMutex(pipe->Mutex());

	if (pipe->IsWriteEndOpened() )

		{

		return KErrInUse;

		}

	pipe->SetWriteEnd(this);

	iChannelType = RPipe::EWriteChannel;

	iData = pipe;

	return KErrNone;

	}

TInt DPipeChannel::PipeOpen(const TDesC* aName, RPipe::TChannelType aType)

/**

This function will be called under DoControl();

Attempts to open the pipe for reading (iReadEnd) or writing (iWriteEnd)

@param  aName 		Name of the pipe to be opened

@param  aType	 	Type of operation to be performed.

@return KErrNone	Pipe successfully created, otherwise one of the other system wide

					error code

*/ 

	{

	if(iData)

		{

		//this channel already has a pipe

		return KErrInUse;

		}

	TKName PName;

	Kern::KUDesGet(PName, *aName);

	DPipeDevice& device = *static_cast<DPipeDevice*>(iDevice);

	TAutoWait<DMutex> outerAutoMutex(device.Mutex());

	DPipe* pipe = device.FindNamedPipe(&PName);

	if(pipe == NULL)

		{

		return KErrNotFound;

		}

	TAutoWait<DMutex> innerAutoMutex(pipe->Mutex());

	iData = pipe;

	//! Check capabilitity if applicalble

	if(!CheckCap())

		{

		iData = NULL;

		return KErrPermissionDenied;

		}

	// Check if the pipe is already opened.

	if(aType == RPipe::EReadChannel)

		{

		if(iData->IsReadEndOpened())

			{

			iData = NULL;

			return KErrInUse;

			}

		iData->SetReadEnd(this);

		}

	else

		{

		if(iData->IsWriteEndOpened())

			{

			iData = NULL;

			return KErrInUse;

			}

		iData->SetWriteEnd(this);	

		}

	iChannelType = aType;

	return KErrNone;	

	}

TBool DPipeChannel::CheckCap()

/**

Check if Security policy is installed, if so, checks if the current thread

has required capabilities

@param 	None

@return TBool  ETrue if The current thread has required capabilities and also if

			  no capabilities is installed, otherwise EFlase.

*/

	{

	//iData->GetCap is always true

	if(iData->GetCap())

		return iData->GetCap()->CheckPolicy(&Kern::CurrentThread());

	else 

		return ETrue;

	}

TInt DPipeChannel::Read (TAny* aBuff, TInt aSize)

/**

Synchronous, non-blocking read operation. If the pipe is empty it will 

return immediately with KErrUnderflow. A successful DPipe::Read() operation 

will free up more space in the pipe. If a request status object has been registered

for Space Available notification, it will complete. Note that there is no 

guarantee that the amount of space freed up in the pipe will be sufficient 

for the next DPipe::Write() operation.

@param	aBuff			Buffer from which data need to be read

@param	aSize			Size of the data to be read

@return:>0				Amount of data read  in octets.