// 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 "FDESC.H"

 #include "LPOSIX.H"

 #include "LTIME.H"

 #include <string.h>

 #include <stdio_r.h>

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

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

 #include <sys/ioctl.h>

 #include <c32comm.h>

 #include "POSIXIF.H"	// for details of CPosixRequest::iLink

 // Cleanup support

 void CFileDescBase::Cleanup(TAny *aPtr)

 	{

 	((CFileDescBase*)aPtr)->Close();

 	}

 void CFileDescBase::PushLC()

 	{

 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

 	}

 // Private constructor

 inline TPosixRequestQueue::TPosixRequestQueue() 

 : TSglQue<CPosixRequest>(_FOFF(CPosixRequest,iLink)) 

 	{}

 CFileDescBase::CFileDescBase() : iReadTimeout(-1)

 	{

 	}

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

 //CFileDescBase* CFileDescBase::Open(RFs& aSession, const char* name, int mode, int perms, TInt& err)

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

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

 	{

 	CFileDescBase* ret=0;

 	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)

 		{

 		RFs& rfs = static_cast<RFs&>(aSession);

 		TParse path;

 		err=GetFullPath(path,(const TText16*)WIDEP_tmpdir, rfs,NULL);

 		if (err)

 			return 0;

 		CTempFileDesc* tmp= new CTempFileDesc;

 		if (tmp)

 			{

 			err=tmp->Open(rfs,path.DriveAndPath());

 			if (err)

 				{

 				delete tmp;

 				return 0;

 				}

 			}

 		ret=tmp;

 		}

 	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')))

 		{

 		RCommServ& rcs = static_cast<RCommServ&>(aSession);

 		if (!rcs.Handle())	

 			{

 			err=rcs.Connect();	//connect to the server

 			if (err)

 				return 0;

 			}

 		CSerialDesc * tmp = new CSerialDesc;

 		if (tmp)

 			{

 			RCommServ& rcs = static_cast<RCommServ&>(aSession);

 			CleanupStack::PushL(tmp);

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

 			CleanupStack::Pop(tmp);

 			if (err)

 				{

 				delete tmp;

 				return 0;

 				}

 			}

 		ret = tmp;

 		}

 	else

 		{

 		TFullName fullName;

 		RFs& rfs = static_cast<RFs&>(aSession);

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

 		if (err)

 			return 0;

 		CFileDesc* f= new CFileDesc;

 		if (f)

 			{

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

 			if (err)

 				{

 				delete f;

 				return 0;

 				}

 			}

 		ret=f;

 		}

 	err=(ret==0)? KErrNoMemory:KErrNone;

 	return ret;

 	}

 // Useful default implementations for CFileDescBase virtual functions.

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

 	{

 	// minimal implementation for devices which can't seek

 	offset=0;

 	return KErrNone;

 	}

 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 (aCmd)

 		{

 	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;

 		}

 	CSocketDesc* s= new CSocketDesc;

 	if (s==0)

 		{

 		err=KErrNoMemory;

 		return 0;

 		}

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

 	if (err)

 		{

 		delete s;

 		return 0;

 		}

 	return s;

 	}

 // 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::RecvFromCompletion(TInt& /*aLength*/, TInt aStatus)

 	{

 	return aStatus;

 	}

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

 	{

 	// minimal implementation

 	Complete(aStatus,ENOTSOCK);

 	}

 void CFileDescBase::SendToCancel () {}

 TInt CFileDescBase::SendToCompletion(TDes8& /*aDesc*/, TInt aStatus)

 	{

 	return aStatus;

 	}

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

 	{

 	// minimal implementation

 	Complete(aStatus,ENOTSOCK);

 	}

 void CFileDescBase::ShutdownCancel () {}

 TInt CFileDescBase::Bind(TSockAddr& /*anAddr*/)

 	{

 	return ENOTSOCK;

 	}

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

 	{

 	return ENOTSOCK;

 	}

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

 	{

 	// minimal implementation

 	Complete(aStatus,ENOTSOCK);

 	}

 void CFileDescBase::AcceptCancel () {}

 void CFileDescBase::Connect(TSockAddr& /*anAddr*/,TRequestStatus& aStatus)

 	{

 	// minimal implementation

 	Complete(aStatus,ENOTSOCK);

 	}

 void CFileDescBase::ConnectCancel () {}

 TInt CFileDescBase::SockName(int /*anEnd*/, TSockAddr& /*anAddr*/)

 	{

 	return ENOTSOCK;

 	}

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

 	{

 	return ENOTSOCK;

 	}

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

 	{

 	return ENOTSOCK;

 	}

 // Queue handling

 void CFileDescBase::AddLast(CPosixRequest& aRequest, IOQueues aQueue)

 	{

 	TPosixRequestQueue& queue = iQueues[aQueue];

 	queue.AddLast(aRequest);

 	if (queue.IsFirst(&aRequest))

 		aRequest.StartAsynch();	// queue was empty, so start straight away

 	}

 void CFileDescBase::Remove(CPosixRequest& aRequest, IOQueues aQueue)

 	{

 	TPosixRequestQueue& queue = iQueues[aQueue];

 	TBool wasFirst = queue.IsFirst(&aRequest);

 	queue.Remove(aRequest);

 	if (wasFirst)

 		{

 		if (!queue.IsEmpty())

 			queue.First()->StartAsynch();	// start the next outstanding request

 		}

 	}

 // Generic (non-virtual) handling for Close

 TInt CFileDescBase::Close()

 	{ 

 	TInt err=KErrNone;

 	if (--iDupCount < 0)

 		{

 		err=FinalClose();

 		delete this;

 		}

 	return err;

 	}

 TInt CFileDescBase::FinalClose()

 	{

 	return KErrNone;

 	}

 // Simple implementation of File handling

 static int MapMode(int aMode, TUint& fMode)

 	{

 	// EPOC32 doesn't support Write-Only

 	if (aMode & (O_WRONLY|O_RDWR))

 		{

 		fMode = EFileWrite;

 		fMode |= (aMode & O_EXCL) ? EFileShareExclusive : EFileShareAny;	

 		}

 	else

 		{

 		fMode = EFileRead;

 		fMode |= (aMode & O_EXCL) ? EFileShareExclusive : EFileShareReadersOnly;	

 		}

 	fMode |= (aMode & O_TEXT) ? EFileStreamText : EFileStream;

 	return aMode & (O_CREAT|O_TRUNC|O_APPEND|O_EXCL);

 	}

 CFileDesc::CFileDesc()

 	:CFileDescBase(), iSize(EBufferSize), iExt(-1)

 	{}

 CFileDesc::~CFileDesc()

 	{

 	iFile.Close();

 	delete [] iBuffer;

 	}

 TInt CFileDesc::FinalClose()

 	{

 	return DoSync();

 	}

 TInt CFileDesc::Open(RFs& aSession, const TDesC& aName, int mode, int /*perms*/)

 	{

 	TInt err;

 	TUint fMode;

 	iDrive=(TInt16)TDriveUnit(aName);

 	// Create  = make new file, can return KErrAlreadyExists

 	// Open    = open an existing file, can return KErrPathNotFound or KErrNotFound

 	// Replace = open a new file, zapping the existing one if necessary

 	int mapped=MapMode(mode, fMode);

 	switch (mapped)

 		{

 		case O_CREAT|O_EXCL:

 			err = iFile.Create(aSession, aName, fMode);

 			break;

 		case O_CREAT|O_TRUNC:

 			err = iFile.Replace(aSession, aName, fMode);

 			break;

 		case O_TRUNC:

 			err = iFile.Open(aSession, aName, fMode);

 			if (err == KErrPathNotFound)

 			    {

 			    // missing directories etc, so fail directly

 			    }

 			else

 			    {

 			    iFile.Close();

 			    err = iFile.Replace(aSession, aName, fMode);

 			    }

 			break;

 		// Everything else is assumed to mean open existing file,

 		// If the file isn't there, O_CREAT implies that we should make it

 		default:

 			err = iFile.Open(aSession, aName, fMode);

 			if (err == KErrNotFound && (mapped & O_CREAT))

 			    err = iFile.Create(aSession, aName, fMode);

 			if (err == KErrNone && (mapped & O_APPEND))

 			    {

 				iPos = Ext();

 				if (iPos < 0)

 					err = iPos;

 			    }

 			break;

 		}

 	if ((mode & O_BUFFERED) == 0)

 		iSize = 0;

 	return err;

 	}

 TInt CFileDesc::LSeek (int& offset, int whence)

 	{

 	TInt pos=offset;

 	TInt ext=Ext();

 	if (ext < 0)

 		return ext;

 	switch (whence)

 		{

 	case SEEK_SET:

 		break;

 	case SEEK_CUR:

 		pos += Pos();

 		break;

 	case SEEK_END:

 		pos += ext;

 		break;

 	default:

 		return KErrArgument;

 		}

 	TInt ret = KErrNone;

 	if (pos < 0)

 		{

 		pos = 0;

 		ret = KErrEof;

 		}

 	else if (pos > ext)

 		{

 		pos = ext;

 		ret = KErrEof;

 		}

 	switch (iState)

 		{

 	case EAlloc:

 		iPos = pos;

 		break;

 	case EReading:

 		{

 		TInt lag = iPos - pos;

 		if (lag >= 0 && lag <= (iEnd - iBuffer))

 			iPtr = iEnd - lag;

 		else

 			{

 			iPtr = iEnd;

 			iPos = pos;

 			}

 		}

 		break;

 	case EWriting:

 		if (pos != Pos())

 			{

 			ret = Flush();

 			if (ret == KErrNone)

 				iPos = pos;

 			}

 		break;

 		}

 	offset = pos;

 	return ret;

 	}

 void CFileDesc::MapStat(struct stat& st, const TTime& aModTime, TUint& aAttr)

     {

     st.st_mode = (aAttr&KEntryAttDir) ? S_IFDIR:S_IFREG;

     if ((aAttr&KEntryAttReadOnly)==0)

 	st.st_mode |= S_IWUSR;

     st.st_nlink = 1;

     st.st_mtime = as_time_t(aModTime);

     st.st_blksize=512;

     }

 TInt CFileDesc::FStat (struct stat* st)

 	{

 	TInt err;

 	TUint att;

 	TTime modtime;

 	err = iFile.Att(att);

 	if (!err)

 	    {

 	    err = iFile.Modified(modtime);

 	    if (!err)

 		{

 		err=Ext();

 		if (err >= 0)

 		    {

 		    st->st_size = err;

 		    st->st_dev = st->st_rdev = iDrive;

 		    MapStat(*st, modtime, att);

 		    return 0;

 		    }

 		}

 	    }

 	return err;

 	}

 TInt CFileDesc::Alloc()

 	{

 	if (iSize)

 		{

 		iBuffer = new TUint8[iSize];

 		if (iBuffer == 0)

 			return KErrNoMemory;

 		}

 	return KErrNone;

 	}

 TInt CFileDesc::FileRead(TUint8* aPtr,TInt aLength)

 	{

 	TPtr8 ptr(aPtr,aLength);

 	TInt r=iFile.Read(iPos,ptr);

 	if (r == KErrNone)

 		{

 		r = ptr.Length();

 		iPos += r;

 		if (r < aLength)

 			iExt = iPos;

 		}

 	return r;

 	}

 TInt CFileDesc::FileWrite(TUint8* aPtr,TInt aLength)

 	{

 	TPtrC8 ptr(aPtr,aLength);

 	TInt r = iFile.Write(iPos,ptr);

 	if (r == KErrNone)

 		{

 		iPos += aLength;

 		if (iPos > iExt && iExt >= 0)

 			iExt = iPos;

 		}

 	return r;

 	}

 TInt CFileDesc::Flush()

 	{

 	if (iPtr > iBuffer)

 		{

 		TInt r = FileWrite(iBuffer, iPtr-iBuffer);

 		if (r < 0)

 			return r;

 		iPtr = iBuffer;

 		}

 	return KErrNone;

 	}

 TInt CFileDesc::DoRead (TDes8& aDesc)

 	{

 	if (iState != EReading)

 		{

 		TInt ret = (iState == EAlloc) ? Alloc() : Flush();

 		if (ret != KErrNone)

 			return ret;

 		iState = EReading;

 		iPtr = iEnd = iBuffer;

 		}

 	TUint8* p = (TUint8*) aDesc.Ptr();

 	TInt max = aDesc.MaxLength();

 	TInt avail = iEnd - iPtr;

 	TInt len = Min(max, avail);

 	if (len > 0)

 		{

 		p = Mem::Copy(p, iPtr, len);

 		iPtr += len;

 		max -= len;

 		}

 	if (max >= iSize)

 		{

 		TInt ret = FileRead(p, max);

 		if (ret < 0)

 			return ret;

 		p += ret;

 		}

 	else if (max > 0)

 		{

 		TInt ret = FileRead(iBuffer, Min(max + EReadAhead, iSize));

 		if (ret < 0)

 			return ret;

 		len = Min(max, ret);

 		p = Mem::Copy(p, iBuffer, len);

 		iPtr = iBuffer + len;

 		iEnd = iBuffer + ret;

 		}

 	aDesc.SetLength(p-aDesc.Ptr());

 	return KErrNone;

 	}

 void CFileDesc::Read (TDes8& aDesc, TRequestStatus& aStatus)

 	{

 	Complete(aStatus,DoRead(aDesc));

 	}

 TInt CFileDesc::DoWrite (TDes8& aDesc)

 	{

 	if (iState != EWriting)

 		{

 		if (iState == EAlloc)

 			{

 			TInt ret = Alloc();

 			if (ret != KErrNone)

 				return ret;

 			}

 		else

 			iPos -= iEnd - iPtr;

 		iState = EWriting;

 		iPtr = iBuffer;

 		iEnd = iBuffer + iSize;

 		}

 	TUint8* p = (TUint8*) aDesc.Ptr();

 	TInt max = aDesc.Length();

 	TInt avail = iEnd - iPtr;

 	TInt len = Min(max, avail);

 	if (len > 0)

 		{

 		iPtr = Mem::Copy(iPtr, p, len);

 		p += len;

 		max -= len;

 		}

 	if (max == 0)

 		return KErrNone;

 	TInt r=Flush();

 	if (r < 0)

 		return r;

 	if (max >= iSize)

 		return FileWrite(p, max);

 	iPtr = Mem::Copy(iPtr, p, max);

 	return KErrNone;

 	}

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

 	{

 	Complete(aStatus,DoWrite(aDesc));

 	}

 TInt CFileDesc::DoSync()

 	{

 	if (iState == EWriting)

 		{

 		TInt ret = Flush();

 		if (ret < 0)

 			return ret;

 		}

 	return iFile.Flush();

 	}

 void CFileDesc::Sync(TRequestStatus& aStatus)

 	{

 	Complete(aStatus,DoSync());

 	}

 TInt CFileDesc::Pos()

 	{

 	TInt pos = iPos;

 	if (iState == EReading)

 		pos -= (iEnd - iPtr);

 	else if (iState == EWriting)

 		pos += (iPtr - iBuffer);

 	return pos;

 	}

 TInt CFileDesc::Ext()

 	{

 	if (iExt < 0)

 		{

 		TInt r = iFile.Size(iExt);

 		if (r < 0)

 			return r;

 		}

 	return Max(iExt, Pos());

 	}

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

 	{

 	TInt ret=aStatus;

 	if (ret!=KErrNone)

 		return ret;

 	// some useful sums about the current state of the file

 	TInt curoff = Pos();

 	TInt size = Ext();

 	if (size < 0)

 		ret = size;

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

 	switch (aCmd)

 		{

 	case E32IONREAD:

 		if (ret==KErrNone)

 			*param=(size-curoff);

 		break;

 	case E32IOSELECT:

 		{

 		int mask=E32SELECT_WRITE;

 		if ((size-curoff)>0)

 			mask |= E32SELECT_READ;

 		*param=(*param)&mask;	// but don't block

 		}

 		break;

 	default:

 		ret=KErrNotSupported;

 		break;

 		}

 	return ret;

 	}

 // Extra support for temporary files

 TInt CTempFileDesc::Open(RFs& aSession, const TDesC& aPath)

 	{

 	iSession=aSession;

 	iDrive=(TInt16)TDriveUnit(aPath);

 	TInt err=iFile.Temp(aSession, aPath, iName, EFileShareAny);

 	return err;

 	}

 TInt CTempFileDesc::FinalClose()

 	{

 	iFile.Close();

 	TInt err=iSession.Delete(iName);

 	return err;

 	}