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