/*

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

*

*/

#include <string.h>

#include <stdio.h>

#include <fcntl.h>		// for struct stat

#include <wchar.h>

#include <sys/errno.h>		// for ENOTSOCK

#include <sys/ioctl.h>

#include <c32comm.h>

#include <sys/stat.h>

#include <limits.h> //for LLONG_MAX and INT_MAX

#ifdef SYMBIAN_OE_LIBRT

#include <sys/shm.h>

#endif// SYMBIAN_OE_LIBRT

#include "sysreent.h"

#include "systemspecialfilercg.h"

#include "fdesc.h"

#include "lposix.h"

#include "ltime.h"

/*

Temp directory, this should be checked later

*/

#ifdef WIDEP_tmpdir

#undef WIDEP_tmpdir

#define WIDEP_tmpdir   L"/System/temp/"

#endif //WIDEP_tmpdir

CFileDescBase::CFileDescBase( TUint aFcntl, TUint32 aFdAttrib ) :

	iReadTimeout(-1), iFcntlFlag(aFcntl), iFdAttrib(aFdAttrib), iPollErr(KErrNone)

	{

	}

TInt CFileDescBase::SetAtt(TUint /*aSetAttMask*/, TUint /*aClearAttMask*/) 

	{

	return 0;

	}

// A CFileDescBase factory function, for "named" file-like objects

CFileDescBase* CFileDescBase::Open(const wchar_t* name, int mode, int perms, TInt& err)

	{

    err = KErrNone;

    CFileDescBase* ret = NULL;

	if(WcsCmp(name, L"CON:") == 0)

		{

		ret = new CTtyDesc;	// NB. This won't be the default stdin/stdout/stderr console

		}

	else if(WcsCmp(name, L"NUL:") == 0)

		{

		ret = new CFileDescBase;

		}

	else if((WcsCmp(name, L"TMP:") == 0) || (mode & O_TMPFILE))

		{	

		CTempFileDesc* tmp = new CTempFileDesc;

		if(tmp != NULL)

			{

			err = tmp->Open(name, mode);

			if(err != KErrNone)

				{

				delete tmp;

				tmp = NULL;

				}

			}

		ret = tmp;

		}

#ifdef SYMBIAN_OE_LIBRT

	else if(mode & O_SHMFLG)

 		{

 		CSharedMemDesc* shm= new CSharedMemDesc;

 		if(shm != NULL)

 			{

 			err = shm->Open(name, mode, perms);

			if(err != KErrNone)

				{

				delete shm;

				shm = NULL;

				}

 			}						

 		ret = shm;

 		}

 #endif //SYMBIAN_OE_LIBRT

	else if	((L'C' == name[0]) && (L'O' == name[1]) && (L'M' == name[2]) && (L':' == name[4]) && ((name[3] >= L'1') && (name[3] <= L'9')) ||

			(L'I' == name[0]) && (L'R' == name[1]) && (L'C' == name[2]) && (L'O' == name[3]) && (L'M' == name[4]) && (L':' == name[6]) && ((name[5] >= L'1') && (name[5] <= L'9')))

		{

		CSerialDesc* com = new CSerialDesc;

		if (com != NULL)

			{

			err = com->Open(name, mode, perms);

			if(err != KErrNone)

				{

				delete com;

				com = NULL;

				}

			}

		ret = com;

		}

	else //It's a special file, directory or normal file

		{

		RFs& rfs = Backend()->FileSession();

		else //normal file or directory

		    {

		    TFullName fullName;

		    err = GetFullFile(fullName, (const TText16*)name, rfs);

		    if(err != KErrNone)

		    	return NULL;

		    //Try opening as a file

		    CFileDesc* file = new CFileDesc;

			if(file != NULL)

				{

				err = file->Open(rfs, fullName, mode, perms);

				if(err != KErrNone)

					{

					delete file;

					file = NULL;

					}

				}

			ret = file;

			//Check if it is directory, if the open as file failed

		    if(err != KErrNone && CheckIfDirectory(fullName, rfs)) 

				{

				CDirectoryDesc* dir = new CDirectoryDesc;

				if(dir != NULL)

					{

					err = dir->Open(rfs, fullName, mode, perms);

					if(err != KErrNone)

						{

						delete dir;

						dir = NULL;

						}

					}

				ret = dir;

				}

    		}

		}

	if(err == KErrNone && ret == NULL)

    	{	

    	err = KErrNoMemory;

    	}

	return ret;

	}

//Check if a path corresponds to a directory. This is a helper function

//for CFileDescBase::Open()

TBool CFileDescBase::CheckIfDirectory(const TDesC& aPath, RFs& aFs)

	{

	//Check whether its a Drive Name

	if(KMaxDriveName+1 == aPath.Length())

		{

		if(RFs::IsValidDrive(TDriveUnit(aPath)))

			{

			return ETrue;

			}

		}

	//Now check whether it is a directory

	else

		{

		TEntry entry;

		if(aFs.Entry(aPath, entry) == KErrNone)

			{

			if(entry.IsDir())

				{

				return ETrue;

				}

			}

		}

	return EFalse;

	}

// Useful default implementations for CFileDescBase virtual functions.

// Function to be re-implemented in a child class which can seek. 

TInt CFileDescBase::LSeek (off_t& offset, int)

	{

	// minimal implementation for devices which can't seek

	offset=-1;

	return ESPIPE;

	}

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

	{

	// minimal implementation for /dev/null

	aBuf.Zero();	// set length to zero

	TRequestStatus* sp=&aStatus;

	User::RequestComplete(sp,KErrNone);

	}

void CFileDescBase::ReadCancel() {}

TInt CFileDescBase::ReadCompletion (TDes8& /*aBuf*/, TInt aStatus)

	{

	return aStatus;

	}

TInt CFileDescBase::FStat (struct stat *st)

	{

	// minimal implementation: 

	// I am a character device about which little is known

	st->st_mode = S_IFCHR;

	st->st_blksize=0;

	return KErrNone;

	}

void CFileDescBase::Complete (TRequestStatus& aStatus, TInt aResult)

	{

	TRequestStatus* sp=&aStatus;

	User::RequestComplete(sp,aResult);

	}

void CFileDescBase::Write (TDes8& /*aBuf*/, TRequestStatus& aStatus)

	{

	// minimal implementation for /dev/null

	// we will claim to have written all of the data

	Complete(aStatus,KErrNone);

	}

void CFileDescBase::WriteCancel() {}

TInt CFileDescBase::WriteCompletion (TDes8& /*aBuf*/, TInt aStatus)

	{

	return aStatus;

	}

void CFileDescBase::Sync(TRequestStatus& aStatus)

	{

	// minimal implementation for /dev/null

	Complete(aStatus,KErrNone);

	}

void CFileDescBase::SyncCancel() {}

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

	{

	// minimal implementation for /dev/null and other synchronous devices

	Complete(aStatus,KErrNone);

	}

void CFileDescBase::IoctlCancel() 

	{

	return;	// suitable for all synchronous ioctls

	}

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

	{

	TInt ret=aStatus;

	if (ret!=KErrNone)

		return ret;

	int *param = reinterpret_cast<int*> (aParam);

	switch ((unsigned)aCmd)

		{

	case FIONREAD:

	case E32IONREAD:

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

		break;

	case E32IOSELECT:

		*param=(*param)&(E32SELECT_READ|E32SELECT_WRITE);	// but don't block

		break;

	default:

		ret=KErrNotSupported;

		break;

		}

	return ret;

	}

// A CFileDescBase factory function, for socket objects

CFileDescBase* CFileDescBase::Socket(RSocketServ& aSs, int family, int style, int protocol, TInt& err)

	{

	// connect to the Socket Server if necessary

	if (aSs.Handle()==0)

		{

		err=aSs.Connect(TUint(-1));	// allow arbitrary number of requests

		if (err)

			return 0;

		else

			{

			err = aSs.ShareAuto();

			if (err)

				return 0;

			}

		}

	CSockDescBase *socketBase = NULL;

	if (family == AF_LOCAL || family == PF_LOCAL || family == AF_UNIX)

		{

		//coverity[alloc_fn]

		//coverity[assign]

		socketBase = new CFileSocketDesc;

		}

	else

		{

		socketBase = new CSocketDesc;

		}

	if (!socketBase)

		{

		err=KErrNoMemory;

		return 0;

		}

	err = socketBase->Socket(aSs,family,style,protocol);

	if (err)

		{

		delete socketBase;

		if (err == KErrBadName) // Some mismatch in family-style-protocol

			{

			err = EPROTONOSUPPORT;

			}

		//coverity[memory_leak]

		return 0;

		}

	return socketBase;

	}

// minimal implementation of sockets, useful for all non-socket descriptors

void CFileDescBase::RecvFrom(TDes8& /*aDesc*/, TSockAddr& /*from*/, int /*flags*/, TRequestStatus& aStatus)

	{

	// minimal implementation

	Complete(aStatus,ENOTSOCK);

	}

void CFileDescBase::RecvFromCancel() {}

TInt CFileDescBase::CompletionStatus (TInt& /*aLength*/, TInt aStatus)

	{

	return aStatus;

	}

void CFileDescBase::SendTo(TDes8& /*aDesc*/, const struct sockaddr* /* anAddr*/, unsigned long /*aAddrLen*/, int /*flags*/, TRequestStatus& aStatus)

	{

	// minimal implementation

	Complete(aStatus,ENOTSOCK);

	}

void CFileDescBase::SendToCancel() {}

void CFileDescBase::Shutdown(TUint /*aHow*/,TRequestStatus& aStatus)

	{

	// minimal implementation

	Complete(aStatus,ENOTSOCK);

	}

void CFileDescBase::ShutdownCancel() {}

TInt CFileDescBase::Bind(const struct sockaddr* /*addr*/, unsigned long /*size*/)

	{

	return ENOTSOCK;

	}

TInt CFileDescBase::Listen(TUint /*qSize*/)

	{

	return ENOTSOCK;

	}

void CFileDescBase::Accept(CFileDescBase*& /*aNewSocket*/, TRequestStatus& aStatus, RSocketServ& /*aSs*/,  TSockAddr * /*aAddr*/)

	{

	// minimal implementation

	Complete(aStatus,ENOTSOCK);

	}

void CFileDescBase::AcceptCancel() {}

void CFileDescBase::Connect(const struct sockaddr* /*anAddr*/,unsigned long /*aSize*/,TRequestStatus& aStatus)

	{

	// minimal implementation

	Complete(aStatus,ENOTSOCK);

	User::WaitForRequest(aStatus);

	}

void CFileDescBase::ConnectCancel() {}

TBool CFileDescBase::GetConnectionProgress()

	{

	return EFalse;

	}

void CFileDescBase::SetConnectionProgress( TBool /* aInProgress */ ) {}

TInt CFileDescBase::SockName(int /*anEnd*/, struct sockaddr* /*anAddr*/,unsigned long* /*aSize*/)

	{

	return ENOTSOCK;

	}

TInt CFileDescBase::GetSockOpt(TInt  /*anOptionName*/,TInt /*anOptionLevel*/,TDes8& /*anOption*/)

	{

	return ENOTSOCK;

	}

TInt CFileDescBase::SetSockOpt(TInt  /*anOptionName*/,TInt /*anOptionLevel*/,TDesC8& /*anOption*/)

	{

	return ENOTSOCK;

	}

// -----------------------------------------------------------------------------

// CFileDescBase::Fcntl

// Minimal Implementation for fcntl

// -----------------------------------------------------------------------------

//

TInt CFileDescBase::Fcntl(TUint /*anArg*/, TUint aCmd)

	{

	// minimal implementation: 

	if(aCmd == F_GETFL)

		{

		return KErrNotFound;

		}

	return KErrNotSupported;

	}

// -----------------------------------------------------------------------------

// CFileDescBase::Poll

// Checks the file for ready to write/read and exception status

// -----------------------------------------------------------------------------

//

TInt CFileDescBase::Poll(TPollMode /*aMode*/,TBool& aStatus,TInt& /*aErrno*/)

    {

    // always return True, let the derived filedescriptors override

    aStatus = ETrue;

    return 0;

    }

// -----------------------------------------------------------------------------

// CFileDescBase::Poll - Overloaded

// Synchronous non-blocking call that returns current state of the file descriptor

// -----------------------------------------------------------------------------

//

TInt CFileDescBase::Poll(TUint aEvents)

    {

    // We return that the file descriptor is select true for ready to read, 

    // ready to write and error conditions. 

    // Let derived file descriptors override as approp.

    TInt readyEvents = 0;

    if (aEvents & EReadyForReading)

		{

		readyEvents = EReadyForReading;

		}

	if (aEvents & EReadyForWriting)

		{

		readyEvents |= EReadyForWriting;

		}

	if (aEvents & EAnyException)

		{

		readyEvents |= EAnyException;

		}

    return readyEvents;

    }

// -----------------------------------------------------------------------------

// CFileDescBase::NotifyActivity

// Registers with the approp. underlying subsystem for read/write/except notifications

// -----------------------------------------------------------------------------

//

TInt CFileDescBase::NotifyActivity(TUint /*aEvents*/, TRequestStatus& /*aRequest*/, TTimeIntervalMicroSeconds32 /*timeout*/)

	{

    // We return KErrCompletion indicating that this activity is complete for 

    // this descriptor.

    // Let derived file descriptors override as approp.

	return KErrCompletion;

	}

// -----------------------------------------------------------------------------

// CFileDescBase::TweakWatchedEvents

// Requests for fd behaviour specific additional events

// -----------------------------------------------------------------------------

//

void CFileDescBase::TweakWatchedEvents(TUint& /*events*/)

    {

    // No implementation required

    // This version is used for both Redir and pipe desc, it is overridden

    // by socket

    }

// -----------------------------------------------------------------------------

// CFileDescBase::TweakReadyEvents

// Prepares the fd behaviours specific output events

// -----------------------------------------------------------------------------

//

TInt CFileDescBase::TweakReadyEvents(TInt /*errval*/)

    {

    return KErrNone;

    }

// CFileDescBase::CancelNotify

// Cancel an outstanding request for read/write/except notifications

// -----------------------------------------------------------------------------