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

// Abstraction for "an environment" holding pairs of C strings (name, value)

// 

//

#include "ENVIRON.H"

#include "LPOSIX.H"

#include <string.h>

TPtrC16 TEnvVar::ValuePtr(const wchar_t* aValue)

//

// Turn a zero-terminated string into a descriptor which contains the terminator

//

	{

	TText16* value = (TText16*)aValue;

	return TPtrC16(value, User::StringLength(value)+1);

	}

void TEnvVar::ConstructL(const TDesC16& aName, const wchar_t* aValue)

	{

	TPtrC16 valueZ = ValuePtr(aValue);

	HBufC16* valueCopy = valueZ.AllocLC();

	iName = aName.AllocL();

	iValue = valueCopy;

	CleanupStack::Pop();

	}

void TEnvVar::Release()

	{

	delete iName;

	iName=0;

	delete iValue;

	iValue=0;

	}

TInt TEnvVar::SetValue(const wchar_t* aValue)

//

// Change the value - if this returns an error then the original value is still intact

//

	{

	TPtrC16 valueZ = ValuePtr(aValue);

	HBufC16* valueCopy=valueZ.Alloc();

	if (valueCopy==0)

		return KErrNoMemory;

	delete iValue;

	iValue = valueCopy;

	return KErrNone;

	}

HBufC16* TEnvVar::Match(const TDesC16& aName)

//

// return value if the name matches

//

	{

	if (iName!=0 && iName->Compare(aName)==0)

		return iValue;

	return 0;

	}

TUint TEnvVar::Length() const

//

// How much space do we need to externalize this pair?

// The format is name followed by '\0' followed by value followed by '\0'

//

	{

	if (iName==0) 

		return 0;

	return iName->Length()+iValue->Length()+2;

	}

TInt TEnvVar::Externalize(const wchar_t* aPair, TDes16& aBuffer)

//

// static function to externalize a "name=value" definition

//

	{

	const wchar_t* cp=aPair;

	for (cp=aPair; *cp; ++cp)

		{

		if (*cp==L'=')

			break;

		}

	if (*cp!=L'=')

		return 0;	// malformed

	TPtrC16 name((TText16*)aPair,cp-aPair);

	TPtrC16 value((TText16*)(cp+1));

	aBuffer.Append(name);

	aBuffer.Append(TChar(0));

	aBuffer.Append(value);

	aBuffer.Append(TChar(0));

	return 1;

	}

TInt TEnvVar::Externalize(TDes16& aBuffer)

	{

	if (iName==0) 

		return 0;

	aBuffer.Append(*iName);

	aBuffer.Append(TChar(0));

	aBuffer.Append(*iValue);

	aBuffer.Append(TChar(0));

	return 1;

	}

void TEnvVar::ConstructL(const TText16*& aPtr)

	{

	TPtrC16 name(aPtr);

	aPtr+=name.Length()+1;

	ConstructL(name,(const wchar_t*)aPtr);

	aPtr+=iValue->Length()+1;

	}

CEnvironment::~CEnvironment()

	{

	while (iCount>0)

		{

		--iCount;

		iVars[iCount].Release();

		}

	User::Free(iVars);

	}

void CEnvironment::ConstructL(TUint aCount, TDes16& aBuffer)

//

// Set up the environment from a descriptor. If this leaves then

// the CEnvironment destructor will be able to clean up properly.

//

	{

	// always allocate at least one slot - makes life easier elsewhere

	TInt bytes = (aCount+1)*sizeof(TEnvVar);

	iVars=(TEnvVar*) User::AllocL(bytes);

	Mem::FillZ(iVars,bytes);

	iCount=aCount+1;

	const TText16* data=aBuffer.Ptr();

	for (TUint i=0; i<aCount; ++i)

		iVars[i].ConstructL(data);

	}

HBufC16* CEnvironment::ExternalizeLC(TUint& aCount, wchar_t** envp)

	{

	if (envp==0)

		return ExternalizeLC(aCount);	// get current environment

	// Externalize supplied environment

	TInt length=0;

	wchar_t** ep=envp;

	for (ep=envp; *ep; ++ep)

		length+=wcslen(*ep)+1;

	HBufC16* retBuf = HBufC16::NewLC(length);

	TInt nvars=0;

	TPtr16 hbuf16=retBuf->Des();

	for (ep=envp; *ep; ++ep)

		nvars+=TEnvVar::Externalize(*ep, hbuf16);

	aCount=nvars;

	return retBuf;

	}

HBufC16* CEnvironment::ExternalizeLC(TUint& aCount)

	{

	TInt length=0;

	TUint i=0;

	for (i=0; i<iCount; ++i)

		length+=iVars[i].Length();

	HBufC16* retBuf = HBufC16::NewLC(length);

	TInt nvars=0;

	TPtr16 hbuf16=retBuf->Des();

	for (i=0; i<iCount; i++)

		nvars+=iVars[i].Externalize(hbuf16);

	aCount=nvars;

	return retBuf;

	}

// The interface used to support the STDLIB routines

wchar_t * CEnvironment::getenv(const wchar_t* aName) const

	{

	TPtrC16 name((TText16*)aName);

	for (TUint i=0; i<iCount; ++i)

		{

		HBufC16* value=iVars[i].Match(name);

		if (value)

			{

			const wchar_t* vptr = (const wchar_t*)(value->Ptr());

			return CONST_CAST(wchar_t*,vptr);	// I hope nobody modifies this data...

			}

		}

	return 0;

	}

int CEnvironment::setenv(const wchar_t* aName, const wchar_t* aValue, int aReplace, int& anErrno)

	{

	TPtrC16 name((TText16*)aName);

	TUint freeSlot=iCount;

	TEnvVar* ep=iVars;

	for (TUint i=0; i<iCount; ++i,++ep)

		{

		if (ep->NotEmpty())

			{

			const TDesC16* existing=ep->Match(name);

			if (existing)

				{

				TInt err=KErrNone;

				if (aReplace)

					ep->SetValue(aValue);

				return MapError(err,anErrno);

				}

			}

		else

			freeSlot=i;

		}

	if (freeSlot==iCount)	

		{

		// no free slots, time to grow the array

		ep=(TEnvVar*)User::ReAlloc(iVars,(iCount+1)*sizeof(TEnvVar));

		if (ep==0)

			return KErrNoMemory;

		iVars=ep;

		++iCount;

		}

	TRAPD(ret,iVars[freeSlot].ConstructL(name,aValue));

	return MapError(ret,anErrno);

	}

void CEnvironment::unsetenv(const wchar_t* aName)

	{

	TPtrC16 name((TText16*)aName);

	for (TUint i=0; i<iCount; ++i)

		{

		const TDesC16* value=iVars[i].Match(name);

		if (value)

			{

			iVars[i].Release();

			return;

			}

		}

	}