// Copyright (c) 1998-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:

 // C routines for creating EPOC32 threads

 // 

 //

 #include <e32std.h>

 #include <estlib.h>		/* for SpawnPosixServerThread */

 #include <unistd.h>

 #include <stdio.h>		/* for popen3 */

 #include <stdlib.h>		/* for mbstowcs */

 #include "CTEST.H"

 #include <sys/errno.h>		/* for errno */

 #include <sys/wait.h>

 typedef void (*FUNC)();

 struct cthread 

 {

 	RThread iThread;

 	RProcess iProcess;

 	TRequestStatus iStatus;

 	int pid;

 };

 TInt threadhelper (TAny* aFn)

 	{

 	CTrapCleanup::New();

 	FUNC f=(FUNC)aFn;

 	(*f)();

 	return 0;

 	}

 #if defined(__WINS__)

 IMPORT_C void NewProcessId();		// WINS bodges for multiple "processes"

 IMPORT_C void NextProcessFn(TAny*);	

 TInt processhelper (TAny* aFn)

 	{

 	// Do the MCRT0.OBJ things straight away

 	NewProcessId();

 	SpawnPosixServerThread();

 	char wd[80];

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

 	return threadhelper(aFn);

 	}

 #endif //__WINS__

 extern "C" {

 EXPORT_C int start_posix_server()

 	{

 	start_redirection_server();

 	return SpawnPosixServerThread();

 	}

 EXPORT_C void* create_thread(void (*aFn)(), char* aName)

 	{

 #ifdef _UNICODE

 	TPtrC8 ptr((TText8*)aName);

 	TBuf<80> name;

 	name.Copy(ptr);

 #else

 	TPtrC8 name((TText8*)aName);

 #endif /* _UNICODE */

 	struct cthread* t = new cthread;

 	// 16k stack, share parent's heap

 	TInt err=t->iThread.Create(name, threadhelper, 0x4000, NULL, (TAny*)aFn);

 	t->iThread.Logon(t->iStatus);

 	if (err!= KErrNone)

 		return 0;

 	return (void*)t;

 	}

 EXPORT_C void start_thread(void* aThread)

 	{

 	struct cthread* t=REINTERPRET_CAST(struct cthread*,aThread);

 	t->iThread.Resume();

 	}

 EXPORT_C int wait_for_thread(void* aThread)

 	{

 	struct cthread* t=REINTERPRET_CAST(struct cthread*,aThread);

 	User::WaitForRequest(t->iStatus);

 	int ret=t->iThread.ExitReason();

 	t->iThread.Close();

 	delete t;

 	return ret;

 	}

 EXPORT_C void* create_process(void (*aFn)(), char* aName, char* mode, int fids[3])

 	{

 #ifdef _UNICODE

 	TPtrC8 ptr((TText8*)aName);

 	TBuf<80> name;

 	name.Copy(ptr);

 #else

 	TPtrC8 name((TText8*)aName);

 #endif /* _UNICODE */

 	struct cthread* t = new cthread;

 	TFileName this_exe = t->iProcess.FileName();

 	TBuf<256> cmd;

 	cmd.Format(_L("%S %S"),&this_exe,&name);

 	cmd.ZeroTerminate();

 #ifdef _UNICODE

 	wchar_t wmode[MAXPATHLEN+1];

 	mbstowcs(wmode, mode, MAXPATHLEN);

 	t->pid=wpopen3((const wchar_t*)cmd.Ptr(), wmode, 0, fids);

 #else

 	t->pid=popen3((const char*)cmd.Ptr(), mode, 0, fids);

 #endif

 	if (t->pid < 0)

 		return 0;

 	User::After(1000000); // 1 Second

 	return (void*)t;

 	}

 EXPORT_C void start_process(void* /*aProcess*/)

 	{

 	// too late, it's already running!

 	}

 EXPORT_C int wait_for_process(void* aProcess)

 	{

 	struct cthread* t=REINTERPRET_CAST(struct cthread*,aProcess);

 	int exit=-1;

 	int pid=waitpid(t->pid, &exit, 0);

 	if (pid<0)

 		return errno;

 	return exit;

 	}

 EXPORT_C int wait_for_process_id(void* aProcess, int procid, int opt, int* status)

 	{

 	// added function to enable calling of waitpid with specific parameters

 	int pid=waitpid(procid, status, opt);

 	return pid;

 	}

 EXPORT_C int get_proc_id(void* aProcess)

 	{

 	// return the pid of a process

 	struct cthread* t=REINTERPRET_CAST(struct cthread*,aProcess);

 	return t->pid;

 	}

 // Testing the dodgy asynchronous form of select

 EXPORT_C int async_ioctl(int aFid, int aCmd, void* aParam, int* status)

 	{

 	TRequestStatus& theStatus = *(TRequestStatus*)status;

 	return ioctl(aFid,aCmd,aParam,theStatus);

 	}

 EXPORT_C int async_ioctl_completion(int aFid, int aCmd, void* aParam, int* status)

 	{

 	TRequestStatus& theStatus = *(TRequestStatus*)status;

 	User::WaitForRequest(theStatus);

 	return ioctl_complete(aFid,aCmd,aParam,theStatus);

 	}

 } // extern "C"