/*

* Copyright (c) 1999-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 <sys/errno.h>

#include <sys/serial.h>

#include <unistd.h>

#include <sys/stat.h>

#include <sys/select.h>

#include <sys/syslimits.h>

#include <utf.h>

#include "sysreent.h"

#include <sys/socket.h>

#include <sys/un.h>

#include "sysif.h"

#include "fdesc.h"

#include "ltime.h"

#include "lposix.h"

#ifdef SYMBIAN_OE_POSIX_SIGNALS

#include <stdlib.h>

#include <signal.h>

#include "tsignalmessage.h"

#endif // SYMBIAN_OE_POSIX_SIGNALS

#ifdef SYMBIAN_OE_POSIX_SIGNALS

#define SIG_SIGNAL_PRESENT_IN_SIGSET(sig,set) ((set & (1ULL << (sig-1))) != 0x0000000000000000ULL)

#define SIG_ISEMPTY_SIGSET(set) (set == 0x0000000000000000ULL)

#define SIG_EMPTY_SIGSET(set) {set = 0x0000000000000000ULL;}

#define SIG_FILL_SIGSET(set) {set = 0xFFFFFFFFFFFFFFFFULL;}

#define SIG_ADD_SIGNAL_TO_SET(sig,set) {set |= (1ULL << (sig-1));}

#define SIG_REMOVE_SIGNAL_FROM_SET(sig,set) {set &= ~(1ULL << (sig-1));}

static void sig_exit();

const TUint KSignalPipeSize = 1024;

#endif

#ifdef __WINSCW__

#include <pls.h> // For emulator WSD API

const TUid KBackendUid3 = {0x102828D5};

#elif defined __X86GCC__

// GCC compiler generates an undefined reference error if static CLocalSystemInterface object is created in a local function. Therefore give it global scope on this platform.

CLocalSystemInterface TheBackend;

#elif defined __EPOC32__

//Globally declaring the CLSI object to overcome the DCLP implementation if given a static scope.

CLocalSystemInterface backend;

#endif

const TUint KConvertToMicroSecond = 1000000;

// Create static singleton backend object for the Process and return the same

EXPORT_C CLocalSystemInterface* Backend()

		{

#ifdef __WINSCW__

		// Access the PLS of this process

		CLocalSystemInterface* backend = Pls<CLocalSystemInterface>(KBackendUid3);

		return backend;

#elif defined __X86GCC__

		return &TheBackend;

#else

		return &backend;

#endif

		}

// Construction of Backend Object which is going to be singleton object for the process

EXPORT_C CLocalSystemInterface::CLocalSystemInterface() : iOpenDirList(CLocalSystemInterface::KDirGran),

iTLDInfoList(CLocalSystemInterface::KTLDInfoListGran)

		{

#ifdef SYMBIAN_OE_POSIX_SIGNALS

		iSignalsInitialized = EFalse;

		iSigInitWaitCount = 0;

		iSigInitWaitMutex.CreateLocal();

		iSigInitWaitSemaphore.CreateLocal(0);

		iBlockedSAMutex.CreateLocal();

		iSignalWaiterMutex.CreateLocal();

		iSignalInitSemaphore.CreateLocal(0);

#endif

		//Create the Heap for all the libraries (local to this process)

		const TInt KMaxHeapSize = 1048576 ; // 1MB

		iPrivateHeap = UserHeap::ChunkHeap(NULL, KMinHeapSize, KMaxHeapSize);

		if (!iPrivateHeap)

			{

			User::Panic(KEstlibInit, KErrNoMemory);

			}

		// Switch to the backend private heap

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

		TInt err = iFids.Init(iPrivateHeap);

		if ( !err )

			{

			CRedirDesc* redirMedia = new CRedirDesc();

			if (redirMedia)

				{

				CStdErrDesc* errMedia = new CStdErrDesc();

				if(errMedia)

					{

					iFids.Default(redirMedia, errMedia);

					redirMedia->Close();

					errMedia->Close();

					}

				else

					{

					iPrivateHeap->Free(redirMedia);

					}

				}

			}

#if (defined SYMBIAN_OE_POSIX_SIGNALS && defined SYMBIAN_OE_LIBRT)

		iTimerOverrunsMutex.CreateLocal(); //use backend heap

#endif

		// Reset to the thread's default heap

		User::SwitchHeap(oldHeap);

		if (!err)

			{

			err=iFs.Connect();

			if(!err)

				{

				err = iFs.ShareAuto();

				}

			}

		if (!err)

			{

			err = PosixFilesystem::SetDefaultDir(iFs);

			}

		//Cache the session path to avoid querying RFs every time it is needed

		if(err == KErrNone)

			{

			err = iFs.SessionPath(iSessionPath);

			}

		if(err == KErrNone)

			{	

			//Create Server Locks

			err |= iSSLock.CreateLocal();

			err |= iCSLock.CreateLocal();

			err |= iIpcS.iLock.CreateLocal();

			//Create TLDList Lock

			err |= iTLDListLock.CreateLocal();

			//Create the lock for Session Path

			err |= iSessionPathLock.CreateLocal();

			//Lock for protecting iASelectRequest across threads

			err |=  iASelectLock.CreateLocal();

	        //Protect the iDefConnection from concurrent GetDefaultConnection calls

	        err |= iDefConnLock.CreateLocal();

			}

		//Panic if any of the above operation returns with error

		if (err)

			{

			User::Panic(KEstlibInit, err);

			}

		iCleanup.StorePtrs(iPrivateHeap, &iFs, &iSs, &iCs, &iSSLock, &iCSLock);

		// No connection settings by default

		iDefConnPref = NULL;

		}

EXPORT_C CLocalSystemInterface::~CLocalSystemInterface()

//

// Shut down all server connections in use

//

	{

	iTLDListLock.Close();

	iSessionPathLock.Close();

	// Close the aselect lock

	iASelectLock.Close();

	// Close the default connection lock

	iDefConnLock.Close();

	//close the default RConnection

	if(iDefConnection.SubSessionHandle() != 0)

		iDefConnection.Close();

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

	for (TInt i = 0, count = iTLDInfoList.Count(); i < count; i++ )

		{

		iTLDInfoList[i].Close(iPrivateHeap);

		}

	// close the RArray itself

	iTLDInfoList.Close();

	// Cleanup the threads serving aselect requests

	int err;

	// passing 1 to cancelaselect will kill all the threads serving aselect

	cancelaselect(NULL,err,1);

	// Switch to backend heap

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

	// Close the array that maintains aselect request details 

	iASelectRequest.Close();

	// Switch back to old heap

	User::SwitchHeap(oldHeap);

	if( iDefConnPref )

	    {

	    switch( iDefConnPref->ExtensionId() )

	        {

	        case TConnPref::EConnPrefSnap:

	            {

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

	            delete (TCommSnapPref*)iDefConnPref;

	            // Switch back to old heap

	            User::SwitchHeap(oldHeap);

	            iDefConnPref = NULL;              

	            }

	            break;

	        case TConnPref::EConnPrefCommDb:

	            {

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

	            delete (TCommDbConnPref*)iDefConnPref;

	            // Switch back to old heap

	            User::SwitchHeap(oldHeap);

	            iDefConnPref = NULL;

	            }

	            break;              

	        default:

	            {

                // Unknown type of Connection Pref, do nothing

	            }

	        }

	    }

#if (defined SYMBIAN_OE_POSIX_SIGNALS && defined SYMBIAN_OE_LIBRT)

	iTimerOverrunsMutex.Close();

	iTimerOverruns.Close(); 

#endif	

	//close the RpointerArray

	iOpenDirList.Close();

	User::SwitchHeap(oHeap);

	}

#ifdef __SYMBIAN_COMPILE_UNUSED__

CLocalSystemInterface& CLocalSystemInterface::Clone()

	{

	return *this;

	}

void CLocalSystemInterface::Release()

	{

	// nada. TODO: Remove this method

	}

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

// CLocalSystemInterface::TerminateProcess

// Sends a message to Posix Server to Terminate itself!

// And delete the Process (self)

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

//

void CLocalSystemInterface::TerminateProcess(int status)

	{

	//delete this;

	RProcess().Terminate(status);

	}

#endif //__SYMBIAN_COMPILE_UNUSED__

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

// CLocalSystemInterface::Exit

// Close all the open FIDS,Terminate the process

//

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

//

void CLocalSystemInterface::Exit(int code)

	{

#ifdef SYMBIAN_OE_POSIX_SIGNALS

	iSignalLoopRunning = EFalse;

#endif

	iFids.Close();

	User::SetCritical(User::EProcessPermanent);

	User::Exit(code);

	}

// Simple layer over PosixFilesystem

wchar_t * CLocalSystemInterface::getcwd (wchar_t* buf, unsigned long len, int& anErrno)

	{

	return PosixFilesystem::getcwd(iFs, buf, len, anErrno);

	}

int CLocalSystemInterface::chdir (const wchar_t* aPath, int& anErrno)

	{

	return PosixFilesystem::chdir(iFs, aPath, anErrno);

	}

int CLocalSystemInterface::rmdir (const wchar_t* aPath, int& anErrno)

	{

	return PosixFilesystem::rmdir(iFs, aPath, anErrno);

	}

int CLocalSystemInterface::mkdir (const wchar_t* aPath, int perms, int& anErrno)

	{

	return PosixFilesystem::mkdir(iFs, aPath, perms, anErrno);

	}

int CLocalSystemInterface::stat (const wchar_t* name, struct stat *st, int& anErrno)

	{

	return PosixFilesystem::stat(iFs, name, st, anErrno);

	}

int CLocalSystemInterface::utime (const wchar_t* name, const struct utimbuf *filetimes, int& anErrno)

	{

	return PosixFilesystem::utime(iFs, name, filetimes, anErrno);

	}

int CLocalSystemInterface::chmod (const wchar_t* name, int perms, int& anErrno)

	{

	return PosixFilesystem::chmod(iFs, name, perms, anErrno);

	}

int CLocalSystemInterface::rename (const wchar_t* oldname, const wchar_t* newname, int& anErrno)

	{

	return PosixFilesystem::rename(iFs, oldname, newname, anErrno);

	}

EXPORT_C TInt CLocalSystemInterface::ResolvePath (TParse& aResult, const wchar_t* path, TDes* aFilename)

	{

	return PosixFilesystem::ResolvePath(aResult, path, aFilename);

	}

// Simple layer over CFileTable synchronous routines

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

	{

	return iFids.open(name,mode,perms,anErrno);

	}

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

	{

	return iFids.dup(fid,anErrno);

	}

int CLocalSystemInterface::dup2 (int fid, int fid2, int& anErrno)

	{

	return iFids.dup2(fid,fid2,anErrno);

	}

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

	{

	return iFids.UserClose(fid,anErrno);

	}

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

	{

	return iFids.lseek(fid,offset,whence,anErrno);

	}

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

	{

	return iFids.fstat(fid,st,anErrno);

	}

int CLocalSystemInterface::socket (int family, int style, int protocol, int& anErrno)

	{

	//Acquire the Lock before issuing a request to the server and release it later

	iSSLock.Wait();

	int retVal = iFids.socket(family,style,protocol,anErrno,iSs);

	iSSLock.Signal();

	return retVal;

	}

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

	{

	return iFids.listen(fid,n,anErrno);

	}

int CLocalSystemInterface::bind (int fid, const struct sockaddr* addr, unsigned long size, int& anErrno)

	{

	return iFids.bind(fid,addr,size,anErrno);

	}

int CLocalSystemInterface::sockname (int fid, struct sockaddr* addr, unsigned long* size, int anEnd, int& anErrno)

	{

	return iFids.sockname(fid,addr,size,anEnd,anErrno);

	}

int CLocalSystemInterface::getsockopt (int fid, int level, int opt, void* buf, unsigned long* len, int& anErrno)

	{

	return iFids.getsockopt(fid,level,opt,buf,len,anErrno);

	}

int CLocalSystemInterface::setsockopt (int fid, int level, int opt, void* buf, unsigned long len, int& anErrno)

	{

	return iFids.setsockopt(fid,level,opt,buf,len,anErrno);

	}

int CLocalSystemInterface::popen3 (const wchar_t* file, const wchar_t* cmd,

		wchar_t** env, int fids[3], int& anErrno)

	{

	return iFids.popen3(file, cmd, env, fids, anErrno);

	}

int CLocalSystemInterface::waitpid (int pid, int* status, int options, int& anErrno)

	{

	return iFids.waitpid(pid, status, options, anErrno);

	}

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

// CLocalSystemInterface::popen

// Implementation for popen

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

//

int CLocalSystemInterface::popen (const wchar_t* file, const wchar_t* cmd,

		const char* mode, int& anErrno)

	{

	return iFids.popen(file, cmd, mode, anErrno);

	}

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

// CLocalSystemInterface::pclose

// Implementation for pclose

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

//

int CLocalSystemInterface::pclose (int aFid, int& anErrno)

	{

	return iFids.pclose(aFid, anErrno);

	}

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

// CLocalSystemInterface::CheckOrigins

// Implementation for CheckPipe

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

//

EXPORT_C void CLocalSystemInterface::CheckOrigins (wchar_t**& wenvp, int& aCount)

	{

	//Acquire the Lock before issuing a request to the server and release it later

#ifdef SYMBIAN_OE_POSIX_SIGNALS

	iFids.CheckOrigins(wenvp, aCount, iSigMask);

#else

	iFids.CheckOrigins(wenvp, aCount);

#endif

	}

#ifdef SYMBIAN_OE_POSIX_SIGNALS

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

// CLocalSystemInterface::WaitOrHandleSignal

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

//

void CLocalSystemInterface::WaitOrHandleSignal(TSignalMessage aMsg)

	{

	TInt lSigNum = 0,lIdx = 0,lSigVal = 0;

	TSignalWaiter lTempWaiter(0,0);

	if(aMsg.mType == TSignalMessage::ESignal)

		lSigNum = aMsg.mSignal;

	else if(aMsg.mType == TSignalMessage::ESignalValuePair)

		{

		lSigNum = aMsg.mSigVal.mSignal;

		lSigVal = aMsg.mSigVal.mValue;

		}

	else if(aMsg.mType == TSignalMessage::ERtTimerSignal)

		{

		lSigNum = aMsg.mRtSignal.mSignal;

		}

	// check and deliver to waiter (if any)

	TUint64 lMask;

	SIG_EMPTY_SIGSET(lMask);

	SIG_ADD_SIGNAL_TO_SET(lSigNum,lMask);

	lTempWaiter.iSigWaitMask = lMask;

	lIdx = iSignalWaiterArray.Find(lTempWaiter,TSignalWaiter::MatchByMask);

	if(lIdx != KErrNotFound)

		{

		iSignalWaiterMutex.Wait();

		iSignalWaiterArray[lIdx].iSigWaitMessagePtr->mType = aMsg.mType;

		if(aMsg.mType == TSignalMessage::ESignal)

			iSignalWaiterArray[lIdx].iSigWaitMessagePtr->mSignal = lSigNum;

		else if(aMsg.mType == TSignalMessage::ESignalValuePair)

			{

			iSignalWaiterArray[lIdx].iSigWaitMessagePtr->mSigVal.mSignal = lSigNum;

			iSignalWaiterArray[lIdx].iSigWaitMessagePtr->mSigVal.mValue = lSigVal;

			}

		iSignalWaiterArray[lIdx].iSigWaitSemaphore.Signal();

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

		iSignalWaiterArray.Remove(lIdx);

		User::SwitchHeap(oldHeap);

		iSignalWaiterMutex.Signal();

		}

	// queueing if blocked or sigqueue

	else

		{

		HandleSignal(aMsg);

		}

	}

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

// CLocalSystemInterface::SignalHandler

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

//

TInt CLocalSystemInterface::SignalHandler()

	{

	// TODO: Put memory barrier to ensure SMP safety

	TInt lRetVal = KErrGeneral;

	InitializeSignalHandlers();

	RPipe::Init(); // check return value

	lRetVal = RPipe::Create(KSignalPipeSize,iSignalReadPipe,iSignalWritePipe);

	if(lRetVal != KErrNone)

		{

		iSignalInitSemaphore.Signal();

		return lRetVal;

		}

	lRetVal = iSignalSession.SendPipe(iSignalWritePipe); // check return value

	if(lRetVal != KErrNone)