/*

* 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 <fcntl.h>

#include <string.h>

#include <sys/errno.h>

#include <sys/stat.h>

#include <sys/wait.h>

#include <wchar.h>

#include <rpipe.h>

#include <sys/syslimits.h>  // for checking maximum no of FDs that can be opened

#include "sysif.h"

#include "fdesc.h"

#include "ltime.h"

#include "lposix.h"

#include "systemspecialfilercg.h"

#include "link.h"

#include "spawn_r.h"

#include "fdtransfer_srv.h"

#include "fdtransfer_cli.h"

#include <sys/socket.h>

#include <sys/un.h>

#include <utf.h>

#define RESERVED(i)	((CFileDescBase*)((i)+1))

#define IS_SUPPORTED(filetype) ( filetype == EFileTypeGeneral || filetype == EFileTypeMkFifo )

static const TInt KMinFds = 8;

static const TInt KMinConnections = 8;

static const TInt KPopen3Fds = 3;

static const TInt KDefaultPipeSz = 512;

static const TInt KPipeReadHandle = 0;

static const TInt KPipeWriteHandle = 1;

enum TChildType

	{

	EPopenChild,

	EPopen3Child,

	ESpawnChild,

	ESystemChild

	};

enum

	{

	// for all operations

	ESlotParentId = 0x8,  //CApaCommandLine::EFirstEnvironmentSlotForPublicUse  apacmdln.h

	ESlotChildType,

	ESlotSemaphore,

	// for popen, popen3

	ESlotStdPipe1 = 0xb,

	// for posix_spawn

	ESlotActions = 0xb,

	// for posix_spawn and popen3

	ESlotEnv = 0xc,

	// for popen3

	ESlotStdPipe2 = 0xd,

	ESlotStdPipe3,

	ESlotSignalMask

	};

CFileTable::CFileTable() : iFids(KMinFds),

						   iRConnectionList(KMinConnections)

	{

	// nada

	}

TInt CFileTable::Init(RHeap* aHeap)

	{

	iPrivateHeap = aHeap;

	CFileDescBase* ptr = NULL;

	//Create FID Lock

	TInt retVal = iFidLock.CreateLocal();

	//Create iRConnectionList Lock

	retVal |= iRcLock.CreateLocal();

	if (!retVal)

		{

		// set up the first KMinFds entries with zero

		TRAP(retVal, iFids.InsertL(0, ptr, KMinFds));

		}

	return retVal;

	}

CFileTable::~CFileTable()

	{

	Close();

	DeleteRConnectionList();

	RHeap* oHeap = User::SwitchHeap(iPrivateHeap);

	iRcLock.Close();

	TInt count = iChildren.Count();

	for(TInt i = 0; i < count; i++)

		{

		iChildren[i].iProc.Close();

		}

	iFidLock.Close();

	iChildren.Close();

	iFids.Reset();

	iCleanup.SaveUserHeap(oHeap);

	}

void CFileTable::Close()

	{

	TInt count = iFids.Count();

	TInt aFid = 0;

	for (; aFid<count; aFid++)

		{

		if (iFids[aFid]!=0 && iFids[aFid]!=RESERVED(aFid))

			{

			iFids[aFid]->RecvFromCancel();

			iFids[aFid]->Close();

			}

		Release(aFid);

		}

	}

void CFileTable::Release(TInt aFid)

	{

	//Lock the resource before using it and unlock later

	iFidLock.Wait();

	iFids[aFid]=0;

	if (aFid<KMinFds || aFid<iFids.Count()-1)

		{

		iFidLock.Signal();

		return;

		}

	// Switch to the backend heap

	RHeap* oldHeap = User::SwitchHeap(iPrivateHeap);

	// opportunity to shrink the array

	while (aFid>=KMinFds && iFids[aFid]==0)

		{

		iFids.Delete(aFid);

		aFid--;

		}

	iFids.Compress();

	// reset to the thread's default heap

	User::SwitchHeap(oldHeap);

	iFidLock.Signal();

	}

void CFileTable::Default(CFileDescBase* aRedirMedia, CFileDescBase* aStdErrMedia)

	{

	if (iFids[0]==0)

		iFids[0]=aRedirMedia->Dup();

	if (iFids[1]==0)

		iFids[1]=aRedirMedia->Dup();

	if (iFids[2]==0)

		iFids[2]=aStdErrMedia->Dup();

	}

TInt CFileTable::Attach(TInt aFid, CFileDescBase* aFile)

	{

	//Lock the resource before using it and unlock later

	iFidLock.Wait();

	if( aFid<0 || aFid>=iFids.Count() || (iFids[aFid] != 0 && iFids[aFid] != RESERVED(aFid)) )

		{

		iFidLock.Signal();

		return KErrArgument;

		}

	iFids[aFid] = aFile;

	iFidLock.Signal();

	return KErrNone;

	}

TInt CFileTable::Reserve()

	{

	TInt aFid = 0;

	TInt err=KErrNone;

	//Lock the resource before using it and unlock later

	iFidLock.Wait();

	TInt count = iFids.Count();

	//Check, is there any free slots in the Table

	for (; aFid<count; aFid++)

		if (iFids[aFid]==0)

			goto success;

	//Check whether we can open more FDs for this process

	if(OPEN_MAX > iFids.Count())

		{

		// Do a switch heap now to make sure that, all the heap allocation will happen

		// with in our private heap

		RHeap* oldHeap = User::SwitchHeap(iPrivateHeap);

		TRAP(err,iFids.ExtendL());

		//Set back the threads default heap

		User::SwitchHeap(oldHeap);

		if (err!=KErrNone)

			{

			iFidLock.Signal();

			return err;

			}

		aFid=iFids.Count()-1;

		}

	else

		{

		iFidLock.Signal();

		//We have reached the maximum limit allowed

		return KErrMaxFdOpened;

		}

success:

	iFids[aFid]=RESERVED(aFid);

	iFidLock.Signal();

	return aFid;

	}

TInt CFileTable::Reserve(int aFids[KPopen3Fds])

	{

	TInt i=0;

	for (i=0; i<KPopen3Fds; i++)

		{

		if (aFids[i]==-1)

			{

			TInt fd=Reserve();

			if (fd<0)

				{

				Detach(aFids);	// release the ones we did get

				return KErrInUse;

				}

			aFids[i]=fd;

			}

		}

	return KErrNone;

	}

TInt CFileTable::Detach(int aFids[KPopen3Fds])

	{

	TInt i=0;

	for (i=0; i<KPopen3Fds; i++)

		{

		if (aFids[i]>0)

			Attach(aFids[i],0);

		}

	return KErrInUse;

	}

TInt CFileTable::Detach(TInt aFid, CFileDescBase*& aDetached)

	{

	if (aFid<0 || aFid>=iFids.Count())

		return KErrBadHandle;

	aDetached=iFids[aFid];

	Release(aFid);

	return KErrNone;

	}

TInt CFileTable::At(TInt aFid, CFileDescBase*& aFound) const

	{

	if (aFid<0 || aFid>=iFids.Count())

		return KErrBadHandle;

	aFound=iFids[aFid];

	if (aFound==0 || aFound == RESERVED(aFid))

		return KErrBadHandle;

	return KErrNone;

	}

int CFileTable::dup(int fid, int& anErrno)

	{

	TInt newfd = Dup(fid);

	if (newfd < KErrNone)

		{

		return MapError(newfd, anErrno);

		}

	return newfd;

	}

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

// CFileTable::Dup

// Invoke DupFd with the aFid and 0

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

TInt CFileTable::Dup(TInt aFid)

	{

	if (aFid<0 || aFid>=iFids.Count())

		return KErrBadHandle;

	CFileDescBase* fdesc;

	// Validate aFid

	if (At(aFid, fdesc) != KErrNone)

		{

		return KErrBadHandle;

		}

	return DupFd(aFid, 0);

	}

int CFileTable::dup2(int fid1, int fid2, int& anErrno)

	{

	// Invoke Dup2. If there is a valid descriptor at fid2, ensure it is closed

	TInt newfd = Dup2(fid1, fid2, ETrue);

	if (newfd < KErrNone)

		{

		return MapError(newfd, anErrno);

		}

	return newfd;

	}

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

// CFileTable::Dup2

// Invoked by both dup2 and fcntl with F_DUPFD

// When invoked from fcntl, aCloseFid2 is FALSE and Dup2 does not close the

// descriptor at aFid2.

// When invoked from dup2, aCloseFid2 is TRUE and Dup2 closes the descriptor

// at aFid2 before invoking DupFd

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

TInt CFileTable::Dup2(TInt aFid1, TInt aFid2, TBool aCloseFid2)

	{

	if (aFid1<0 || aFid1>=iFids.Count() || aFid2<0 || aFid2 > OPEN_MAX)

		return KErrBadHandle;

	CFileDescBase* fdesc;

	// Validate aFid

	if (At(aFid1, fdesc) != KErrNone)

		{

		return KErrBadHandle;

		}

	if (aCloseFid2)

		{

		// Invoked from dup2

		if (aFid1 == aFid2)

			{

			return aFid2;

			}

		// Validate aFid2 and close descriptor, if found.

		if (At(aFid2, fdesc) == KErrNone)

			{

			fdesc->Close();

			iFids[aFid2] = 0;

			}

		}

	return DupFd(aFid1, aFid2);

	}

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

// CFileTable::DupFd

// Invoked by CFileTable::Dup and CFileTable::Dup2

// Return a new fd at slot >= aFid2 refering to the same CFileDescBase object as

// the one at aFid1.

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

TInt CFileTable::DupFd(TInt aFid1, TInt aFid2)

	{

	// Arguments have been validated in the calling methods

	TInt err = KErrNone;

	CFileDescBase* fdesc = iFids[aFid1];

	iFidLock.Wait();

	TInt count = iFids.Count();

	for (; aFid2<count; aFid2++)

		if (iFids[aFid2]==0)

			{

			iFids[aFid2]=fdesc->Dup();

			iFidLock.Signal();

			return aFid2;

			}

	iFidLock.Signal();

	//Expand the FTable

	TRAP(err,ExpandFTableL(aFid2+1));

	//Handle error case

	if (KErrNone == err)

		{

		iFidLock.Wait();

		iFids[aFid2] = fdesc->Dup();

		iFidLock.Signal();

		return aFid2;

		}

	return err;

	}

int CFileTable::open (const wchar_t* name, int mode, int perms, int& anErrno)

	{

	int fd=Reserve();

	TInt err=fd;

	if (fd>=0)

		{

		RHeap* oldHeap = User::SwitchHeap(iPrivateHeap);

		CFileDescBase *f=CFileDescBase::Open(name, mode, perms, err);

		User::SwitchHeap(oldHeap);

		if (!err)

			{

			err=Attach(fd,f);

			if (!err)

				return fd;

			delete f;

			}

		Attach(fd,0);	// cancel the reservation

		//coverity[leaked_storage]

		}

	// KErrNotReady, here typically means filesystem not mounted or the mentioned

	// drive doesnt exist. As KErrNotReady cannot be directly mapped to the existing

	// posix error codes, ENOENT would be the appropriate error to return in this scenario.

	if (err == KErrNotReady)

		{

		anErrno = ENOENT;

		return -1;

		}

	if (err == KErrPathNotFound)

		{

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

		err = Find_Error(name, rfs);

		}

	return MapError(err,anErrno);

	}

int CFileTable::socket (int family, int style, int protocol, int& anErrno, RSocketServ& aSs)

	{

	int fd=Reserve();

	TInt err=fd;

	if (fd>=0)

		{

		CFileDescBase* f;

		RHeap* oldHeap;

			oldHeap = User::SwitchHeap(iPrivateHeap);

			f = CFileDescBase::Socket(aSs, family, style, protocol, err);

		User::SwitchHeap(oldHeap);

		if (err == KErrNone)

			{

			err=Attach(fd,f);

			if (err == KErrNone)

				{

				f->SetFids((void*)this);

				return fd;

				}

			delete f;

			}

		Attach(fd,0);	// cancel the reservation

		}

	return MapError(err,anErrno);

	}

int CFileTable::UserClose(int fid, int& anErrno)

	{

	CFileDescBase *f=0;

	TInt err=At(fid,f);

	if (!err)

		{

		f->UserClose();

		close(fid, anErrno);

		}

	else

		{

		if (KErrNotFound == err)

			err = EBADF;

		}

	return MapError(err,anErrno);

	}

int CFileTable::close (int fid, int& anErrno)

	{

	CFileDescBase *f=0;

	TInt err=Detach(fid,f);

	if (!err)

		{

		if (f==0)

			err=EBADF;

		else

			f->RecvFromCancel();

			err=f->Close();

		}

	return MapError(err,anErrno);

	}

off_t CFileTable::lseek (int fid, off_t offset, int whence, int& anErrno)

	{

	CFileDescBase *f=0;

	TInt err=At(fid,f);

	if (!err)

		{

		err=f->LSeek(offset, whence);

		if (err==KErrNone)

			return offset;

		}

	return MapError(err,anErrno);

	}

int CFileTable::fstat (int fid, struct stat *st, int& anErrno)

	{

	CFileDescBase *f=0;

	TInt err=At(fid,f);

	if (!err)

		{

		memset(st,0,sizeof(struct stat));

		err=f->FStat(st);

		}

	return MapError(err,anErrno);

	}

int CFileTable::listen (int fid, int n, int& anErrno)

	{

	CFileDescBase *f=0;

	TInt err=At(fid,f);

	if (!err)

		err=f->Listen(n);

	return MapError(err,anErrno);

	}