// Copyright (c) 2006-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 <e32std.h>

 #include "spawn_r.h"

 #include <spawn.h>

 #include <sys/syslimits.h>

 #include <errno.h>

 #include <wchar.h>

 #include <stdlib.h>

 #include <string.h>

 #include "sysreent.h"

 extern "C" {

 // -----------------------------------------------------------------------------

 // posix_spawn_file_actions_init

 // Initialize the file actions structure

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawn_file_actions_init(posix_spawn_file_actions_t* file_actions)

 	{

 	file_actions->_fa = new file_actions_t;

 	if (!file_actions->_fa)

 		{

 		return ENOMEM;

 		}

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawn_file_actions_addopen

 // Add an open action to the file actions structure

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawn_file_actions_addopen(

 				posix_spawn_file_actions_t* file_actions, 

 				int fid,

 				const char* path, 

 				int oflag, 

 				mode_t mode)

 	{

 	if (fid < 0 || fid > OPEN_MAX)

 		{

 		return EBADF;

 		}

 	TFileAction* fa = new TFileAction;

 	if (!fa)

 		{

 		return ENOMEM;

 		}

 	memset(fa, 0, sizeof(TFileAction));	

 	fa->iOp = EOpen;

 	fa->iFid1 = fid;

 	fa->iOFlag = oflag;

 	fa->iMode = mode;

 	int len = strlen(path)+1;

 	wchar_t* wpath = new wchar_t[len];

 	if (!wpath)

 		{

 		delete fa;

 		return ENOMEM;

 		}

 	if (mbstowcs(wpath, path, len) == (size_t)-1)

 		{

 		delete fa;

 		delete[] wpath;

 		return EILSEQ;

 		}

 	fa->iPath = new TFileName;

 	fa->iPath->Copy((TText16*)wpath, len);

 	delete[] wpath;

 	(file_actions->_fa->iActions).AddLast(*fa);

 	if (file_actions->_fa->iIter == NULL)

 		{

 		(file_actions->_fa->iIter).SetToFirst();

 		}

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawn_file_actions_adddup2

 // Add a dup2 action to the file actions structure

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawn_file_actions_adddup2(

 				posix_spawn_file_actions_t* file_actions, 

 				int fid1, 

 				int fid2)

 	{

 	if (fid1 < 0 || fid2 < 0 || fid1 > OPEN_MAX || fid2 > OPEN_MAX)

 		{

 		return EBADF;

 		}

 	TFileAction* fa = new TFileAction;

 	if (!fa)

 		{

 		return ENOMEM;

 		}

 	memset(fa, 0, sizeof(TFileAction));		

 	fa->iOp = EDup;

 	fa->iFid1 = fid1;

 	fa->iFid2 = fid2;

 	(file_actions->_fa->iActions).AddLast(*fa);

 	if (file_actions->_fa->iIter == NULL)

 		{

 		(file_actions->_fa->iIter).SetToFirst();

 		}

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawn_file_actions_addclose

 // Add a close action to the file actions structure

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawn_file_actions_addclose(

 				posix_spawn_file_actions_t* file_actions, 

 				int fid)

 	{

 	if (fid < 0 || fid > OPEN_MAX)

 		{

 		return EBADF;

 		}

 	TFileAction* fa = new TFileAction;

 	if (!fa)

 		{

 		return ENOMEM;

 		}

 	memset(fa, 0, sizeof(TFileAction));	

 	fa->iOp = EClose;

 	fa->iFid1 = fid;

 	(file_actions->_fa->iActions).AddLast(*fa);

 	if (file_actions->_fa->iIter == NULL)

 		{

 		(file_actions->_fa->iIter).SetToFirst();

 		}

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawn_file_actions_destroy

 // Empty and destroy the file actions structure

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t* file_actions)

 	{

 	if (!file_actions || !file_actions->_fa)

 		{

 		return EINVAL;

 		}

 	if (file_actions->_fa->iActions.IsEmpty())

 		{

 		delete file_actions->_fa;

 		return 0;

 		}

 	TFileAction* fa = (file_actions->_fa->iIter)++;

 	while (fa)

 		{

 		if (fa->iPath)

 			{

 			delete fa->iPath;

 			}

 		delete fa;

 		fa = (file_actions->_fa->iIter)++;

 		}

 	file_actions->_fa->iActions.Reset();

 	delete file_actions->_fa;

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawnattr_init

 // Initialize the spawn attributes structure

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawnattr_init(posix_spawnattr_t* attrp)

 	{

 	// we don't support these flags. simply set all attribs to 0.

 	if (!attrp)

 		{

 		return EINVAL;

 		}

 	memset(attrp, 0, sizeof(posix_spawnattr_t));

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawnattr_getsigdefault

 // Returns the sigdefault attribute

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawnattr_getsigdefault(

 				const posix_spawnattr_t* attrp, 

 				sigset_t* sigdefault)

 	{

 	if (!attrp || !sigdefault)

 		{

 		return EINVAL;

 		}

 	*sigdefault = attrp->_sd;

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawnattr_getflags

 // Return the flags attribute

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawnattr_getflags(

 				const posix_spawnattr_t* attrp,

 				short* flags)

 	{

 	if (!attrp || !flags)

 		{

 		return EINVAL;

 		}

 	*flags = attrp->_flags;

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawnattr_getpgroup

 // Return the process group attribute

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawnattr_getpgroup(

 				const posix_spawnattr_t* attrp, 

 				pid_t* pgroup)

 	{

 	if (!attrp || !pgroup)

 		{

 		return EINVAL;

 		}

 	*pgroup = attrp->_pgrp;

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawnattr_getschedparam

 // Return scheduling parameters attribute

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawnattr_getschedparam(

 				const posix_spawnattr_t* attrp,

           		struct sched_param* schedparam)

 	{

 	if (!attrp || !schedparam)

 		{

 		return EINVAL;

 		}

 	*schedparam = attrp->_sp;

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawnattr_getschedpolicy

 // Return the scheduling policy attribute

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawnattr_getschedpolicy(

 				const posix_spawnattr_t* attrp, 

 				int* policy)

 	{

 	if (!attrp || !policy)

 		{

 		return EINVAL;

 		}

 	*policy = attrp->_policy;

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawnattr_getsigmask

 // Return the signal mask attribute

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawnattr_getsigmask(

 				const posix_spawnattr_t* attrp, 

 				sigset_t* sigmask)

 	{

 	if (!attrp || !sigmask)

 		{

 		return EINVAL;

 		}

 	*sigmask = attrp->_sm;

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawnattr_setsigdefault

 // Sets the sigdefault attribute

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawnattr_setsigdefault(

 				posix_spawnattr_t* attrp,

 				const sigset_t* sigdefault)

 	{

 	if (!attrp || !sigdefault)

 		{

 		return EINVAL;

 		}

 	attrp->_sd = *sigdefault;

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawnattr_setflags

 // Sets the flags attribute

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawnattr_setflags(posix_spawnattr_t* attrp, short flags)

 	{

 	if (!attrp)

 		{

 		return EINVAL;

 		}

 	attrp->_flags = flags;

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawnattr_setpgroup

 // Sets the process group attribute

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawnattr_setpgroup(posix_spawnattr_t* attrp, pid_t pgroup)

 	{

 	if (!attrp)

 		{

 		return EINVAL;

 		}

 	attrp->_pgrp = pgroup;

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawnattr_setschedparam

 // Sets the scheduling parameters attribute

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawnattr_setschedparam(

 				posix_spawnattr_t* attrp,

 				const struct sched_param* schedparam)

 	{

 	if (!attrp || !schedparam)

 		{

 		return EINVAL;

 		}

 	attrp->_sp = *schedparam;

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawnattr_setschedpolicy

 // Sets the scheduling policy attribute

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawnattr_setschedpolicy(posix_spawnattr_t* attrp, int policy)

 	{

 	if (!attrp)

 		{

 		return EINVAL;

 		}

 	attrp->_policy = policy;

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawnattr_setsigdefault

 // Sets the sigmask attribute

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawnattr_setsigmask(

 				posix_spawnattr_t* attrp, 

 				const sigset_t* sigmask)

 	{

 	if (!attrp || !sigmask)

 		{

 		return EINVAL;

 		}

 	attrp->_sm = *sigmask;

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawnattr_setsigdefault

 // Empty and cleanup the spawn attributes structure

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawnattr_destroy(posix_spawnattr_t* /*attrp*/)

 	{

 	// nothing to do

 	return 0;

 	}

 // -----------------------------------------------------------------------------

 // posix_spawn

 // Launch a child process specified by path and obtain its pid

 // This API allows the caller to specify command line arguments and envp for the child

 // In addition, one can also specify a set of file operations that will be performed

 // and a set of attributes that will be applied in the child before it enters its main.

 // -----------------------------------------------------------------------------

 EXPORT_C int posix_spawn(

 				pid_t* pid, 

 				const char* path,

 				const posix_spawn_file_actions_t* file_actions,

 				const posix_spawnattr_t* attrp, 

 				char *const argv[],

 				char *const envp[])

 	{

 	if(path == NULL || *path == '\0')

 		{

 		return ECHILD;

 		}

 	int len = strlen(path) + 1;

 	wchar_t* wpath = new wchar_t[len];

 	if (mbstowcs(wpath, path, len) == (size_t)-1)

 		{

 		delete[] wpath;

 		return EILSEQ;

 		}

 	int ret = 0;

 	wchar_t* wargs = NULL;

 	wchar_t** wenvp = NULL;

 	if (argv && argv[1])

 		{

 		TInt totlen = 0;

 		// argv[0] is (or atleast should be) the exe name

 		for (int i = 1; argv[i]; ++i)

 			{

 			totlen += strlen(argv[i]) + 1;

 			}

 		wargs = new wchar_t[totlen+1];

 		if (!wargs)

 			{

 			ret = ENOMEM;

 			goto bailout;

 			}

 		wchar_t* wp = wargs;

 		// argv[0] is (or atleast should be) the exe name

 		for (int i = 1; argv[i]; ++i)

 			{

 			int len = strlen(argv[i]);

 			if (mbstowcs(wp, argv[i], len) == (size_t)-1)

 				{

 				ret = EILSEQ;

 				goto bailout;

 				}

 			wp[len++] = L' ';

 			wp += len;

 			}

 		// replace the last blank with a null character

 		*(--wp) = 0;

 		}

 	if (envp)

 		{

 		TInt count = 0;

 		for (; envp[count]; ++count) {}

 		//coverity[alloc_fn]

 		//coverity[assign]

 		wenvp = new wchar_t*[count+1];

 		if (!wenvp)

 			{

 			ret = ENOMEM;

 			goto bailout;

 			}

 		for (int i = 0; i < count; ++i)

 			{

 			int len = strlen(envp[i]) + 1;

 			wenvp[i] = new wchar_t[len];

 			if (wenvp[i] == NULL)

 				{

 				ret = ENOMEM;

 				goto bailout;

 				}

 			if (mbstowcs(wenvp[i], envp[i], len) == (size_t)-1)

 				{

 				ret = EILSEQ;

 				wenvp[i+1] = NULL;

 				goto bailout;

 				}

 			}

 		wenvp[count] = 0;

 		}

 	//coverity[leave_without_push]

 	ret = _posix_spawn_r(pid, wpath, file_actions, attrp, wargs, wenvp);

 bailout:

 	delete[] wpath;

 	if (wargs)

 		{

 		delete[] wargs;

 		}

 	if (wenvp)

 		{

 		for (int i = 0; wenvp[i]; ++i)

 			{

 			delete wenvp[i];

 			}

 		delete wenvp;

 		}

 	return ret;

 	}

 }  //extern "C"