/* Copyright (c) 2005-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:
 * Name        : UPIPEDESC.CPP
 * Description : Contains the source for the pipe descriptor classes 
 * 
 */



#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <rpipe.h>
#include <signal.h>
#include "fdesc.h"

TInt CPipeDescBase::Fcntl(TUint anArg, TUint aCmd)
	{
	TInt ret = KErrNone;
    TUint  accessMode = iFcntlFlag & O_ACCMODE;
    TUint  statusFlag = O_NONBLOCK | O_APPEND| O_SYNC; //Looks like we only support O_NONBLOCK

	// F_DUPFD is handled before this method is reached
	switch (aCmd)
		{
	case F_SETFL:
	    iFcntlFlag = accessMode|(anArg & statusFlag); //preserve the access mode flags
		break;
	case F_GETFL:
		ret = iFcntlFlag;
		break;
	case F_SETFD:
		if(anArg & FD_CLOEXEC)
			iFdAttrib |= KCloseonExec;
		else
			iFdAttrib &= ~KCloseonExec;
		break;
	case F_GETFD:
		if (iFdAttrib & KCloseonExec)
			{
			ret = FD_CLOEXEC;
			}
		break;
		}

	return ret;
	}


TInt CPipeDescBase::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 CPipeDescBase::Ioctl(int /* aCmd */, void* /* aParam */, TRequestStatus& aStatus)
	{
	// return if it is an invalid fd - Do I need this?
	if (iFdAttrib & KInvalidFd)
		{
		Complete(aStatus, KErrBadHandle);
		return;
		}

	Complete(aStatus, KErrNotSupported);
	}

TInt CPipeDescBase::FinalClose()
	{
	iHandle.Close();
	return KErrNone;
	}


void CPipeReadDesc::Read(TDes8& aDesc, TRequestStatus& aStatus)
	{
	// return if it is an invalid fd - Do I need this?
	if (iFdAttrib & KInvalidFd)
		{
		Complete(aStatus, KErrBadHandle);
		return;
		}

	//Acquire the Lock before read and release it later
	Complete(aStatus, DoRead(aDesc));
	}

TInt CPipeReadDesc::DoRead(TDes8& aDesc)
	{
	TInt err = KErrNone;

	if (iFcntlFlag & O_NONBLOCK)
		{
		err = iHandle.Read(aDesc, aDesc.MaxLength());
		if (err == 0 || err == KErrUnderflow || err == KErrNotReady)
			{
			err = KErrWouldBlock;
			}
		}
	else
		{
		err = iHandle.ReadBlocking(aDesc, aDesc.MaxLength());
		if (err == KErrNotReady)
			{
			err = 0;
			}
		}

	return err;
	}

void CPipeReadDesc::Write(TDes8& /*aDesc*/, TRequestStatus& aStatus)
	{
	// Write on a RD_ONLY handle
	Complete(aStatus, KErrBadHandle);
	}

TInt CPipeReadDesc::Poll(TUint aEvents)
	{
	if (aEvents & EReadyForWriting && !(aEvents & EReadyForReading) &&  !(aEvents & EAnyException))
		{
		return KErrNotSupported;
		}
	TInt sz = iHandle.Size();
	if (sz == 0)
		{
		if(aEvents & EAnyException)
      			{
      			TBuf8<1> dummy;
      			//returns the number of bytes read from the pipe if passed.
      			sz = iHandle.Read(dummy,0);
      			// if write end of pipe is closed return an exception.
      			if (sz == KErrNotReady)
        			{
        			return EAnyException;
        			}
       		return 0;
       		}
		}
	if (sz > 0)
		{
		if(aEvents & EReadyForReading)
			{
			// There is data in the pipe
			return EReadyForReading;
			}
		return 0;
		}
	return 0;
	}

TInt CPipeReadDesc::NotifyActivity(TUint aEvents, TRequestStatus& aRequest, TTimeIntervalMicroSeconds32 /*timeout = 0*/)
	{
	if (aEvents & EReadyForWriting && !(aEvents & EReadyForReading) &&  !(aEvents & EAnyException))
		{
		return KErrNotSupported;
		}

	// Even if aEvents includes EAnyException, I will register for DataAvailable.
	// If aRequest.Int() is not KErrNone, I will mark this fd as set in exceptfds.
	// Else ignore.
	iHandle.NotifyDataAvailable(aRequest);
	return KErrNone;
	}

// -----------------------------------------------------------------------------
// CPipeDescBase::TweakReadyEvents
// Prepares the pipe specific output events
// -----------------------------------------------------------------------------
//
TInt CPipeReadDesc::TweakReadyEvents(TInt errval)
    {
    TInt returnEvents = 0;
    // This file descriptor is pipe-like 
    if( errval >= KErrNone )
        {
        returnEvents |= EReadyForReading;
        }
    else
        {
        returnEvents |= EAnyException;
        }
    return returnEvents;
    }
	
void CPipeReadDesc::CancelNotify()
	{
	iHandle.CancelDataAvailable();
	}

void CPipeWriteDesc::Write(TDes8& aDesc, TRequestStatus& aStatus)
	{
	// return if it is an invalid fd - Do I need this?
	if (iFdAttrib & KInvalidFd)
		{
		Complete(aStatus, KErrBadHandle);
		return;
		}

	// Acquire the Lock before write and release it later
	Complete(aStatus, DoWrite(aDesc));
	}

TInt CPipeWriteDesc::DoWrite(TDes8& aDesc)
	{
	TInt err = KErrNone;
	TInt sz = aDesc.Length();
	TInt size = 0;
	if (iFcntlFlag & O_NONBLOCK)
		{
		if (aDesc.Length() > iHandle.MaxSize())
			{
			sz = iHandle.MaxSize() - iHandle.Size();
			if (sz == 0)
				{
				// no space in pipe. Attempt to write 1 byte
				sz = 1;
				}
			}

		err = iHandle.Write(aDesc, sz);
		if (err == KErrOverflow)
			{
			err = KErrWouldBlock;
			}
		size = err;
		}
	else
		{
		TPtrC8 ptr(aDesc);
		TInt len;

		do
			{
			len = sz;
			if (len > iHandle.MaxSize())
				{
				len = iHandle.MaxSize();
				}

			err = iHandle.Write(ptr, len);
			if (err == KErrOverflow)
				{
				TRequestStatus req = KRequestPending;
				iHandle.NotifySpaceAvailable(len, req);
				User::WaitForRequest(req);
				err = iHandle.Write(ptr, len);
				}

			if (err < 0)
				{
				size = err;
				break;
				}

			/* err is the number of bytes actually written into the pipe */
			sz -= err;
			if (sz)
				{
				ptr.Set( ptr.Mid(err));
				}
			size +=err;
			} while (sz);
		}

#ifdef SYMBIAN_OE_POSIX_SIGNALS
	if(err == KErrNotReady)
		{
		TInt lErrno;
		Backend()->raise(SIGPIPE,lErrno);
		}
#endif
	return size;
	}


void CPipeWriteDesc::Read(TDes8& /*aDesc*/, TRequestStatus& aStatus)
	{
	// Read on a WR_ONLY handle
	Complete(aStatus, KErrBadHandle);
	}

TInt CPipeWriteDesc::Poll(TUint aEvents)
	{
	if (aEvents & EReadyForReading && !(aEvents & EReadyForWriting) &&  !(aEvents & EAnyException))
		{
		return KErrNotSupported;
		}

	if (iHandle.MaxSize() > iHandle.Size())
		{
		if(aEvents & EAnyException)
      			{
		      TBuf8<1> dummy;
		      //to check if read end of a pipe is closed
		      TInt sz = iHandle.Write(dummy,0);
		      if (sz == KErrNotReady)
		     		{
		        	return EAnyException;
		        	}
      			return 0;
			}
		// There is space to write into the pipe
		if(aEvents & EReadyForWriting)
			{
			return EReadyForWriting;
			}
		return 0;
		}
	return 0;
	}

TInt CPipeWriteDesc::NotifyActivity(TUint aEvents, TRequestStatus& aRequest, TTimeIntervalMicroSeconds32 /*timeout = 0*/)
	{
	if (aEvents & EReadyForReading && !(aEvents & EReadyForWriting) &&  !(aEvents & EAnyException))
		{
		return KErrNotSupported;
		}

	// Even if aEvents is EAnyException, I will register for SpaceAvailable.
	// If aRequest.Int() is not KErrNone, I will mark this fd as set in exceptfds.
	// Else ignore.

	/* I wait for the pipe to be empty. Am I bad? */
	iHandle.NotifySpaceAvailable(iHandle.MaxSize(), aRequest);
	return KErrNone;
	}

// -----------------------------------------------------------------------------
// CPipeWriteDesc::TweakReadyEvents
// Prepares the pipe specific output events
// -----------------------------------------------------------------------------
//
TInt CPipeWriteDesc::TweakReadyEvents(TInt errval)
    {
    TInt returnEvents = 0;
    // This file descriptor is pipe-like 
    if( errval >= KErrNone )
        {        
        returnEvents |= EReadyForWriting;
        }
    else
        {
        returnEvents |= EAnyException;
        }
    return returnEvents;
    }
	
void CPipeWriteDesc::CancelNotify()
	{
	iHandle.CancelSpaceAvailable();
	}