/*
* 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();
        TUint attribval;
        TFullName fullName;
        err = GetFullFile(fullName, (const TText16*)name, rfs);
        if(err != KErrNone)
            return NULL;
        int ret1 = rfs.Att(fullName, attribval);
        if (ret1 == 0 && ((attribval & (KEntryAttHidden | KEntryAttSystem))== (KEntryAttHidden | KEntryAttSystem)))
            {
            TSpecialFileType fileType = _SystemSpecialFileBasedFilePath(name, err, rfs);
            if(fileType  == EFileTypeMkFifo) //special file, FIFO
                {
                ret = CFileTable::FifoOpen(name, mode, perms, err);
                }
            else if(fileType  == EFileTypeSymLink) //special file, symlink
                {
                ret = CFileTable::LinkOpen(name, mode, perms, err, rfs);
                }
            }
		else //normal file or directory
		    {
     	    //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
// -----------------------------------------------------------------------------
//
void CFileDescBase::CancelNotify()
	{
	// do nothing
	return;
	}


// Generic (non-virtual) handling for Close
EXPORT_C TInt CFileDescBase::Close()
	{ 
	TInt err = KErrNone;
	//Decrement the dup count and mark this FD as invalid if dupcount is 0
	if ( --iDupCount < 0 )
		{
		iFdAttrib |= KInvalidFd;
		//delete this FD only if its not mmaped and being used
		if(!(iFdAttrib & KMMapedFd))
			{
			err=FinalClose();
			//Release the Lock now
			delete this;
			}
		}
	return err;
	}

TInt CFileDescBase::FinalClose()
	{
	return KErrNone;
	}

void CFileDescBase::SetFids(void *)
	{
	// nada (virtual)
	}

// 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;
		}
	else
		{
		fMode = EFileRead;
		}

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

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

CFileDesc::CFileDesc()
	:CFileDescBase(), iSize(EBufferSize), iExt(-1)
	{}

void CFileDesc::SetState(const TDes& params)
	{
	TFileName name;
	iFile.FullName(name);
	iDrive = (TInt16)TDriveUnit(name);

	TLex lexr(params);
	lexr.Val(iPos);
	lexr.Inc();
	lexr.Val(iExt);
	lexr.Inc();
	lexr.Val(iFcntlFlag);
	lexr.Inc();
	lexr.Val(iFdAttrib, EDecimal);
	lexr.Inc();
	lexr.Val(iPos);
	lexr.Inc();
	lexr.Val(iExt);
	lexr.Inc();
	lexr.Val(iSize);
	
	}

CFileDesc::~CFileDesc()
	{
	iFile.Close();
	if(iBuffer)
		{
		RHeap* oldHeap = User::SwitchHeap(Backend()->Heap());
		delete [] iBuffer;
		User::SwitchHeap(oldHeap);
		}
	}

TInt CFileDesc::FinalClose()
	{
	TInt err = DoSync();
	iLock.Close();
	return err;
	}
	
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);
	// if the file is in \sys, use EFileShareReadersOnly not EFileShareReadersOrWriters
	TParsePtrC pars(aName);
	if (pars.Path().FindF(_L("\\SYS\\")) == 0)
		{
		fMode &= ~EFileShareReadersOrWriters;
		fMode |= EFileShareReadersOnly;
		}
	
	// if the file is in \resource, dont use EFileShareReadersOrWriters
	if (pars.Path().FindF(_L("\\resource\\")) == 0)
		{
		fMode &= ~EFileShareReadersOrWriters;
		fMode |= EFileShareReadersOnly;
		}

	//Set iFcntlFlag flag	
	iFcntlFlag = mode & O_ACCMODE;	
    
    if(mode & O_APPEND) 
    	{
    	iFcntlFlag |= O_APPEND;
    	}
    	
	TInt fileMode = 0;
	TBool created = EFalse;
	//store the open modes in the file descriptor object

	switch(perms & (S_IRUSR | S_IWUSR ))  
		{
		case S_IRUSR | S_IWUSR: //owner read write
		case S_IWUSR :         //owner write   
		    {
			break;
			}
			case S_IRUSR:           //owner read 
			{
			fileMode = KEntryAttReadOnly;
			break;
			}
		default:
			{
			 break;
			}
		}

	switch (mapped)
		{
		case O_CREAT|O_EXCL: //For O_EXCL if file exists then return error
			err = iFile.Create(aSession, aName, fMode);
            if(err)   
            	{
                return err;
                }  
                created = ETrue ;
			break;
		case O_CREAT|O_TRUNC:
			err = iFile.Replace(aSession, aName, fMode);
			if(!err)
				{
				created = ETrue;
				}   
			break;
		case O_TRUNC:
			err = iFile.Open(aSession, aName, fMode);
			if(!err)				
			    err = iFile.SetSize(0);
			break;
		case O_CREAT|O_EXCL|O_APPEND: //if file exists then return error
			err = iFile.Create(aSession, aName, fMode);
            if(err)   
            	{
                return err;
                }  
                created = ETrue ;
			break;
		case O_CREAT|O_EXCL|O_TRUNC: //if file exists then return error
			err = iFile.Create(aSession, aName, fMode);
            if(!err)   
            	{
                err = iFile.SetSize(0);
                created = ETrue ;                
                }  
            else
            	{
            	return err;
            	}  
			break;
		case O_EXLOCK: //emulating exclusive locks
			err = iFile.Open(aSession, aName, fMode);
            if(err == KErrNone)   
            	{
            	FSIZE fileSize = 0;
            	err = iFile.Size(fileSize);
            	if(fileSize <= 0 )
            		return KErrNotSupported;
            	
            	if(err == KErrNone)
            		{
            		err = iFile.Lock(0, fileSize);
            		}
                } 
   			
            if(err != KErrNone)   
            	{
                return err;
                } 
			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)   
					{
					created = ETrue;
					}  

				} 
			if((err == KErrArgument) &&(mode == (O_CREAT | O_RDONLY)))
				{
				TUint CrMode = EFileShareReadersOrWriters | EFileWrite ;
				CrMode |= (mode & O_TEXT) ? EFileStreamText : EFileStream;
				err = iFile.Create(aSession , aName , CrMode);
			  
				if(!err)  
					{
					created = ETrue;
					iFile.Close() ;
					err = iFile.Open(aSession, aName , fMode);
					}
				}

			if (err == KErrNone && (mapped & O_APPEND))
			    {
				iPos = Ext();
				if (iPos < 0)
					err = iPos;
			    }
			break;
		
		}
	if ((mode & O_BUFFERED) == 0)
		iSize = 0;
	
	//If File is to be opened for O_CREAT | O_RDONLY, set the corresponding attributes
	if(created && fileMode) 
		{
		err = iFile.SetAtt(fileMode, 0) ;	
		}
		
	if (!err)
		{
		err = Alloc();
		}
	
	if(err == KErrNone)
		{
		err = CreateLock();
		}
	
	return err;
	}

TInt CFileDesc::LSeek (off_t& offset, int whence)
	{
	//return if its an invalid fd
	//This scenario comes when the file is closed, but mmap still exists
	if(iFdAttrib & KInvalidFd)
		{
		return KErrBadHandle;	
		}
	iLock.Wait();
	FSIZE pos=offset;
	FSIZE ext=Ext();
	if (ext < 0)
		{
		iLock.Signal();
		return ext;
		}
	switch (whence)
		{
		case SEEK_SET:
			break;
		case SEEK_CUR:
			pos += Pos();
			break;
		case SEEK_END:
			pos += ext;
			break;
		default:
			{
			iLock.Signal();
			return KErrArgument;
			}
		}

	TInt ret = KErrNone;
	if (pos < 0)
		{
		iLock.Signal();
		return KErrArgument;
		}
	else if (pos >= ext)
		{
		ret = Flush();		
		if (!ret)
			{
			iState = EAlloc;
			}
		}

	switch (iState)
		{
		case EAlloc:
			iPos = pos;
			break;
		case EReading:
			{
			FSIZE 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)
					{
					iLock.Signal();
					return ret;
					}
					iPos = pos;
				}
			break;
		default:
			{
			//Do nothing
			}
		}
	offset = pos;
	iLock.Signal();
	return ret;
	}

void CFileDesc::MapStat(struct stat& st, const TTime& aModTime, TUint& aAttr, const mode_t aMode)
    {
    if ( aMode == S_IFREG)
        {
        st.st_mode = (aAttr&KEntryAttDir) ? S_IFDIR: S_IFREG;
        }
    else
        {
        st.st_mode = aMode;
        }
    
    if ((aAttr&KEntryAttReadOnly))
        {
		st.st_mode |= S_IRUSR;
	    }
	 else
	 	{
	 	st.st_mode = st.st_mode | S_IWUSR | S_IRUSR;
	 	}
	    
    st.st_nlink = (S_IFLNK == st.st_mode) ? 2 : 1;
	TTimeIntervalSeconds res;
	const TTime KEpocTime(MAKE_TINT64(0x00dcddb3,0x0f2f8000));    // 00:00, Jan 1st 1970
    if(aModTime.SecondsFrom(KEpocTime, res))
		{
		st.st_mtime = -1;
		st.st_atime = -1 ;
		st.st_ctime = -1;
		}
	else
		{
		st.st_mtime = res.Int();
		st.st_ctime = st.st_atime = st.st_mtime ;   //here modification and access time are same
		}
    st.st_blksize=512;
    }

TInt CFileDesc::FStat (struct stat* st)
	{
	//return if its an invalid fd
	if(iFdAttrib & KInvalidFd)
		{
		return KErrBadHandle;	
		}
	TInt err;
	TUint att;
	TTime modtime;
	
	err = iFile.Att(att);
	if (!err)
	    {
	    err = iFile.Modified(modtime);
	    if (!err)
		{
		FSIZE ext=Ext();
		if (ext >= 0)
		    {
		    st->st_size = ext;
		    st->st_dev = st->st_rdev = iDrive;
		    MapStat(*st, modtime, att);
		    return 0;
		    }
		else
			err = ext;
		}
	    }
	return err;
	}

TInt CFileDesc::SetAtt(TUint aSetAttMask, TUint aClearAttMask) 
	{
	return iFile.SetAtt(aSetAttMask , aClearAttMask) ;
	}

TInt CFileDesc::Alloc()
	{
	if (iSize)
		{
		//Delete if iBuffer is holding some memory already
		if (iBuffer)
			{
			delete [] iBuffer;
			}
		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);
	if (iExt >= 0) 
   		{ 
        if (iPos > iExt) 
    	    { 
			iFile.SetSize(iPos); 
			} 
		}
	
	// Check if the specified file is opened in O_APPEND 
	// mode and set right the file write position
	if(iFcntlFlag & O_APPEND)
		{
		FSIZE bytes=0;
		TInt ret = iFile.Size(bytes);
		if (ret < 0)
			return ret;
		iPos = Max(bytes, Pos());
		}
		
	TInt r = iFile.Write(iPos,ptr);
	if (r == KErrNone)
		{
		r = ptr.Length();
		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)
		{
		if (iState != EAlloc)
			{
			TInt ret = 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 aDesc.Length();
	}

void CFileDesc::Read (TDes8& aDesc, TRequestStatus& aStatus)
	{
	//return if its an invalid fd
	if(iFdAttrib & KInvalidFd)
		{
		Complete(aStatus, KErrBadHandle);
		return;
		}
	//Acquire the Lock before read and release it later
	iLock.Wait();
	Complete(aStatus,DoRead(aDesc));
	iLock.Signal();
	}

TInt CFileDesc::DoWrite (TDes8& aDesc)
	{
	if (iState != EWriting)
		{
		if (iState != EAlloc)
			{
			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 len;
	TInt r=Flush();
	if (r < 0)
		return r;
	if (max >= iSize)
		return  len + FileWrite(p, max);
	iPtr = Mem::Copy(iPtr, p, max);
	return len + max;
	}

void CFileDesc::Write(TDes8& aDesc, TRequestStatus& aStatus)
	{
	//return if its an invalid fd
	if(iFdAttrib & KInvalidFd)
		{
		Complete(aStatus, KErrBadHandle);
		return;
		}
	//Acquire the Lock before write and release it later
	iLock.Wait();
	Complete(aStatus,DoWrite(aDesc));
	iLock.Signal();
	}

TInt CFileDesc::DoSync()
	{
	if (iState == EWriting)
		{
		TInt ret = Flush();
		if (ret < 0)
			return ret;
		}
	return iFile.Flush();
	}

void CFileDesc::Sync(TRequestStatus& aStatus)
	{
	iLock.Wait();
	Complete(aStatus,DoSync());
	iLock.Signal();
	}

FSIZE CFileDesc::Pos()
	{
	FSIZE pos = iPos;
	if (iState == EReading)
		pos -= (iEnd - iPtr);
	else if (iState == EWriting)
		pos += (iPtr - iBuffer);
	return pos;
	}

FSIZE CFileDesc::Ext()
	{
	TInt r = iFile.Size(iExt);
	if (r < 0)
		return r;
	return iExt;
	}

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
	FSIZE curoff = Pos();
	FSIZE size = Ext();
	if (size < 0)
		ret = size;
	int *param=reinterpret_cast<int*> (aParam);
	switch ((unsigned)aCmd)
		{
	case FIONREAD:
	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;
	}


#if defined(SYMBIAN_OE_LARGE_FILE_SUPPORT) && !defined(SYMBIAN_OE_NO_LFS)
// this needs to be corrected once the api which gives the large file size is available.
//#define MAX_SIZE	LLONG_MAX  /* 2^63-1  - MAX file size */
#define MAX_SIZE    INT_MAX    /* 2^31-1  - MAX file size */
#else
#define MAX_SIZE 	INT_MAX    /* 2^31-1  - MAX file size */
#endif //SYMBIAN_OE_LARGE_FILE_SUPPORT && !SYMBIAN_OE_NO_LFS

TInt CFileDesc::ProcessLockParams(FSIZE& pos, FSIZE& lock_len, TInt& lock_type, struct flock* lock)
    {
    TInt retVal=0;
    lock_type = lock->l_type;
	if(!lock->l_len) 		//if len = 0 then lock must be extended to the system limit for max file size
		{
		lock_len=MAX_SIZE;
		}
	else 		//len argument is non-zero
		{
		lock_len = lock->l_len;
		}
	pos =lock->l_start;	//offset		
	switch( lock->l_whence )
		{
		case SEEK_SET:
		
			if(pos<0)
				{
				retVal = KErrArgument; 	
				return retVal;	
				}
			else
				break;
		case SEEK_CUR:
			pos += iPos;	//current position + offset
			break;
		case SEEK_END: 
			retVal = iFile.Size(pos); 								
			switch( retVal)
				{
				case KErrNone: 
					pos += lock->l_start;	//file size + ofset
					break;
				default: 
					return retVal; 								
				}
			
			if(pos<0)
				{
				retVal = KErrArgument; 	
				return retVal;	
				}
			break;
		default: 
			retVal = KErrArgument;	//invalid argument
			return retVal;																	
		 }		
			
	if( lock_len < 0)
		{
		pos += lock_len;
		lock_len = -lock_len;
		}
    return retVal;
     }
// -----------------------------------------------------------------------------
// CFileDesc::Fcntl
// Symbian File Specific Implementation for fcntl
// There is no mapping from Symbian RFile for File fcntl.
// This implementation supports fcntl with F_SETFL and F_GETFL as cmd
// We can set the Flag as Blocking or Non-Blocking.
// -----------------------------------------------------------------------------
//
TInt CFileDesc::Fcntl(TUint anArg, TUint aCmd)
	{
	struct flock *lock = NULL;
	FSIZE pos = 0,lock_len = -1;
	TInt lock_type = -1;
	//return if its an invalid fd
	if(iFdAttrib & KInvalidFd)
		{
		return KErrBadHandle;
		}
	TInt retVal = KErrNone;
	//fcntl supports only F_SETFL and F_GETFL for Non-Blocking I/O
	//If aCmd and anArg does not match these, return with Error
	switch( aCmd )
		{
		case F_SETFL:
			{
			//Set the fcntl Flag
			if((anArg == O_APPEND) || (anArg == O_NONBLOCK)) 
				{
				iFcntlFlag |=  anArg ;	
				}
		retVal = 0 ;
		break;
			}
		case F_GETFL:
			{
			//Return fcntl flag
			retVal = iFcntlFlag;
			break;
			}
		case F_GETFD:
			{
			if(iFdAttrib & KCloseonExec)
				{
				retVal = 1;
				}
			break;
			}
		case  F_SETFD:
			{
			if(anArg == 1) 
				{
				iFdAttrib |= SET_CLOSE_ON_EXEC_FLG; // (1 << 2) ;
				retVal = anArg;
				}
			else if(anArg == 0 ) 
				{
				iFdAttrib &= ~SET_CLOSE_ON_EXEC_FLG; //(1 << 2) ;
				retVal = anArg;
				}
			else  
				{
				retVal = KErrArgument;    //return invalid argument 
				}
			break;
			}
		case F_GETLK:
			{
			lock = (struct flock*)anArg;				
		    retVal=ProcessLockParams(pos, lock_len, lock_type, lock);
		    if(retVal)
		    return retVal;
		    switch( lock_type)
				{
				case F_WRLCK:	
					retVal =  iFile.Lock(pos ,lock_len); 	//try to lock the region.
					if (retVal  == KErrNone)
						{						
						retVal =  iFile.UnLock(pos ,lock_len);   //if previous lock() is successful then unlock the region
						lock->l_type = F_UNLCK;				     //indication that region can be locked
						}
					else
						{
						retVal = KErrNone;		//region cant be lock. return success, but don't change lock->l_type
						}
					break;
				default:
					retVal = KErrArgument;								
				}
			break;
			}	 
		case F_SETLK:
			{
			lock = (struct flock*)anArg;
			retVal=ProcessLockParams(pos, lock_len, lock_type, lock);
			if(retVal)
			return retVal;
		    switch( lock_type)
				{
				case F_WRLCK:
					retVal =  iFile.Lock(pos ,lock_len);	//try to lock without waiting
					break;
				case F_UNLCK:
					retVal =  iFile.UnLock(pos ,lock_len);	//try to unlock without waiting
					break;
				case F_RDLCK:
					retVal = KErrNotSupported;

				default:
				retVal = KErrArgument;    //return invalid argument 
				}
			break;
			}
		default:
			retVal = KErrNotSupported;
		}
	return retVal;
	}

// -----------------------------------------------------------------------------
// CFileDesc::Truncate
// Symbian File Specific Implementation for Truncate
// This will truncate the file which is opened in write mode
// -----------------------------------------------------------------------------
//
TInt CFileDesc::Truncate(off_t anOffset)
	{
	TInt retVal;
	//return if its an invalid fd
	if(iFdAttrib & KInvalidFd)
		{
		return KErrBadHandle;
		}
	iExt = anOffset;
	retVal = iFile.SetSize(anOffset);
	if (retVal == KErrNotSupported)
		{
		return KErrArgument;//to work around RFile64::SetSize() return value
		}
	return retVal;
	}

// Extra support for temporary files
TInt CTempFileDesc::Open(const wchar_t* aName, TInt mode)
	{
	iSession = Backend()->FileSession();
	
	TFileName filePath;
	if (mode & O_TMPFILE) //from tmpfile()
		{				
		//obtain original mode for tmpfile()
		mode &= (~O_TMPFILE);
		filePath.Copy((const TText*)aName);
		}
	else //for "TMP:"
		{
		TParse path;
		TInt err = GetFullPath(path, (const TText16*)WIDEP_tmpdir, NULL);
		if (err != KErrNone)
			{
			return err;	
			}				
		filePath.Copy(path.DriveAndPath());
		}

	if((mode & O_BUFFERED) == 0)
		{
		setSize(0);
		}
	iFcntlFlag = mode & O_ACCMODE;//setting the fcntl flag
	TInt ret = Alloc();
	if (ret != KErrNone)
		{
		return ret;
		}
	TFileName aPathName;
	aPathName.Append(iSession.GetSystemDriveChar());
	aPathName.Append(TChar(KDriveDelimiter));
	aPathName.Append(_L("\\System\\temp"));	
	if (filePath.Find(aPathName) == 0)
		{			
		ret = iSession.MkDir(filePath);
		if (ret != KErrNone && ret != KErrAlreadyExists)
			{
			return ret;	
			}		
		else
			{
			ret = iFile.Temp(iSession, filePath, iName, EFileShareReadersOrWriters);
			}		
		}			
	else		
		{
		ret = iFile.Create(iSession, filePath, EFileShareReadersOrWriters);			
		}	
	return ret;		
	}

TInt CTempFileDesc::FinalClose()
	{	
  	TInt ret = iFile.FullName(iName);
  	if (ret != KErrNone)
  		{
  		return ret;
  		}
  	iFile.Close();
	return iSession.Delete(iName);
	}

#ifdef SYMBIAN_OE_LIBRT
// -----------------------------------------------------------------------------
// CSharedMemDesc::CSharedMemDesc : Constructor
// Constructs sharedmemory Descriptor
// -----------------------------------------------------------------------------
CSharedMemDesc::CSharedMemDesc()
	{
	iLock.CreateLocal();
	}

// -----------------------------------------------------------------------------
// CSharedMemDesc::CSharedMemDesc : Destructor
// Destructor for sharedmemory Descriptor
// -----------------------------------------------------------------------------
CSharedMemDesc::~CSharedMemDesc()
	{
	iLock.Close();	
	}

// -----------------------------------------------------------------------------
// CSharedMemDesc::Open
// Gives sharedmemory Descriptor
// -----------------------------------------------------------------------------
TInt CSharedMemDesc::Open(const wchar_t* aName, int mode, int perms)
	{
	int aerr = 0, err =0;
	void* ptr = NULL;
	TInt shmkey = 0;
	TInt shmid = 0;
	struct shmid_ds *buf = NULL;
	
	mode &= (~O_SHMFLG);
	if(mode == O_WRONLY)
		{
		return KErrNone;
		}		
		
	TFileName shrdmemname;
	shrdmemname.Copy((const TText*)aName);					 			
	
	iPerms = perms;
	iFcntlFlag = mode & O_ACCMODE;
	shmkey = GeneratePathKey(shrdmemname);
	switch (mode)
		{		
		case O_CREAT:
		case O_CREAT|O_RDWR:
			shmid = Backend()->iIpcS.shmget(shmkey, SHM_CHUNKSIZE, IPC_CREAT|perms, aerr);
			if (shmid == -1)
				{
				err = aerr;
				return err;
				}
		break;
		case O_TRUNC:
		case O_TRUNC|O_RDWR:
		case O_CREAT|O_TRUNC:
			shmid = Backend()->iIpcS.shmget(shmkey, SHM_CHUNKSIZE, IPC_CREAT|perms, aerr);
			if (shmid == -1)
				{
				err = aerr;
				return err;
				}
			if (Backend()->iIpcS.shmctl(shmid, IPC_RMID, buf, aerr) == -1)
				{
				err = aerr;
				return err;
				}
			shmid = Backend()->iIpcS.shmget(shmkey, SHM_CHUNKSIZE, IPC_CREAT|perms, aerr);
			if (shmid == -1)
				{
				err = aerr;
				return err;
				}
		break;
		case O_CREAT|O_EXCL:
		case O_CREAT|O_EXCL|O_RDWR:
			shmid = Backend()->iIpcS.shmget(shmkey, SHM_CHUNKSIZE, IPC_CREAT|IPC_EXCL|perms, aerr);
			if (shmid == -1)
				{
				err = aerr;
				return err;
				}
		break;
		case O_CREAT|O_EXCL|O_TRUNC:
		case O_CREAT|O_EXCL|O_TRUNC|O_RDWR:
			shmid = Backend()->iIpcS.shmget(shmkey, SHM_CHUNKSIZE, IPC_CREAT|IPC_EXCL|perms, aerr);
			if (shmid == -1)
				{
				err = aerr;
				return err;
				}
			if (Backend()->iIpcS.shmctl(shmid, IPC_RMID, buf, aerr) == -1)
				{
				err = aerr;
				return err;
				}
			shmid = Backend()->iIpcS.shmget(shmkey, SHM_CHUNKSIZE, IPC_CREAT|IPC_EXCL|perms, aerr);
			if (shmid == -1)
				{
				err = aerr;
				return err;
				}
		break;
		default:
		shmid = Backend()->iIpcS.shmget(shmkey, SHM_CHUNKSIZE, perms, aerr);
		if (shmid == -1)
			{
			err = aerr;
			return err;
			}
		break;		
		}
	ptr = Backend()->iIpcS.shmat(shmid, (void *)NULL, 0, aerr);
	if (ptr == (void*)-1)
		{
		err = aerr;
		return err;
		}
	iPtr = ptr;
	iKey = shmkey;
	return err;
	}

TInt CSharedMemDesc::ShmRead(TUint8* aPtr,TInt aLength)
	{
	TInt err = KErrNone;
	iSize = Backend()->iIpcS.GetShmSize(iKey, err);
	TInt diff = iSize - iPos;
	if (aLength >= diff)
		aLength = diff;
	TPtr8 ptr(aPtr, aLength);
	ptr.Copy((TUint8*)(iPtr)+iPos, aLength);
	TInt r = ptr.Length();
	iPos += r;
	return r;
	}

TInt CSharedMemDesc::DoShmRead (TDes8& aDesc)
	{
	TUint8* p = (TUint8*) aDesc.Ptr();
	TInt max = aDesc.MaxLength();
	TInt ret = ShmRead(p, max);
	p += ret;
	aDesc.SetLength(p-aDesc.Ptr());
	return aDesc.Length();
	}


// -----------------------------------------------------------------------------
// CSharedMemDesc::Read
// Reading from a sharedmemory
// -----------------------------------------------------------------------------
void CSharedMemDesc::Read(TDes8& aDesc, TRequestStatus& aStatus)
	{
	//return if its an invalid fd
	if(iFdAttrib & KInvalidFd)
		{
		Complete(aStatus, KErrBadHandle);
		return;
		}
	//Acquire the Lock before read and release it later
	iLock.Wait();
	Complete(aStatus,DoShmRead(aDesc));
	iLock.Signal();
	}

TInt CSharedMemDesc::ShmWrite(TUint8* aPtr,TInt aLength)
	{
	TInt err = KErrNone;
	TInt size = Backend()->iIpcS.GetShmSize(iKey, err);
	TPtrC8 ptr(aPtr,aLength);
	TUint8* bufPtr = const_cast<TUint8*>(ptr.Ptr());
	TInt len = ptr.Length();
	TInt r = Min(aLength, len);	
	Mem::Copy((TUint8*)(iPtr)+iPos, bufPtr, r);
	iPos += r;
	if (iPos > iExt && iExt >= 0)
		iExt = iPos;
	if (iExt <= size)
		iSize = iExt = size;
	else
		iSize = iExt;
	Backend()->iIpcS.SetShmSize(iKey, iSize, err);
	return r;
	}

TInt CSharedMemDesc::DoShmWrite (TDes8& aDesc)
	{
	TUint8* p = (TUint8*) aDesc.Ptr();
	TInt max = aDesc.Length();
	return  ShmWrite(p, max);
	}

// -----------------------------------------------------------------------------
// CSharedMemDesc::Write
// Writing to sharedmemory
// -----------------------------------------------------------------------------
void CSharedMemDesc::Write(TDes8& aDesc, TRequestStatus& aStatus)
	{
	//return if its an invalid fd
	if(iFdAttrib & KInvalidFd)
		{
		Complete(aStatus, KErrBadHandle);
		return;
		}
	//Acquire the Lock before write and release it later
	iLock.Wait();
	Complete(aStatus,DoShmWrite(aDesc));
	iLock.Signal();
	}

// -----------------------------------------------------------------------------
// CSharedMemDesc::Fcntl
// fcntl Implementation for sharedmemory 
// -----------------------------------------------------------------------------
//
TInt CSharedMemDesc::Fcntl(TUint anArg, TUint aCmd)
	{
	//return if its an invalid fd
	if(iFdAttrib & KInvalidFd)
		{
		return KErrBadHandle;
		}
	TInt retVal = KErrNotSupported;
	//fcntl supports only F_SETFL and F_GETFL for Non-Blocking I/O
	//If aCmd and anArg does not match these, return with Error
	switch(aCmd)
		{
		case F_SETFL:
			{
			//Set the fcntl Flag
			if(anArg == O_NONBLOCK)
				{
				iFcntlFlag |=  anArg ;	
				}
			retVal = 0 ;
			break;
			}
		case F_GETFL:
			{
			//Return fcntl flag
			retVal = iFcntlFlag;
			break;
			}
		case F_GETFD:
			{
			if(iFdAttrib & KCloseonExec)
				{
				retVal = 1;
				}
			break;
			}
		case  F_SETFD:
			{
			if(anArg == 1) 
				{
				iFdAttrib |= SET_CLOSE_ON_EXEC_FLG; // (1 << 2) ;
				retVal = anArg;
				}
			else if(anArg == 0 ) 
				{
				iFdAttrib &= ~SET_CLOSE_ON_EXEC_FLG; //(1 << 2) ;
				retVal = anArg;
				}
			else  
				{
				retVal = KErrArgument;    //return invalid argument 
				}
			break;
			}
		}
	return retVal;	
	}

// -----------------------------------------------------------------------------
// CSharedMemDesc::FStat
// stat Implementation for sharedmemory 
// -----------------------------------------------------------------------------
//
TInt CSharedMemDesc::FStat(struct stat *st)
	{
	// set mode as directory
	TInt err = 0, aerr =0;
	TInt shmid = 0;
	struct shmid_ds shmDesc;
	st->st_mode = S_IFREG|iPerms;
	shmid = Backend()->iIpcS.shmget(iKey, SHM_CHUNKSIZE, iPerms, aerr);
	Backend()->iIpcS.shmctl(shmid, IPC_STAT, &shmDesc, aerr);
	st->st_uid = shmDesc.shm_perm.cuid;
	st->st_gid = 0;
	st->st_size = Backend()->iIpcS.GetShmSize(iKey, err);
	return KErrNone;
	}

// -----------------------------------------------------------------------------
// CSharedMemDesc::FinalClose
// stat Implementation for sharedmemory 
// -----------------------------------------------------------------------------
//
TInt CSharedMemDesc::FinalClose()
	{
	TInt err = 0;
	TInt ret = KErrNone;
	ret = Backend()->iIpcS.shmdt(iPtr, err);
	iLock.Close();
	return ret;
	}
	
TInt CSharedMemDesc::Pos()
	{
	return iPos;
	}

TInt CSharedMemDesc::Ext()
	{
	return iExt;
	}
	
//-------------------------------------------------------------------------------
// Function Name : CSharedMemDesc::LSeek()
// Description   : Shall seek to specific position of shared memory
//-------------------------------------------------------------------------------	
TInt CSharedMemDesc::LSeek (off_t& offset, int whence)
	{
	//return if its an invalid fd
	//This scenario comes when the file is closed, but mmap still exists
	if(iFdAttrib & KInvalidFd)
		{
		return KErrBadHandle;	
		}
	TInt pos=offset;
	TInt ext=Ext();
	switch (whence)
		{
		case SEEK_SET:
			break;
		case SEEK_CUR:
			pos += Pos();
			break;
		case SEEK_END:
			pos += ext;
			break;
		default:
			return KErrArgument;
		}
	if (pos < 0)
		{
		return KErrArgument;
		}
	iPos = pos;
	offset = pos;
	return KErrNone;
	}
	
#endif //SYMBIAN_OE_LIBRT

