// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Implementation of pipes

// 

//

#include "POSIXIF.H"

#include <sys/errno.h>

#include <sys/stat.h>

// Child end of the pipe

CPipeChildDesc::CPipeChildDesc(TInt anIndex, RPosixSession& aSession)

		: CFileDescBase(), iIndex(anIndex), iSession(aSession), iParamDes(0,0,0)

	{}

TInt CPipeChildDesc::LSeek (int&, int)

	{

	return ESPIPE;	// can't seek on a pipe

	}

TInt CPipeChildDesc::FStat(struct stat *st)

	{

	// I am a fifo about which little is known

	st->st_mode = S_IFIFO;

	st->st_blksize=0;

	return KErrNone;

	}

void CPipeChildDesc::Read (TDes8& aBuf, TRequestStatus& aStatus)

	{

	if (iClientClosed || !IsReadable())

		{

		Complete(aStatus,KErrEof);

		return;

		}

	TIpcArgs args(iIndex,&aBuf,aBuf.MaxLength());

	iSession.Request(PMPipeRead,args,aStatus);	// asynchronous request

	}

void CPipeChildDesc::ReadCancel()

	{

	Cancel(PMPipeRead);

	}

TInt CPipeChildDesc::ReadCompletion(TDes8& aDesc, TInt aStatus)

	{

	if (aStatus==KErrEof)

		{

		ClientClose();

		aDesc.Zero();		// set read length to zero

		return KErrNone;	// indicates graceful close at the other end

		}

	return aStatus;

	}

void CPipeChildDesc::Write(TDes8& aDesc, TRequestStatus& aStatus)

	{

	if (iClientClosed || !IsWriteable())

		{

		Complete(aStatus,KErrEof);

		return;

		}

	TIpcArgs args(iIndex,&aDesc,aDesc.Length());

	iSession.Request(PMPipeWrite,args,aStatus);	// asynchronous request

	}

void CPipeChildDesc::WriteCancel()

	{

	Cancel(PMPipeWrite);

	}

TInt CPipeChildDesc::WriteCompletion(TDes8& /*aDesc*/, TInt aStatus)

	{

	if (aStatus==KErrEof)

		ClientClose();

	return aStatus;

	}

void CPipeChildDesc::Ioctl(int aCmd, void* aParam, TRequestStatus& aStatus)

//

// The work of the Ioctl is done in the parent, including writing back to aParam?

// Use the default completion which just returns aStatus.Int()

//

	{

	if (iClientClosed)

		{

		Complete(aStatus,KErrEof);

		return;

		}

	iParamDes.Set((TText8*)aParam,4,4);

	TIpcArgs args(iIndex,aCmd,&iParamDes);	

	if (aCmd==E32IOSELECT)

		args.Set(3, *((TInt*)aParam));

	iSession.Request(PMPipeIoctl,args,aStatus);	// asynchronous request

	}

void CPipeChildDesc::IoctlCancel()

	{

	Cancel(PMPipeIoctl);

	}

void CPipeChildDesc::Cancel(TInt aType)

	{

	if (iClientClosed)

		return;

	TIpcArgs args(iIndex,aType);

	iSession.Request(PMPipeCancel,args);

	}	

TInt CPipeChildDesc::FinalClose()

	{

	ClientClose();

	TIpcArgs args(iIndex);

	return iSession.Request(PMPipeClose,args);		// synchronous request

	}

// 

// Parent end of the pipe, where the real work is done

//

CPipeDesc::CPipeDesc(TInt anIndex) : CFileDescBase()

	{

	iIndex=anIndex;

	}

void CPipeDesc::SetClientSide(CPipeDesc*& aClientPointer)

	{

	iClientSide=&aClientPointer;

	}

_LIT(KCPipeDescPanic, "CPipeDesc");

void CPipeDesc::Panic(TInt aReason)

	{

	User::Panic(KCPipeDescPanic,aReason);

	}

void CPipeDesc::Panic(RMessage2& aMessage, TInt aReason)

	{

	aMessage.Panic(KCPipeDescPanic,aReason);

	}

TInt CPipeDesc::LSeek (int&, int)

	{

	return ESPIPE;	// can't seek on a pipe

	}

TInt CPipeDesc::FStat(struct stat *st)

	{

	// I am a fifo about which little is known

	st->st_mode = S_IFIFO;

	st->st_blksize=0;

	return KErrNone;

	}

void CPipeDesc::Read (TDes8& aBuf, TRequestStatus& aStatus)

	{

	if (!IsReadable())

		{

		Complete(aStatus, KErrEof);	// avoids treading on iStatus of pending Write

		return;

		}

	__ASSERT_DEBUG(iStatus==0,Panic(1));

	iStatus=&aStatus;

	if (iClientClosed)

		{

		User::RequestComplete(iStatus,KErrEof);

		return;

		}

	iReadBuf=&aBuf;

	if (ClientIoctlPending())

		CompleteClientIoctl();

	if (iClientLength!=0)

		TransferFromClient();

	}

void CPipeDesc::ReadCancel()

	{

	Cancel();

	}

TInt CPipeDesc::ReadCompletion(TDes8& aDesc, TInt aStatus)

	{

	if (aStatus==KErrEof)

		{

		ClientClose();

		aDesc.Zero();		// set read length to zero

		return KErrNone;	// indicates graceful close at the other end

		}

	return aStatus;

	}

void CPipeDesc::Write(TDes8& aDesc, TRequestStatus& aStatus)

	{

	if (!IsWriteable())

		{

		Complete(aStatus, KErrEof);	// avoids treading on iStatus of pending Read

		return;

		}

	__ASSERT_DEBUG(iStatus==0,Panic(2));

	iStatus=&aStatus;

	if (iClientClosed)

		{

		User::RequestComplete(iStatus,KErrEof);

		return;

		}

	iWriteBuf.Set(aDesc);

	if (ClientIoctlPending())

		CompleteClientIoctl();

	if (iClientLength!=0)

		TransferToClient();

	}

void CPipeDesc::WriteCancel()

	{

	Cancel();

	}

TInt CPipeDesc::WriteCompletion(TDes8& /*aDesc*/, TInt aStatus)

	{

	if (aStatus==KErrEof)

		ClientClose();

	return aStatus;

	}

void CPipeDesc::Ioctl(int aCmd, void* aParam, TRequestStatus& aStatus)

	{

	TInt ret=KErrNone;

	iIoctlStatus=&aStatus;

	int *param=REINTERPRET_CAST(int*,aParam);

	switch (aCmd)

		{

	case E32IONREAD:

		// synchronous ioctls are handled in the completion routine.

		break;

	case E32IOSELECT:

		{

		int mask=(*param)&SelectMask();

		if (mask!=0 && iClientLength==0)

			return;	// wait for client to show up

		}

		break;

	default:

		ret=KErrNotSupported;

		break;

		}

	User::RequestComplete(iIoctlStatus,ret);

	}

TInt CPipeDesc::IoctlCompletion(int aCmd, void* aParam, TInt aStatus)

	{

	TInt ret=aStatus;

	if (ret!=KErrNone)

		return ret;

	int *param=REINTERPRET_CAST(int*,aParam);

	switch (aCmd)

		{

	case E32IONREAD:

		if (IsReadable())

			*param=iClientLength;	// 0 if no outstanding client data

		else

			*param=0;	// claim that no data is available

		break;

	case E32IOSELECT:

		{

		int mask=0;

		if (iClientLength!=0)

			mask = SelectMask();

		*param=(*param)&mask;

		}

		break;

	default:

		ret=KErrNotSupported;

		break;

		}

	return ret;

	}

void CPipeDesc::IoctlCancel()

	{

	User::RequestComplete(iIoctlStatus,KErrCancel);

	}

void CPipeDesc::Cancel()

	{

	// Pipes are unidirectional, so don't need to distinguish between

	// ReadCancel and WriteCancel

	User::RequestComplete(iStatus,KErrCancel);

	}

// Client-side interface

void CPipeDesc::ClientWrite(const RMessage2& aMessage)

	{

	__ASSERT_DEBUG(iClientLength==0,Panic(3));

	if (iClientClosed)

		{

		aMessage.Complete(KErrEof);

		return;

		}

	iClientLength=aMessage.Int2();

	iClientOffset=0;

	iMessage=aMessage;

	if (iIoctlStatus!=0)

		User::RequestComplete(iIoctlStatus,KErrNone);

	if (iStatus!=0)

		TransferFromClient();

	}

void CPipeDesc::ClientRead(const RMessage2& aMessage)

	{

	__ASSERT_DEBUG(iClientLength==0,Panic(4));

	if (iClientClosed)

		{

		aMessage.Complete(KErrEof);

		return;

		}

	iClientLength=aMessage.Int2();

	iMessage=aMessage;

	if (iIoctlStatus!=0)

		User::RequestComplete(iIoctlStatus,KErrNone);

	if (iStatus!=0)

		TransferToClient();

	}

void CPipeDesc::ClientIoctl(const RMessage2& aMessage)

	{

	__ASSERT_DEBUG(!ClientIoctlPending(),Panic(7));

	if (iClientClosed)

		{

		aMessage.Complete(KErrEof);

		return;

		}

	iClientIoctlPending=1;

	iIoctlMessage=aMessage;

	TInt ret=KErrNone;

	switch (aMessage.Int1())

		{

	case E32IONREAD:

		// synchronous ioctls are handled in the completion routine.

		break;

	case E32IOSELECT:

		{

		int mask=aMessage.Int3();

		mask&=ClientSelectMask();

		if (mask!=0 && iStatus==0)

			return;	// wait for parent activity

		}

		break;

	default:

		ret=KErrNotSupported;

		break;

		}

	CompleteClientIoctl(ret);

	}

void CPipeDesc::ClientCancel(const RMessage2& aMessage)

	{

	if (aMessage.Int1()==PMPipeIoctl)

		{

		if (ClientIoctlPending())

			CompleteClientIoctl(KErrCancel);

		return;

		}

	// Pipes are unidirectional, so Read and Write are cancelled by

	// cancelling the current client operation.

	//

	if (iClientLength!=0)

		{

		iMessage.Complete(KErrCancel);

		iClientLength=0;

		}

	}

void CPipeDesc::ClientClose()

	{

	iClientClosed=1;

	// terminate any pending requests

	if (iStatus!=0)

		User::RequestComplete(iStatus,KErrEof);

	if (ClientIoctlPending())

		CompleteClientIoctl(KErrEof);

	if (iClientLength!=0)

		{

		iMessage.Complete(KErrEof);

		iClientLength=0;

		}

	}

TInt CPipeDesc::FinalClose()

	{

	ClientClose();

	if (iClientSide)

		{

		*iClientSide=0;

		iClientSide=0;

		}

	return KErrNone;

	}

void CPipeDesc::TransferFromClient()

//

// Handle transfer of data from client to parent.

// Always complete the parent read, but only complete the child write when

// all of the data has been consumed.

//

	{

	TRAPD(err,iMessage.ReadL(1,*iReadBuf,iClientOffset));

	if (err)

		{

		Panic(iMessage,5);

		iClientLength=0;

		ClientClose();	// will complete the parent read

		return;

		}

	TInt length=iReadBuf->Length();	// record the amount of data transferred

	User::RequestComplete(iStatus,KErrNone);

	iClientOffset+=length;

	iClientLength-=length;

	if (iClientLength==0)

		iMessage.Complete(KErrNone);

	}

void CPipeDesc::TransferToClient()

//

// Handle transfer from parent to client

// Always complete the client read, but only complete the parent write when

// all of the data has been consumed.

//

	{

	TInt err=KErrNone;

	TInt length=iWriteBuf.Length();

	TInt written=length;

	if (iClientLength >= length)

		{

		TRAP(err,iMessage.WriteL(1,iWriteBuf,0));

		}

	else

		{

		written=iClientLength;

		TRAP(err,iMessage.WriteL(1,iWriteBuf.Left(written),0));

		}

	iClientLength=0;

	if (err)

		{

		Panic(iMessage,6);

		ClientClose();	// will complete the parent write

		return;

		}

	iMessage.Complete(KErrNone);

	length-=written;

	if (length==0)

		User::RequestComplete(iStatus,KErrNone);

	else

		iWriteBuf.Set(iWriteBuf.Right(length));

	}

void CPipeDesc::CompleteClientIoctl(TInt ret)

	{

	if (ret!=KErrNone)

		{

		iIoctlMessage.Complete(ret);

		iClientIoctlPending=0;

		return;

		}

	CompleteClientIoctl();

	}

void CPipeDesc::CompleteClientIoctl()

//

// Complete outstanding PMPipeIoctl message

//

	{

	TInt ret=KErrNone;

	int param=0;

	switch (iIoctlMessage.Int1())

		{

	case E32IONREAD:

		if (IsWriteable() && iStatus!=0)

			param=iWriteBuf.Length();

		else

			param=0;	// claim that no data is available

		break;

	case E32IOSELECT:

		{

		int mask=0;

		if (iStatus!=0)

			mask=ClientSelectMask();

		param=(iIoctlMessage.Int3())&mask;

		}

		break;

	default:

		ret=KErrNotSupported;

		break;

		}

	if (ret==KErrNone)

		{

		TPtrC8 paramReturn((const TText8*)&param,4);

		TRAP(ret,iIoctlMessage.WriteL(2,paramReturn,0));

		}

	iIoctlMessage.Complete(ret);

	iClientIoctlPending=0;

	}