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