/*

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

#include "systemspecialfilercg.h"

#include "link.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),

		{

#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();

			}

        if(err == KErrNone)

            {

            err = iTzServer.Connect();

            if(!err)

                {

                err = iTzServer.ShareAuto();

                }

            }

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

		if (err)

			{

			User::Panic(KEstlibInit, err);

			}

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

		}

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

	// Close the array that maintains aselect request details 

	iASelectRequest.Close();

	//close the RTz connection

	iTzServer.Close();

	if( iDefConnPref )

	    {

	    switch( iDefConnPref->ExtensionId() )

	        {

	        case TConnPref::EConnPrefSnap:

	            {

	            delete (TCommSnapPref*)iDefConnPref;

	            iDefConnPref = NULL;              

	            }

	            break;

	        case TConnPref::EConnPrefCommDb:

	            {

	            delete (TCommDbConnPref*)iDefConnPref;

	            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	

#if (defined SYMBIAN_OE_POSIX_SIGNALS)

	iSigInitWaitMutex.Close();

	iSigInitWaitSemaphore.Close();

	iBlockedSAMutex.Close();

	iSignalWaiterMutex.Close();

	iSignalInitSemaphore.Close();

#endif

	//close the RpointerArray

	iOpenDirList.Close();

	iSSLock.Close();

	iCSLock.Close();

	iSignalSession.Close();

	iIpcS.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

    if(iSignalsInitialized)

        {

        TRequestStatus status = KRequestPending;

        iSignalHandlerThread.Logon(status);

        iSignalLoopRunning = EFalse;

        iSignalHandlerThread.RequestSignal();

        User::WaitForRequest(status);

        }

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

    {    

    const wchar_t* filename  = name;

    // This needs to be zero terminated

    TBuf<KMaxFileName> inputName;

    TUint pathAtt = 0;

    TInt err = GetFullFile(inputName,(const TText16*)name,iFs);

    if( !err )

        {

        TInt err = iFs.Att(inputName,pathAtt);

        if ( (err == KErrNone) && (pathAtt & KEntryAttDir) )

            {                    

            inputName.Append(_L("\\"));            

            }

        filename = (wchar_t*)inputName.PtrZ();

        }

    TSpecialFileType fileType;

    struct SLinkInfo enBuf;

    // Check the type of file

    fileType = _SystemSpecialFileBasedFilePath(filename, err, iFs);

    // If it is a symbolic link, follow the link

    // If _SystemSpecialFileBasedFilePath fails, treat it as normal file

    // and try to proceed

    if( fileType == EFileTypeSymLink && err == KErrNone )

        {

        err = _ReadSysSplFile(filename, (char*)&enBuf, sizeof(struct SLinkInfo), anErrno, iFs);

        if (err == KErrNone)

            {

            filename = (wchar_t*)enBuf.iParentPath;

            }

        else

            {

            // errno is already set by _ReadSysSplFile

            return -1;

            }

        }

    else if ( fileType != EFileGeneralError && err != KErrNone )

        {

        return MapError(err,anErrno);

        }

    return PosixFilesystem::statbackend(iFs, filename, st, anErrno);

    }

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

    {

    return PosixFilesystem::statbackend(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);