--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/genericopenlibs/cstdlib/USTLIB/LOCALIF.CPP	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,476 @@
+// 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 "SYSIF.H"
+#include "FDESC.H"
+#include "LTIME.H"
+#include "LPOSIX.H"
+#include <fcntl.h>
+#include <sys/errno.h>
+#include <sys/serial.h>
+
+// System Interface for thread-local form of STDLIB
+
+/** 
+Two-phase constructor method to create a CLocalSystemInterface instance.
+*/
+CLocalSystemInterface* CLocalSystemInterface::NewL()
+	{
+	CLocalSystemInterface* self = new (ELeave) CLocalSystemInterface();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+/**
+Constructor.
+*/	
+CLocalSystemInterface::CLocalSystemInterface()
+	{
+	}
+
+/**
+Second-phase constructor.
+Initialises some data members.
+This function leaves if any system-wide error happens.
+*/	
+void CLocalSystemInterface::ConstructL()		
+	{
+	iFids.InitL();
+	
+	CTtyDesc* console=new CTtyDesc;
+	User::LeaveIfNull(console);
+	
+	iFids.Default(console);
+	console->Close();
+
+	User::LeaveIfError(iFs.Connect());
+	User::LeaveIfError(PosixFilesystem::SetDefaultDir(iFs));
+	}
+
+CLocalSystemInterface::~CLocalSystemInterface()
+//
+// Shut down all server connections in use
+//
+	{
+	iFids.Close();
+	iCs.Close();
+	iSs.Close();
+	iFs.Close();
+	}
+
+MSystemInterface& CLocalSystemInterface::Clone()
+	{
+	iUseCount++;
+	return *this;
+	}
+
+void CLocalSystemInterface::Release()
+	{
+	if (--iUseCount<0)
+		delete this;
+	}
+
+void CLocalSystemInterface::TerminateProcess(int status)
+	{
+	delete this;
+	RProcess().Terminate(status);
+	}
+
+
+// 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::chmod (const wchar_t* name, int perms, int& anErrno)
+	{
+	return PosixFilesystem::chmod(iFs,name,perms,anErrno);
+	}
+
+int CLocalSystemInterface::unlink (const wchar_t* name, int& anErrno)
+	{
+	return PosixFilesystem::unlink(iFs,name,anErrno);
+	}
+
+int CLocalSystemInterface::rename (const wchar_t* oldname, const wchar_t* newname, int& anErrno)
+	{
+	return PosixFilesystem::rename(iFs,oldname,newname,anErrno);
+	}
+
+
+TInt CLocalSystemInterface::ResolvePath (TParse& aResult, const wchar_t* path, TDes* aFilename)
+	{
+	return PosixFilesystem::ResolvePath(iFs, aResult, path, aFilename);
+	}
+
+// Simple layer over CFileTable synchronous routines
+
+int CLocalSystemInterface::open (const wchar_t* name, int mode, int perms, int& anErrno)
+	{
+	//at this point we need to know if it is a serial port or file
+	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')))
+		return iFids.open(name,mode,perms,anErrno, iCs);
+	else
+		return iFids.open(name,mode,perms,anErrno, iFs);
+	}
+
+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.close(fid,anErrno);
+	return iFids.userclose(fid,anErrno);
+	}
+
+int CLocalSystemInterface::lseek (int fid, int 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)
+	{
+	return iFids.socket(family,style,protocol,anErrno,iSs);
+	}
+
+int CLocalSystemInterface::listen (int fid, int n, int& anErrno)
+	{
+	return iFids.listen(fid,n,anErrno);
+	}
+
+int CLocalSystemInterface::bind (int fid, struct sockaddr* addr, unsigned long size, int& anErrno)
+	{
+	TUSockAddr address(addr,size);
+	return iFids.bind(fid,address,anErrno);
+	}
+
+int CLocalSystemInterface::sockname (int fid, struct sockaddr* addr, unsigned long* size, int anEnd, int& anErrno)
+	{
+	TUSockAddr address(addr);
+	TInt ret=iFids.sockname(fid,address,anEnd,anErrno);
+	if (ret==0)
+		address.Get(addr,size);
+	return ret;
+	}
+
+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);
+	}
+
+wchar_t* CLocalSystemInterface::getenv (const wchar_t* name)
+	{
+	return iEnv.getenv(name);
+	}
+
+void CLocalSystemInterface::unsetenv (const wchar_t* name)
+	{
+	iEnv.unsetenv(name);
+	}
+
+int CLocalSystemInterface::setenv (const wchar_t* name, const wchar_t* value, int rewrite, int& anErrno)
+	{
+	return iEnv.setenv(name,value,rewrite,anErrno);
+	}
+
+
+int CLocalSystemInterface::popen3 (const wchar_t *, const wchar_t *, const wchar_t *, wchar_t**, int [3], int& anErrno)
+	{
+	return MapError(KErrNotSupported,anErrno);
+	}
+
+int CLocalSystemInterface::waitpid (int, int*, int, int& anErrno)
+	{
+	return MapError(KErrNotSupported,anErrno);
+	}
+
+// Synchronous layer over CFileTable asynchronous routines
+
+int CLocalSystemInterface::read (int fid, char* buf, unsigned long len, int& anErrno)
+	{
+	CFileDescBase* f=0;
+	TBool patchErr = EFalse;
+
+	TInt err=iFids.Asynch(fid,f);
+	if (!err)
+		{
+		TRequestStatus readStatus;
+		TRequestStatus timerStatus(KRequestPending);
+		RTimer theTimer;
+		TBool timerRunning = EFalse;
+
+		TPtr8 ptr((TText8 *)buf, len);
+
+		if (f->TimedRead())
+			{
+			TTimeIntervalMicroSeconds32 timeout(f->TimeoutValue()*1000);
+			theTimer.CreateLocal();
+			theTimer.After(timerStatus, timeout);
+			timerRunning = ETrue;
+			}
+
+		f->Read(ptr, readStatus);
+
+		User::WaitForRequest(readStatus, timerStatus);
+
+		if (timerRunning)
+			{
+			if (timerStatus.Int() != KRequestPending)
+				{
+				//cancel the read and wait for it
+				f->ReadCancel();
+				patchErr = ETrue;	//report this as a timeout not a cancel!!
+				User::WaitForRequest(readStatus);
+				}
+			else
+				{
+				//if the timer was in operation
+				//cancel the timer
+				theTimer.Cancel();
+				User::WaitForRequest(timerStatus);
+				}
+			theTimer.Close();
+			}
+
+		err=f->ReadCompletion(ptr, readStatus.Int());
+		f->Close();	// balances the Dup() in CFileTable::Asynch()
+		if (err==0)
+			return ptr.Length();
+		}
+	if (patchErr)
+		err = ETIMEDOUT;
+
+	return MapError(err,anErrno);
+	}
+
+int CLocalSystemInterface::write (int fid, const char* buf, unsigned long len, int& anErrno)
+	{
+	CFileDescBase* f=0;
+	TInt err=iFids.Asynch(fid,f);
+	if (!err)
+		{
+		TRequestStatus status;
+		TPtr8 ptr((TText8 *)buf, len, len);
+		f->Write(ptr,status);
+		User::WaitForRequest(status);
+		err=f->WriteCompletion(ptr, status.Int());
+		f->Close();	// balances the Dup() in CFileTable::Asynch()
+		if (err==0)
+			return ptr.Length();
+		}
+	return MapError(err,anErrno);
+	}
+
+int CLocalSystemInterface::recvfrom (int fid, char* buf, unsigned long len, int flags, struct sockaddr* from, unsigned long* fromsize, int& anErrno)
+	{
+	CFileDescBase* f=0;
+	TInt err=iFids.Asynch(fid,f);
+	if (!err)
+		{
+		TRequestStatus status;
+		TPtr8 ptr((TText8 *)buf, len);
+		TUSockAddr addr(from);
+		f->RecvFrom(ptr,addr,flags,status);
+		User::WaitForRequest(status);
+		TInt ret=0;
+		err=f->RecvFromCompletion(ret, status.Int());
+		f->Close();	// balances the Dup() in CFileTable::Asynch()
+		if (err==0)
+			{
+			addr.Get(from,fromsize);
+			return ptr.Length();
+			}
+		}
+	return MapError(err,anErrno);
+	}
+
+int CLocalSystemInterface::sendto (int fid, const char* buf, unsigned long len, int flags, struct sockaddr* to, unsigned long tosize, int& anErrno)
+	{
+	CFileDescBase* f=0;
+	TInt err=iFids.Asynch(fid,f);
+	if (!err)
+		{
+		TRequestStatus status;
+		TPtr8 ptr((TText8 *)buf, len, len);
+		TUSockAddr addr(to,tosize);
+		f->SendTo(ptr,addr,flags,status);
+		User::WaitForRequest(status);
+		err=f->SendToCompletion(ptr, status.Int());
+		f->Close();	// balances the Dup() in CFileTable::Asynch()
+		if (err==0)
+			return ptr.Length();
+		}
+	return MapError(err,anErrno);
+	}
+
+int CLocalSystemInterface::fsync (int fid, int& anErrno)
+	{
+	CFileDescBase* f=0;
+	TInt err=iFids.Asynch(fid,f);
+	if (!err)
+		{
+		TRequestStatus status;
+		f->Sync(status);
+		User::WaitForRequest(status);
+		f->Close();	// balances the Dup() in CFileTable::Asynch()
+		err=status.Int();
+		}
+	return MapError(err,anErrno);
+	}
+
+int CLocalSystemInterface::shutdown (int fid, int how, int& anErrno)
+	{
+	CFileDescBase* f=0;
+	TInt err=iFids.Asynch(fid,f);
+	if (!err)
+		{
+		TRequestStatus status;
+		f->Shutdown(how,status);
+		User::WaitForRequest(status);
+		f->Close();	// balances the Dup() in CFileTable::Asynch()
+		err=status.Int();
+		}
+	return MapError(err,anErrno);
+	}
+
+int CLocalSystemInterface::connect (int fid, struct sockaddr* addr, unsigned long size, int& anErrno)
+	{
+	CFileDescBase* f=0;
+	TInt err=iFids.Asynch(fid,f);
+	if (!err)
+		{
+		TRequestStatus status;
+		TUSockAddr address(addr,size);
+		f->Connect(address,status);
+		User::WaitForRequest(status);
+		f->Close();	// balances the Dup() in CFileTable::Asynch()
+		err=status.Int();
+		}
+	return MapError(err,anErrno);
+	}
+
+int CLocalSystemInterface::accept (int fid, int& anErrno)
+//
+// The CSocketDesc performing the Accept is responsible for creating the new CSocketDesc
+//
+	{
+	CFileDescBase* f=0;
+	TInt err=iFids.Asynch(fid,f);
+	if (!err)
+		{
+		CSocketDesc* newf=0;
+		int fd=iFids.Reserve();
+		err=fd;
+		if (fd>=0)
+			{
+			TRequestStatus status;
+			f->Accept(newf,status,iSs);
+			CleanupStack::PushL(newf);
+			User::WaitForRequest(status);
+			f->Close();	// balances the Dup() in CFileTable::Asynch()
+			err=status.Int();
+			if (!err)
+				{
+				err=iFids.Attach(fd,newf);
+				if (!err)
+					{	
+					CleanupStack::PopAndDestroy(newf);
+					return fd;
+					}
+				}
+			iFids.Attach(fd,0);	// cancel the reservation
+			CleanupStack::PopAndDestroy(newf);
+			}
+		}
+	return MapError(err,anErrno);
+	}
+
+int CLocalSystemInterface::ioctl (int fid, int cmd, void* param, int& anErrno)
+	{
+	TRequestStatus ioctlStatus;
+	TInt err=ioctl(fid,cmd,param,ioctlStatus,anErrno);
+	if (err==KErrNone)
+		{
+		User::WaitForRequest(ioctlStatus);
+		err=ioctl_complete(fid,cmd,param,ioctlStatus,anErrno);
+		}
+	return err;
+	}
+
+// C++ version of asynchronous ioctl
+
+int CLocalSystemInterface::ioctl (int fid, int cmd, void* param, TRequestStatus& aStatus, int& anErrno)
+	{
+	CFileDescBase* f=0;
+	TInt err=iFids.Asynch(fid,f);
+	if (!err)
+		{
+		f->Ioctl(cmd,param,aStatus);
+		f->Close();	// balances the Dup() in CFileTable::Asynch() - live dangerously!
+		}
+	return MapError(err,anErrno);
+	}
+
+int CLocalSystemInterface::ioctl_complete (int fid, int cmd, void* param, TRequestStatus& aStatus, int& anErrno)
+	{
+	return iFids.ioctlcomplete(fid,cmd,param,aStatus,anErrno);
+	}
+
+int CLocalSystemInterface::ioctl_cancel (int fid, int& anErrno)
+	{
+	return iFids.ioctlcancel(fid,anErrno);
+	}