1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Client interface to the CPosixServer

    15 // 

    16 //

    17 

    18 #include "POSIXIF.H"

    19 #include "LTIME.H"

    20 #include "LPOSIX.H"

    21 #include <fcntl.h>

    22 #include <sys/errno.h>

    23 #include <sys/serial.h>

    24 #include <sys/wait.h>

    25 

    26 

    27 #ifdef _DEBUG

    28 #define DebugPrint	RDebug::Print

    29 #else

    30 inline void DebugPrint(const TDesC&, ...) {}

    31 #endif

    32 

    33 // RPosixSession

    34 //

    35 // The message protocol is to pass the errno pointer in p[0] and a pointer to a PosixParams

    36 // in p[1]. The result is written back into the PosixParams.retval field.

    37 

    38 int RPosixSession::Request(TInt aFunction, int& anErrno, PosixParams& aParams) const

    39 	{

    40 	return SendReceive(aFunction,TIpcArgs(&anErrno,&aParams));

    41 	}

    42 

    43 void RPosixSession::Request(TInt aFunction, int& anErrno, PosixParams& aParams, TRequestStatus& aStatus) const

    44 	{

    45 	SendReceive(aFunction,TIpcArgs(&anErrno,&aParams),aStatus);	// asynchronous request

    46 	}

    47 

    48 void RPosixSession::Request(TInt aFunction, const TIpcArgs& aArg,TRequestStatus &aStatus) const

    49 	{

    50 	RSessionBase::SendReceive(aFunction,aArg,aStatus);

    51 	}

    52 TInt RPosixSession::Request(TInt aFunction, const TIpcArgs& aArg) const

    53 	{

    54 	return RSessionBase::SendReceive(aFunction,aArg);

    55 	}

    56 

    57 TVersion RPosixSession::Version()

    58 	{

    59 	return TVersion(KCPosixMajorVersionNumber,KCPosixMinorVersionNumber,0);

    60 	}

    61 

    62 TInt RPosixSession::Connect (TDesC& aServerName)

    63 	{

    64 	TVersion version=Version();

    65 	return CreateSession(aServerName,version,1+3);	// 3 extra message slots for pipes

    66 	}

    67 

    68 TInt RPosixSession::Connect ()

    69 	{

    70 	TBuf<80> serverName;

    71 	PosixServerName(serverName);

    72 	return CreateSession(serverName,Version(),1);

    73 	}

    74 

    75 // CPosixServer support functions exported from ESTLIB.DLL

    76 

    77 #if defined(__WINS__)

    78 

    79 // simple scheme to provide pretend processes on WINS

    80 

    81 extern "C" void getcwd(char*,int);

    82 typedef void (*FUNC)();

    83 

    84 static int id=1;

    85 EXPORT_C void NewProcessId () 

    86 	{ 

    87 	id += 10; 

    88 	}

    89 

    90 static FUNC procFn;

    91 EXPORT_C void NextProcessFn (TAny* aFn)

    92 	{

    93 	procFn=(FUNC)aFn;

    94 	}

    95 

    96 TInt threadhelper (TAny* aFn)

    97 	{

    98 	CTrapCleanup::New();

    99 	FUNC f=(FUNC)aFn;

   100 	(*f)();

   101 	return 0;

   102 	}

   103 TInt processhelper (TAny*)

   104 	{

   105 	// Do the MCRT0.OBJ things straight away

   106 	SpawnPosixServerThread();

   107 	char wd[80];

   108 	getcwd(wd, sizeof(wd));		// connect to CPosixServer

   109 	return threadhelper(procFn);

   110 	}

   111 #endif // __WINS__

   112 _LIT(SERVER_FORMAT,"Posix-%d");

   113 _LIT(SERVER_MATCH, "Posix-*");

   114 

   115 EXPORT_C void PosixServerName(TDes& aBuffer)

   116 //

   117 // Construct the name of the CPosixServer for this process

   118 //

   119 	{

   120 	TProcessId id=RProcess().Id();

   121 	aBuffer.Format(SERVER_FORMAT,*REINTERPRET_CAST(int*,&id));

   122 	}

   123 

   124 struct rendezvous 

   125 	{

   126 	RThread iCaller;

   127 	TRequestStatus* iStatus;

   128 	};

   129 

   130 EXPORT_C TInt SpawnPosixServerThread ()

   131 //

   132 // Try to start a PosixServer thread, assuming there isn't one already

   133 //

   134 	{

   135 	RPosixSession probe;

   136 	TInt err=probe.Connect();

   137 	probe.Close();

   138 	if (err==KErrNone)

   139 		return KErrNone;	// server already exists

   140 	TBuf<80> serverName;

   141 	PosixServerName(serverName);

   142 	TRequestStatus status(KRequestPending);

   143 	struct rendezvous rv;

   144 	rv.iCaller.Duplicate(RThread(),EOwnerProcess);

   145 	rv.iStatus=&status;

   146 	RThread server;

   147 	err=server.Create(serverName,CPosixServer::ThreadFunction,0x2000,NULL,&rv);

   148 	if (err==KErrNone) 

   149 		{

   150 		server.Resume();

   151 		User::WaitForRequest(status);

   152 		err=status.Int();

   153 		server.Close();

   154 		}

   155 	rv.iCaller.Close();

   156 	return err;

   157 	}

   158 

   159 EXPORT_C TInt InstallPosixServerActiveObject (TInt aPriority)

   160 	{

   161 	TRAPD(err, CPosixServer::InitL(aPriority));

   162 	return err;

   163 	}

   164 

   165 void CPosixServer::InitL(TInt aPriority)

   166 //

   167 // Construct and install a CPosixServer active object

   168 //

   169 	{

   170 	CPosixServer *pS=new(ELeave) CPosixServer(aPriority);

   171 	CleanupStack::PushL(pS);

   172 	TBuf<80> serverName;

   173 	PosixServerName(serverName);

   174 

   175 	User::LeaveIfError(pS->iFs.Connect());

   176 

   177 	pS->iFids.InitL();

   178 

   179 	// search for parent process

   180 	pS->FindParentL();

   181 

   182 	// set up default fids

   183 	pS->DefaultConsoleL();

   184 

   185 	DebugPrint(_L("Starting CPosixServer\n"));

   186 	pS->StartL(serverName);

   187 	CleanupStack::Pop(pS);

   188 // Leave pS on the clean up stack for the calling routine to clean up normally on 

   189 // Active Scheduler shutdown or in a failure case where  the scheduler does not 

   190 // start due to an error.

   191 

   192 	}

   193 

   194 // CPosixServer

   195 

   196 CPosixServer::CPosixServer(TInt aPriority)

   197 	: CServer2(aPriority)

   198 	{

   199 	__DECLARE_NAME(_S("CPosixServer"));

   200 	}

   201 

   202 TInt CPosixServer::ThreadFunction(TAny* aPtr)

   203 //

   204 // Create and run an active scheduler containing a CPosixServer

   205 //

   206 	{

   207 	CTrapCleanup* TheTrapCleanup=CTrapCleanup::New();

   208 

   209 	RLibrary stdlib;

   210 	stdlib.Load(_L("estlib"));	// workaround for RAM-loaded EXE calling RAM-loaded DLL

   211 

   212 	struct rendezvous* rvp = (struct rendezvous *)aPtr;

   213 	TInt ret=KErrNone;

   214 	// start scheduler and server

   215 	CActiveScheduler *pA=new CActiveScheduler;

   216 	if (pA!=NULL) 

   217 		{

   218 		CActiveScheduler::Install(pA);

   219 		ret=InstallPosixServerActiveObject();

   220 		}

   221 	// signal to the caller that we've started (or failed!)

   222 	rvp->iCaller.RequestComplete(rvp->iStatus,ret);

   223 	if (ret==KErrNone)

   224 		{

   225 		// start fielding requests from clients

   226 		CActiveScheduler::Start();

   227 		}

   228 	// finished

   229 	delete TheTrapCleanup;

   230 	return(KErrNone);

   231 	}

   232 

   233 CSession2* CPosixServer::NewSessionL(const TVersion& aVersion, const RMessage2& aMessage) const

   234 	{

   235 	TBool r=User::QueryVersionSupported(RPosixSession::Version(),aVersion);

   236 	if (!r)

   237 		User::Leave(KErrNotSupported);

   238 

   239 	RProcess clientProcess;

   240 	RThread clientThread;

   241 	User::LeaveIfError(aMessage.Client(clientThread));

   242 	CleanupClosePushL(clientThread);

   243 	User::LeaveIfError(clientThread.Process(clientProcess));

   244 	TProcessId clientId = clientProcess.Id();

   245 	clientProcess.Close();

   246 	CleanupStack::PopAndDestroy(1); //close thread

   247 

   248 	if (clientId!=RProcess().Id())

   249 		{

   250 		// A thread in a different process

   251 		if (iChildren==0)

   252 			User::Leave(KErrNotReady);	// quick rejection

   253 

   254 		// We need an explicit CONST_CAST so that the CPosixRequest objects have a

   255 		// mutable reference to the CPosixServer which holds the shared data structures

   256 		return new(ELeave) CPosixIPCSession(CONST_CAST(CPosixServer&,*this));

   257 		}

   258 	// A thread in the same process

   259 	return new(ELeave) CPosixSession(CONST_CAST(CPosixServer&,*this));

   260 	}

   261 

   262 void CPosixServer::ServerPanic (TPosixServerPanic aPanic)

   263 	{

   264 	_LIT(KPosixServerPanic, "Posix server");

   265 	User::Panic(KPosixServerPanic,aPanic);

   266 	}

   267 

   268 void CPosixServer::FindParentL()

   269 	{

   270 	TFullName parent;

   271 	TPosixIPCPid pid;

   272 	TPosixIPCReply reply;

   273 

   274 	TProcessId id=RProcess().Id();

   275 	pid = *REINTERPRET_CAST(TUint*,&id);	// my process id

   276 

   277 	TFindServer posixservers(SERVER_MATCH);

   278 	while (posixservers.Next(parent)==KErrNone)

   279 		{

   280 		DebugPrint(_L("Are you my mother, %S?"), &parent);

   281 		if (iParent.Connect(parent)!=KErrNone)

   282 			continue;

   283 		if (iParent.Request(PMAreYouMyMother,TIpcArgs(&pid, &reply))!=KErrNone)

   284 			{

   285 			iParent.Close();

   286 			continue;

   287 			}

   288 

   289 		// found parent

   290 		DebugPrint(_L("Found parent process %S"), &parent);

   291 

   292 		// Create any pipes that might be required

   293 		TUint mask=reply().iPipeMask;

   294 		CPipeChildDesc* pipes[3];

   295 		TInt i=0;

   296 		for (i=0; i<3; i++, mask>>=1)

   297 			{

   298 			pipes[i]=0;

   299 			if (mask&1)

   300 				{

   301 				CPipeChildDesc* pipe=new(ELeave) CPipeChildDesc(i,iParent);

   302 				pipes[i]=pipe;

   303 				pipe->PushLC();

   304 				}

   305 			}

   306 

   307 		// organise the necessary descriptors

   308 		TPtr env=HBufC::NewLC(reply().iEnvironmentSize)->Des();

   309 		TPtr cwd=HBufC::NewLC(reply().iWorkingDirectorySize)->Des();

   310 

   311 		// get the data from parent

   312 		TInt err=iParent.Request(PMHelloMum, TIpcArgs(&pid, &env, &cwd));

   313 		

   314 		DebugPrint(_L("Environment string: %S"), &env);

   315 		DebugPrint(_L("Working directory: %S"), &cwd);

   316 		

   317 		if(err!=KErrNone)

   318 			{

   319 			DebugPrint(_L("I've become an orphan"));

   320 			// release stuff

   321 			iParent.Close();

   322 			User::Leave(err);

   323 			break;

   324 			}

   325 		// apply to our process

   326 		iEnv.ConstructL(reply().iVarCount,env);

   327 		err=iFs.SetSessionPath(cwd);

   328 		User::LeaveIfError(err);

   329 

   330 		// free up the temporary descriptors

   331 		CleanupStack::PopAndDestroy(2);

   332 

   333 		// Attach the pipes!

   334 		for (i=0; i<3; i++)

   335 			{

   336 			iFids.Attach(i, pipes[i]);

   337 			if (pipes[i]!=0)

   338 				CleanupStack::Pop();

   339 			}

   340 		return;

   341 		}

   342 	DebugPrint(_L("Posix-%d is a top-level process"), pid());

   343 	User::LeaveIfError(PosixFilesystem::SetDefaultDir(iFs));

   344 	}

   345 

   346 int CPosixServer::POpen3(PosixParams* aParams, int& anErrno)

   347 	{

   348 	TInt err=KErrNoMemory;

   349 	//coverity[alloc_fn]

   350 	//coverity[assign]

   351 	CPosixProcess* proc= new CPosixProcess(*this);

   352 	if (proc!=0)

   353 		{

   354 		//coverity[leave_without_push]

   355 		err=iFids.Reserve(aParams->pint);

   356 		if (err==KErrNone)

   357 			{

   358 			TRAP(err,proc->POpen3L(aParams));

   359 			}

   360 		if (err==KErrNone)

   361 			{

   362 			DebugPrint(_L("POpen3 created process %d"), proc->iPid);

   363 			proc->iNextProcess=iChildren;

   364 			iChildren=proc;

   365 			return (int)proc->iPid;	// success

   366 			}

   367 		delete proc;

   368 		iFids.Detach(aParams->pint);

   369 		}

   370 	return MapError(err, anErrno);

   371 	}

   372 

   373 CPosixRequest* CPosixServer::Waiters() 

   374 	{

   375 	CPosixRequest* waiters=iWaitAnyQueue;

   376 	iWaitAnyQueue=0;

   377 	return waiters;

   378 	}

   379 

   380 // CPosixSession

   381 //

   382 // Each local thread gets one of these

   383 

   384 CPosixSession::CPosixSession(CPosixServer& aServer)

   385 	: iActive(aServer)

   386 	{

   387 	CActiveScheduler::Add(&iActive);

   388 	__DECLARE_NAME(_S("CPosixSession"));

   389 	}

   390 

   391 void CPosixSession::ServiceL(const RMessage2& aMessage)

   392 	{

   393 	iActive.Service(aMessage);

   394 	}

   395 

   396 // CPosixRequest

   397 //

   398 // An active object contained within the Session that handles the deferred completion

   399 // of asynchronous functions (e.g. read & write).

   400 

   401 CPosixRequest::CPosixRequest(CPosixServer& aServer)

   402 	: CActive(EPriorityStandard), iServer(aServer), iPtr(0,0)

   403 	{

   404 //	iFile=0;

   405 //	iNewF=0;

   406 //	iNewFid=0;

   407 	}

   408 

   409 void CPosixRequest::Service(const RMessage2& aMessage)

   410 //

   411 // The message protocol is to pass the errno pointer in p[0] and a pointer to a PosixParams

   412 // in p[1]. The result is written back into the PosixParams.retval field.

   413 //

   414 	{

   415 	if (aMessage.Function() == PMcancel)

   416 		{

   417 		Cancel();						// Cancel in the active scheduler

   418 		if (iFile)

   419 			EndAsynch(KErrCancel);		// Complete the cancelled request & clean up

   420 		aMessage.Complete(KErrNone);

   421 		return;

   422 		}

   423 

   424 	if (iFile!=0)

   425 		{

   426 		aMessage.Complete(KErrInUse);

   427 		return;

   428 		}

   429 	int& anErrno=*REINTERPRET_CAST(int*,CONST_CAST(TAny*,aMessage.Ptr0()));

   430 	PosixParams* params=REINTERPRET_CAST(PosixParams*,CONST_CAST(TAny*,aMessage.Ptr1()));

   431 	switch (aMessage.Function())

   432 		{

   433 

   434 	// Asynchronous functions need queuing, active objects etc.

   435 

   436 	case PMread:

   437 	case PMwrite:

   438 	case PMsendto:

   439 	case PMrecvfrom:

   440 		iPtr.Set((TText8*)params->ptr[0], params->len[0], params->len[0]);

   441 		// and fall through...

   442 	case PMfsync:

   443 	case PMconnect:

   444 	case PMshutdown:

   445 		{

   446 		TInt err=Fids().Asynch(params->fid,iFile);

   447 		if (!err)

   448 			{

   449 			QueueAsynch(aMessage);	// start operation or queue if busy

   450 			return;					// deferred completion through RunL

   451 			}

   452 		params->ret=MapError(err,anErrno);

   453 		}

   454 		break;

   455 

   456 	case PMaccept:

   457 		{

   458 		TInt err=Fids().Asynch(params->fid,iFile);

   459 		if (!err)

   460 			{

   461 			iNewF=0;

   462 			iNewFid=Fids().Reserve();	// reserve a fid for the accepted socket

   463 			err=iNewFid;

   464 			if (iNewFid>=0)

   465 				{

   466 				QueueAsynch(aMessage);	// start operation or queue if busy

   467 				return;					// deferred completion through RunL

   468 				}

   469 			}

   470 		params->ret=MapError(err,anErrno);

   471 		}

   472 		break;

   473 

   474 	case PMioctl:

   475 	case PMioctlN:

   476 		{

   477 		TInt err=Fids().Asynch(params->fid,iFile);

   478 		if (!err)

   479 			{

   480 			QueueAsynch(aMessage);	// start operation or queue if busy

   481 			return;					// deferred completion through RunL

   482 			}

   483 

   484 		aMessage.Complete(err);	// Different calling convention

   485 		return;

   486 		}

   487 

   488 	// complicated synchronous functions which might do their own completion

   489 

   490 	case PMwaitpid:

   491 		{

   492 		// check for invalid options or if an invalid pid is specified. currently there is no 

   493 		// support for process group id's so a pid less than -1 or equal to 0 is invalid

   494 		if((params->pint[1] & ~(WNOHANG|WUNTRACED))|| (params->pint[0] < -1) || (params->pint[0] ==0))

   495 			{

   496 			anErrno=EINVAL;

   497 			params->ret=-1;

   498 			break;

   499 			}

   500 		if (params->pint[0]==-1 && params->pint[1]==0)	/* wait for any child */

   501 			{

   502 			iMessage=aMessage;

   503 			iServer.WaitForAnyChild(this);

   504 			return; // wait for the next child to die

   505 			}

   506 		CPosixProcess* child=iServer.Child(params->pint[0]);

   507 		if (child!=0)

   508 			{

   509 			if (child->IsAlive())

   510 				{

   511 				if (params->pint[1]&1)	/* WNOHANG */

   512 					{

   513 					params->ret=0;

   514 					break;

   515 					}

   516 				iMessage=aMessage;

   517 				child->Queue(this);

   518 				return;	// wait for the child to die

   519 				}

   520 			params->pint[0]=child->iExitReason;

   521 			params->ret=child->iPid;

   522 			iServer.Release(child);

   523 			}

   524 		else

   525 			{

   526 			anErrno=ECHILD;

   527 			params->ret=-1;

   528 			}

   529 		}

   530 		break;

   531 

   532 	// simple synchronous functions

   533 

   534 	case PMdup:

   535 		params->ret=Fids().dup(params->fid,anErrno);

   536 		break;

   537 	case PMdup2:

   538 		params->ret=Fids().dup2(params->fid,params->pint[0],anErrno);

   539 		break;

   540 	case PMopen: 

   541 		{

   542 		const wchar_t* name = params->cwptr[0];

   543 		if	((L'C' == name[0]) && (L'O' == name[1]) && (L'M' == name[2]) && (L':' == name[4]) && ((name[3] >= L'1') && (name[3] <= L'9')) ||

   544 			(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')))

   545 			params->ret=Fids().open(params->cwptr[0],params->pint[0],params->pint[1],anErrno,Cs());

   546 		else

   547 			params->ret=Fids().open(params->cwptr[0],params->pint[0],params->pint[1],anErrno,Fs());

   548 

   549 		}

   550 		break;

   551 	case PMclose: 

   552 		params->ret=Fids().userclose(params->fid,anErrno);

   553 		break;

   554 	case PMlseek: 

   555 		params->ret=Fids().lseek(params->fid,params->pint[0],params->pint[1],anErrno);

   556 		break;

   557 	case PMfstat: 

   558 		params->ret=Fids().fstat(params->fid,(struct stat*)params->ptr[0],anErrno);

   559 		break;

   560 	case PMgetcwd: 

   561 //		params->ret=(int)PosixFilesystem::getcwd(Fs(),params->ptr[0],params->len[0],anErrno);

   562 		params->ret=(int)PosixFilesystem::getcwd(Fs(),params->wptr[0],params->len[0],anErrno);

   563 		break;

   564 	case PMchdir: 

   565 		params->ret=PosixFilesystem::chdir(Fs(),params->cwptr[0],anErrno);

   566 		break;

   567 	case PMmkdir: 

   568 //		params->ret=PosixFilesystem::mkdir(Fs(),params->cptr[0],params->pint[0],anErrno);

   569 		params->ret=PosixFilesystem::mkdir(Fs(),params->cwptr[0],params->pint[0],anErrno);

   570 		break;

   571 	case PMrmdir: 

   572 		params->ret=PosixFilesystem::rmdir(Fs(),params->cwptr[0],anErrno);

   573 		break;

   574 	case PMchmod: 

   575 		params->ret=PosixFilesystem::chmod(Fs(),params->cwptr[0],params->pint[0],anErrno);

   576 		break;

   577 	case PMunlink: 

   578 		params->ret=PosixFilesystem::unlink(Fs(),params->cwptr[0],anErrno);

   579 		break;

   580 	case PMstat: 

   581 		params->ret=PosixFilesystem::stat(Fs(),params->cwptr[0],(struct stat*)params->ptr[0],anErrno);

   582 		break;

   583 	case PMrename: 

   584 		params->ret=PosixFilesystem::rename(Fs(), params->cwptr[0],params->cwptr[1],anErrno);

   585 		break;

   586 	case PMResolvePath:

   587 //		params->ret=PosixFilesystem::ResolvePath(Fs(),

   588 //			*(TParse*)params->ptr[0],params->cptr[0],(TDes*)params->ptr[1]);

   589 		params->ret=PosixFilesystem::ResolvePath(Fs(),

   590 			*(TParse*)params->ptr[0],params->cwptr[0],(TDes*)params->ptr[1]);

   591 		break;

   592 	case PMsocket:

   593 		params->ret=Fids().socket(params->pint[0],params->pint[1],params->pint[2],anErrno,Ss());

   594 		break;

   595 	case PMbind:

   596 		params->ret=Fids().bind(params->fid,params->addr,anErrno);

   597 		break;

   598 	case PMlisten:

   599 		params->ret=Fids().listen(params->fid,params->pint[0],anErrno);

   600 		break;

   601 	case PMsockname:

   602 		params->ret=Fids().sockname(params->fid,params->addr,params->pint[0],anErrno);

   603 		break;

   604 	case PMgetsockopt:

   605 		params->ret=Fids().getsockopt(params->fid,params->pint[0],params->pint[1],

   606 			params->ptr[0],params->lenp[0],anErrno);

   607 		break;

   608 	case PMsetsockopt:

   609 		params->ret=Fids().setsockopt(params->fid,params->pint[0],params->pint[1],

   610 			params->ptr[0],params->len[0],anErrno);

   611 		break;

   612 	case PMgetenv:

   613 		params->ret=(int)Env().getenv(params->cwptr[0]);

   614 		break;

   615 	case PMunsetenv:

   616 		Env().unsetenv(params->cwptr[0]);	// no return value

   617 		break;

   618 	case PMsetenv:

   619 		params->ret=Env().setenv(params->cwptr[0],params->cwptr[1],params->pint[0],anErrno);

   620 		break;

   621 	case PMioctlcomplete:

   622 		params->ret=Fids().ioctlcomplete(params->fid,params->pint[0],params->ptr[0],*(REINTERPRET_CAST(TRequestStatus*, params->ptr[1])), anErrno);

   623 		break;

   624 	case PMTerminateProcess:

   625 		{

   626 		int status = params->fid;

   627 		RProcess().Kill(status);

   628 		}

   629 		break;

   630 	case PMpopen3:

   631 		params->ret=iServer.POpen3(params,anErrno);

   632 		break;

   633 	default:

   634 		aMessage.Complete(KErrNotSupported);

   635 		return;

   636 		}

   637 	// deal with completion of a synchronous request

   638 	aMessage.Complete(KErrNone);

   639 	}

   640 

   641 // Asynchronous requests

   642 //

   643 // 1. QueueAsynch() to get into the appropriate queue in the FileDesc

   644 // 2. FileDesc calls StartAsynch() when it's our turn

   645 // 3. StartAsynch() makes the relevant IO call and does SetActive()

   646 // 4a.    RunL() handles the completion of the IO call and calls EndAsynch()

   647 // 4b.    DoCancel() handles cancellation of the IO call, but doesn't call EndAsynch()

   648 // 5. EndAsynch() removes us from the FileDesc queue and completes iMessage

   649 //

   650 

   651 void CPosixRequest::QueueAsynch(const RMessage2& aMessage)

   652 //

   653 // Add this to the appropriate queue in the associated file

   654 //

   655 	{

   656 	iMessage=aMessage;	// Suggested by AndrewT to avoid code duplication

   657 	iQueue=CFileDescBase::IOwriteQ;

   658 	switch (aMessage.Function())

   659 		{

   660 	case PMread:

   661 	case PMrecvfrom:

   662 		iQueue=CFileDescBase::IOreadQ;

   663 		break;

   664 	case PMioctl:

   665 		iQueue=CFileDescBase::IOioctlQ;

   666 		break;

   667 	case PMioctlN:

   668 		iQueue=CFileDescBase::IOioctlNQ;

   669 		break;

   670 	default:

   671 		// everything else uses the IOwriteQ, including Accept and Connect

   672 		break;

   673 		}

   674 

   675 	__ASSERT_ALWAYS(iFile!=0,CPosixServer::ServerPanic(EPosix_NoPendingIO));

   676 	iFile->AddLast(*this,iQueue);

   677 	}

   678 

   679 void CPosixRequest::StartAsynch()

   680 //

   681 // The request has reached the front of the queue and can now be actioned

   682 //

   683 	{

   684 	PosixParams* params=REINTERPRET_CAST(PosixParams*,CONST_CAST(TAny*,iMessage.Ptr1()));

   685 	switch (iMessage.Function())

   686 		{

   687 	case PMread:

   688 		{

   689 		

   690 		//if we need to have a timer for this operation to cancel it later

   691 		if (iFile->TimedRead())

   692 			{

   693 			iFile->ReadIsTimed = ETrue;

   694 			TRAPD(tRes, {iFile->TimedMessage = CSerialTimer::NewL(iFile);});

   695 			if (tRes != KErrNone)

   696 				{

   697 				//we have a problem here

   698 				//basically, fake the async request completing with the returned error

   699 				iStatus = KRequestPending;

   700 				SetActive();

   701 				TRequestStatus * ps = &iStatus;

   702 				User::RequestComplete(ps, tRes);

   703 				return;

   704 				}

   705 

   706 			iFile->TimedMessage->IssueRequest();

   707 			}

   708 		else

   709 			iFile->ReadIsTimed = EFalse;

   710 

   711 		iFile->ReadWasCancelled = EFalse;

   712 

   713 		iFile->Read(iPtr,iStatus);

   714 		

   715 		}

   716 		break;

   717 	case PMrecvfrom:

   718 		iFile->RecvFrom(iPtr,params->addr,params->pint[0],iStatus);

   719 		break;

   720 	case PMwrite:

   721 		iFile->Write(iPtr,iStatus);

   722 		break;

   723 	case PMsendto:

   724 		iFile->SendTo(iPtr,params->addr,params->pint[0],iStatus);

   725 		break;

   726 	case PMfsync:

   727 		iFile->Sync(iStatus);

   728 		break;

   729 	case PMconnect:

   730 		iFile->Connect(params->addr,iStatus);

   731 		break;

   732 	case PMshutdown:

   733 		iFile->Shutdown(params->pint[0],iStatus);

   734 		break;

   735 	case PMaccept:

   736 		iFile->Accept(iNewF,iStatus,Ss());

   737 		break;

   738 	case PMioctl:

   739 		iFile->Ioctl(params->pint[0],params->ptr[0],iStatus);

   740 		break;

   741 	case PMioctlN:

   742 		iFile->Ioctl(params->pint[0],params->ptr[0],iStatus);

   743 		break;

   744 	default:

   745 		EndAsynch(KErrGeneral);

   746 		return;

   747 		}

   748 	SetActive();	// for asynchronous completion via RunL

   749 	return;

   750 	}

   751 

   752 void CPosixRequest::RunL()

   753 //

   754 // The pending IO has completed, so handle the result

   755 //

   756 	{

   757 	__ASSERT_ALWAYS(iFile!=0,CPosixServer::ServerPanic(EPosix_NoPendingIO));

   758 	TInt completion=KErrNone;

   759 	int& anErrno=*REINTERPRET_CAST(int*,CONST_CAST(TAny*,iMessage.Ptr0()));

   760 	PosixParams* params=REINTERPRET_CAST(PosixParams*,CONST_CAST(TAny*,iMessage.Ptr1()));

   761 	switch (iMessage.Function())

   762 		{

   763 	case PMread:

   764 		{

   765 		if (iFile->ReadIsTimed)

   766 			{

   767 				//need to stop the timer

   768 				delete iFile->TimedMessage;

   769 				iFile->TimedMessage = NULL;

   770 				iFile->ReadIsTimed = EFalse;

   771 			}

   772 

   773 		TInt err=iFile->ReadCompletion(iPtr, iStatus.Int());

   774 		if (err==0)

   775 			{

   776 			params->ret=iPtr.Length();

   777 			break;

   778 			}

   779 		//if the read was cancelled and we are to patch it due to me cancelling it

   780 

   781 		if (iFile->ReadWasCancelled)

   782 			{

   783 			err = ETIMEDOUT;

   784 			iFile->ReadWasCancelled = EFalse;

   785 			}

   786 

   787 		params->ret=MapError(err,anErrno);

   788 		}

   789 		break;

   790 	case PMwrite:

   791 		{

   792 		TInt err=iFile->WriteCompletion(iPtr, iStatus.Int());

   793 		if (err==0)

   794 			{

   795 			params->ret=iPtr.Length();

   796 			break;

   797 			}

   798 		params->ret=MapError(err,anErrno);

   799 		}

   800 		break;

   801 	case PMconnect:

   802 	case PMshutdown:

   803 	case PMfsync:

   804 		params->ret=MapError(iStatus.Int(),anErrno);

   805 		break;

   806 	case PMsendto:

   807 		{

   808 		TInt err=iFile->SendToCompletion(iPtr, iStatus.Int());

   809 		if (err==0)

   810 			{

   811 			params->ret=iPtr.Length();

   812 			break;

   813 			}

   814 		params->ret=MapError(err,anErrno);

   815 		}

   816 		break;

   817 	case PMrecvfrom:

   818 		{

   819 		TInt err=iFile->RecvFromCompletion(params->ret, iStatus.Int());

   820 		if (err==0)

   821 			{

   822 			params->ret=iPtr.Length();

   823 			break;

   824 			}

   825 		params->ret=MapError(err,anErrno);

   826 		}

   827 		break;

   828 	case PMaccept:

   829 		{

   830 		TInt err=iStatus.Int();

   831 		if (err)

   832 			Fids().Attach(iNewFid,0);	// cancel the reservation

   833 		else

   834 			{

   835 			err=Fids().Attach(iNewFid,iNewF);

   836 			if (!err)

   837 				{

   838 				params->ret=iNewFid;

   839 				break;	// so that we return the new fid

   840 				}

   841 			delete iNewF;

   842 			iNewF=0;

   843 			}

   844 		params->ret=MapError(err,anErrno);

   845 		}

   846 		break;

   847 

   848 	case PMioctlN:

   849 		{

   850 		completion=iStatus.Int();	// caller picks up completion explicitly 

   851 		}

   852 		break;

   853 

   854 	case PMioctl:

   855 		{

   856 		completion=iStatus.Int();	// caller picks up completion explicitly 

   857 //		TInt err=iFile->IoctlCompletion(params->pint[0], &params->ret, iStatus.Int());

   858 //		params->ret=MapError(err,anErrno);

   859 		}

   860 		break;

   861 

   862 	default:

   863 		completion=KErrGeneral;	// arrgh - I imagine that it's going to die if we get here...

   864 		break;

   865 		}

   866 	EndAsynch(completion);

   867 	}

   868 

   869 void CPosixRequest::EndAsynch(TInt aResult)

   870 // 

   871 // finish an asynchronous operation and complete iMessage

   872 //

   873 	{

   874 	__ASSERT_ALWAYS(iFile!=0,CPosixServer::ServerPanic(EPosix_NoPendingIO));

   875 	iFile->Remove(*this,iQueue);

   876 	iFile->Close();	// balances the Dup() in CFileTable::Asynch(), may delete object!

   877 	iFile=0;

   878 	iMessage.Complete(aResult);	

   879 	}

   880 

   881 

   882 void CPosixRequest::DoCancel()

   883 //

   884 // The pending IO has been cancelled, so cancel the outstanding request

   885 // Needs to deal with all of the cases in RunL, but doesn't call EndAsynch().

   886 // This is called from CActive::Cancel() only when the object is active, but

   887 // EndAsynch() needs to be called when the object is active or when it's just

   888 // waiting in a FileDesc queue.

   889 //

   890 	{

   891 	__ASSERT_ALWAYS(iFile!=0,CPosixServer::ServerPanic(EPosix_NoPendingIO));

   892 	switch (iMessage.Function())

   893 		{

   894 	case PMread:

   895 		iFile->ReadCancel();

   896 		break;

   897 	case PMrecvfrom:

   898 		iFile->RecvFromCancel();

   899 		break;

   900 	case PMwrite:

   901 		iFile->WriteCancel();

   902 		break;

   903 	case PMsendto:

   904 		iFile->SendToCancel();

   905 		break;

   906 	case PMfsync:

   907 		iFile->SyncCancel();

   908 		break;

   909 	case PMconnect:

   910 		iFile->ConnectCancel();

   911 		break;

   912 	case PMshutdown:

   913 		iFile->ShutdownCancel();

   914 		break;

   915 	case PMaccept:

   916 		iFile->AcceptCancel();

   917 		Fids().Attach(iNewFid,0);	// cancel the reservation

   918 		break;

   919 	case PMioctl:

   920 		iFile->IoctlCancel();

   921 		break;

   922 	default:

   923 		// it would be wrong to get here, so leave well alone

   924 		break;

   925 		}

   926 	}

   927 

   928 CPosixRequest::~CPosixRequest()

   929 	{

   930 	Cancel();

   931 	if (iFile)

   932 		EndAsynch(KErrCancel);

   933 	}

   934 

   935 // Handling waiting on other processes

   936 //

   937 void CPosixRequest::EnList(CPosixRequest*& aHead)

   938 	{

   939 	iNext=aHead;

   940 	aHead=this;

   941 	}

   942 

   943 void CPosixRequest::WaitCompleted(TInt aPid, TInt aReason)

   944 	{

   945 	PosixParams* params=REINTERPRET_CAST(PosixParams*,CONST_CAST(TAny*,iMessage.Ptr1()));

   946 

   947 	__ASSERT_DEBUG(iMessage.Function()==PMwaitpid, CPosixServer::ServerPanic(EPosix_BadWaitCompletion));

   948 	params->pint[0]=aReason;

   949 	params->ret=aPid;

   950 	iMessage.Complete(KErrNone);

   951 

   952 	CPosixRequest* next=iNext;

   953 	iNext=0;

   954 	if (next)

   955 		next->WaitCompleted(aPid, aReason);

   956 	}

   957 

   958 static void ClosePipes(CPipeDesc* aPipes[3])

   959 	{

   960 	TInt i=0;

   961 	for (i=0; i<3; i++)

   962 		{

   963 		CPipeDesc* pipe=aPipes[i];

   964 		aPipes[i]=0;

   965 		if (pipe)

   966 			pipe->ClientClose();

   967 		}

   968 	}

   969 

   970 TInt CPosixIPCSession::AreYouMyMotherL(const RMessage2& aMessage)

   971 	{

   972 	TPosixIPCPid pid;

   973 	TPosixIPCReply reply;

   974 	aMessage.ReadL(0,pid);

   975 	DebugPrint(_L("Process %d asks am I its mother?"), pid());

   976 	CPosixServer* pServ = const_cast<CPosixServer*>(static_cast<const CPosixServer*>(Server()));

   977 	CPosixProcess* child=pServ->Child(pid());

   978 	if (!child)

   979 		return KErrNotFound;	// you are no child of mine

   980 	DebugPrint(_L("Found child process"));

   981 	child->Sizes(reply);

   982 	aMessage.Write(1,reply);

   983 	return KErrNone;

   984 	}

   985 

   986 TInt CPosixIPCSession::HelloMumL(const RMessage2& aMessage)

   987 	{

   988 	TPosixIPCPid pid;

   989 	aMessage.ReadL(0,pid);

   990 

   991 	DebugPrint(_L("Process %d is requesting its inheritance"),pid());

   992 

   993 	CPosixServer* pServ = const_cast<CPosixServer*>(static_cast<const CPosixServer*>(Server()));

   994 	CPosixProcess* child=pServ->Child(pid());

   995 	if (!child)

   996 		return KErrNotFound;	// you are no child of mine

   997 

   998 	// CopyToChildL will pull out the second and third element out directly so as

   999 	// to copy data to it. This is why data is passed in this way.

  1000 	child->CopyToChildL(aMessage);

  1001 	return KErrNone;

  1002 	}

  1003 

  1004 void CPosixIPCSession::PipeRead(const RMessage2& aMessage)

  1005 	{

  1006 	TInt index=aMessage.Int0();

  1007 	if (iPipes[index]==0)

  1008 		aMessage.Complete(KErrEof);	// go away, incorrect thing!

  1009 	else

  1010 		iPipes[index]->ClientRead(aMessage);

  1011 	}

  1012 

  1013 void CPosixIPCSession::PipeWrite(const RMessage2& aMessage)

  1014 	{

  1015 	TInt index=aMessage.Int0();

  1016 	if (iPipes[index]==0)

  1017 		aMessage.Complete(KErrEof);	// go away, incorrect thing!

  1018 	else

  1019 		iPipes[index]->ClientWrite(aMessage);

  1020 	}

  1021 

  1022 void CPosixIPCSession::PipeIoctl(const RMessage2& aMessage)

  1023 	{

  1024 	TInt index=aMessage.Int0();

  1025 	if (iPipes[index]==0)

  1026 		aMessage.Complete(KErrEof);	// go away, incorrect thing!

  1027 	else

  1028 		iPipes[index]->ClientIoctl(aMessage);

  1029 	}

  1030 

  1031 void CPosixIPCSession::PipeClose(const RMessage2& aMessage)

  1032 	{

  1033 	TInt index=aMessage.Int0();

  1034 	if (iPipes[index]!=0)

  1035 		iPipes[index]->ClientClose();

  1036 	aMessage.Complete(KErrNone);

  1037 	}

  1038 

  1039 void CPosixIPCSession::PipeCancel(const RMessage2& aMessage)

  1040 	{

  1041 	TInt index=aMessage.Int0();

  1042 	if (iPipes[index]!=0)

  1043 		iPipes[index]->ClientCancel(aMessage);

  1044 	aMessage.Complete(KErrNone);

  1045 	}

  1046 

  1047 void CPosixIPCSession::ServiceL(const RMessage2& aMessage)

  1048 //

  1049 // Handle the communication between CPosixServers

  1050 //

  1051 	{

  1052 	TInt response=KErrNone;

  1053 	switch (aMessage.Function())

  1054 		{

  1055 	case PMAreYouMyMother:

  1056 		response=AreYouMyMotherL(aMessage);

  1057 		break;

  1058 	case PMHelloMum:

  1059 		response=HelloMumL(aMessage);

  1060 		break;

  1061 

  1062 	case PMPipeRead:

  1063 		PipeRead(aMessage);

  1064 		return;	// handles completion

  1065 	case PMPipeWrite:

  1066 		PipeWrite(aMessage);

  1067 		return; // handles completion

  1068 	case PMPipeIoctl:

  1069 		PipeIoctl(aMessage);

  1070 		return; // handles completion

  1071 	case PMPipeClose:

  1072 		PipeClose(aMessage);

  1073 		return; // handles completion

  1074 

  1075 	case PMPipeCancel:

  1076 		PipeCancel(aMessage);

  1077 		return;

  1078 

  1079 	default:

  1080 		response=KErrNotSupported;

  1081 		break;

  1082 		}

  1083 	aMessage.Complete(response);

  1084 	}

  1085 

  1086 void CPosixIPCSession::SetPipes(CPipeDesc* aPipes[3])

  1087 //

  1088 // Accept ownership of the pipes between child and parent

  1089 //

  1090 	{

  1091 	TInt i=0;

  1092 	for (i=0; i<3; i++)

  1093 		{

  1094 		CPipeDesc* pipe=aPipes[i];

  1095 		iPipes[i]=pipe;

  1096 		aPipes[i]=0;

  1097 		if (pipe)

  1098 			pipe->SetClientSide(iPipes[i]);

  1099 		}

  1100 	}

  1101 

  1102 CPosixIPCSession::~CPosixIPCSession()

  1103 	{

  1104 	ClosePipes(iPipes);

  1105 	}

  1106 

  1107 // Active Object representing a POSIX process

  1108 

  1109 CPosixProcess::CPosixProcess(CPosixServer& aServer)

  1110 	: CActive(EPriorityStandard), iServer(aServer)

  1111 	{

  1112 	// iPid=0;

  1113 	// iWaiters=0;

  1114 	// iNextProcess=0;

  1115 	// iEnvironment=0;

  1116 	// iWorkingDirectory=0;

  1117 	}

  1118 

  1119 CPosixProcess* CPosixProcess::Find(CPosixProcess* proc, TInt pid)

  1120 	{

  1121 	while (proc!=0)

  1122 		{

  1123 		if (proc->iPid==pid)

  1124 			return proc;

  1125 		if (pid==-1 && !proc->IsAlive())	// for waitpid(WAIT_ANY,...)

  1126 			return proc;

  1127 		proc=proc->iNextProcess;

  1128 		}

  1129 	return 0;

  1130 	}

  1131 

  1132 void CPosixProcess::Release(CPosixProcess** aHead, CPosixProcess* aChild)

  1133 	{

  1134 	while (*aHead!=0)

  1135 		{