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

 			}

 		}

 	}