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