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

 // connectors for shared environment variables

 // 

 //

 #include "SYSIF.H"

 #include "LPOSIX.H"

 #include <errno.h>

 #include <string.h>

 #include <stdlib_r.h>

 extern "C" {

 /**

 Get string from environment.

 @return A null-terminated string with the value of the requested environment 

 variable or NULL if that environment variable does not exist.

 @param name Null-terminated string containing the name of the requested variable.

 */

 EXPORT_C char* getenv (const char* name)

 	{

 	return _getenv_r (_REENT, name);

 	}

 /**

 A reentrant version of getenv().

 */

 EXPORT_C char* _getenv_r (struct _reent *r, const char* name)

 	{

 //	wchar_t tmpbuf[KMaxFullName+1];		//use the max path length possible

 	char *  rval = NULL;

 	int err = 0;

 	wchar_t * tmpbuf = (wchar_t*)malloc(2*(strlen(name)+1));

 	if (tmpbuf)

 		{

 		if (-1 != mbstowcs(tmpbuf, name, strlen(name)+1))

 			{

 			MSystemInterface& sysIf=Interface(r);

 			wchar_t * wideval = sysIf.getenv(tmpbuf);

 			if (wideval)

 				{

 				//get the max size

 				int size = 1 + 2* wcslen(wideval);

 				if (size < _MINNARROWBUFSIZE)

 					size = _MINNARROWBUFSIZE;

 				if (size > r->_NEBSize)

 					{

 					//this string could be longer

 					char * p = (char*)realloc(r->_pNarrowEnvBuffer, size);

 					if (p)

 						{

 						r->_pNarrowEnvBuffer = p;

 						r->_NEBSize = size;

 						}

 					else

 						err = ENOMEM;

 					}

 				if (wcstombs(r->_pNarrowEnvBuffer, wideval, r->_NEBSize) >= 0)

 					rval =  r->_pNarrowEnvBuffer;

 				}

 			}

 		else

 			err = EILSEQ;

 		}

 	MapError(err, r->_errno);

 	free(tmpbuf);

 	return rval;

 	}

 EXPORT_C wchar_t* wgetenv (const wchar_t* name)

 	{

 	return _wgetenv_r (_REENT, name);

 	}

 /**

 A reentrant version of wgetenv().

 */

 EXPORT_C wchar_t* _wgetenv_r (struct _reent *r, const wchar_t* name)

 	{

 	MSystemInterface& sysIf=Interface(r);

 	return sysIf.getenv(name);

 	}

 /**

 Removes an environment variable.

 */

 EXPORT_C void unsetenv (const char* name)

 	{

 	_unsetenv_r (_REENT, name);

 	}

 /**

 A reentrant version of unsetenv().

 */

 EXPORT_C void _unsetenv_r (struct _reent *r, const char* name)

 	{

 	int rval = 0;

 	wchar_t* tmpbuf = (wchar_t*)malloc(2*(strlen(name)+1));

 	if (tmpbuf)

 		{

 		if (-1 != mbstowcs(tmpbuf, name, strlen(name)+1))

 			{

 			MSystemInterface& sysIf=Interface(r);

 			sysIf.unsetenv(tmpbuf);

 			}

 		else

 			rval = EILSEQ;

 		}

 	else

 		rval = ENOMEM;

 	free(tmpbuf);

 	MapError(rval, r->_errno);

 	}

 /**

 A wide-character version of a unsetenv()

 */

 EXPORT_C void wunsetenv (const wchar_t* name)

 	{

 	_wunsetenv_r (_REENT, name);

 	}

 /**

 A reentrant version of wunsetenv().

 */

 EXPORT_C void _wunsetenv_r (struct _reent *r, const wchar_t* name)

 	{

 	MSystemInterface& sysIf=Interface(r);

 	sysIf.unsetenv(name);

 	}

 /**

 Adds or changes an environment variable.

 @return On Success, returns 0.

 		On Failure, returns -1, errno may be set and the environment shall be unchanged.

 */

 EXPORT_C int setenv (const char *name, const char *value, int rewrite)

 	{

 	struct _reent *r = _REENT2;

 	if (!r)

 		return -1; // Memory for library globals is not allocated (errno not set).

 	return _setenv_r(r, name, value, rewrite);

 	}

 /**

 A reentrant version of setenv().

 */

 EXPORT_C int _setenv_r (struct _reent *r, const char *name, const char *value, int rewrite)

 	{

 	int rval = 0;

 	wchar_t* wname = (wchar_t*)malloc(2*(strlen(name)+1));

 	wchar_t* wvalue = (wchar_t*)malloc(2*(strlen(value)+1));

 	if (wname && wvalue)	//the allocs were OK

 		{

 		if ((-1 != mbstowcs(wname, name, strlen(name)+1)) &&

 			(-1 != mbstowcs(wvalue, value, strlen(value)+1)))

 			{

 			MSystemInterface& sysIf=Interface(r);

 			rval = sysIf.setenv(wname, wvalue, rewrite, r->_errno);

 			}

 		else

 			rval =  MapError(EILSEQ, r->_errno);

 		}

 	else

 		rval =  MapError(ENOMEM, r->_errno);

 	free (wname);

 	free (wvalue);

 	return rval;

 	}

 /**

 A wide-character version of a setenv()

 */

 EXPORT_C int wsetenv (const wchar_t *name, const wchar_t *value, int rewrite)

 	{

 	struct _reent *r = _REENT2;

 	if (!r)

 		return -1; // Memory for library globals is not allocated (errno not set).

 	return _wsetenv_r(r, name, value, rewrite);

 	}

 /**

 A reentrant version of wsetenv().

 */

 EXPORT_C int _wsetenv_r (struct _reent *r, const wchar_t *name, const wchar_t *value, int rewrite)

 	{

 	MSystemInterface& sysIf=Interface(r);

 	return sysIf.setenv(name,value,rewrite,r->_errno);

 	}

 } // extern "C"