/*

* Copyright (c) 2002-2004 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: Implementation of policymanagement components

*

*/

// INCLUDE FILES

#define __INCLUDE_CAPABILITY_NAMES__

#include "IniFileHelper.h"

#include "constants.h"

#include "debug.h"

#include <e32capability.h>

#include <centralrepository.h>

#include <utf.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

static const TChar KNullDataIndicator = '-';

static const TInt KMaxCapCount = 7;

static const TInt KMaxCapCountSidExist = 3;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// ==================== LOCAL FUNCTIONS =================

// ================= MEMBER FUNCTIONS =======================

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

// CSecuritySetting::AddSid()

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

//

CSecuritySetting::CSecuritySetting()

{

	iSidExistWr = iSidExistRd = EFalse;

	for ( TInt i(0); i < KMaxCapCount; i++)

	{

		iCapWr[i] = iCapRd[i] = TUint8(ECapability_None);

	}

}

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

// CSecuritySetting::SecurityString()

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

//

TDesC& CSecuritySetting::SecurityString( TDes &aSecurityString)

{

	using namespace IniConstants;

	aSecurityString.Zero();	

	TBuf<30> cap;

	TInt capCount = KMaxCapCount;

	if ( iSidExistRd)

	{

		//create sid_wr=0x000000 string, where 0x000000 is aSecurityId  

		TBuf< KUidLengthSet> name;

		name.Num( iSidRd.iUid, EDecimal);

		aSecurityString.Append( KReadAccessSidString );

		aSecurityString.Append( _L("=") );

		aSecurityString.Append( name );

			aSecurityString.Append(' ');

		capCount = KMaxCapCountSidExist;	

	}

	for ( TInt i(0); i < capCount; i++)

	{

		if ( iCapRd[ i] != TUint8(ECapability_None) )

		{

			aSecurityString.Append( KReadAccessCapString);

			aSecurityString.Append('=');

			cap.Copy( ConvertCapToStr( iCapRd[ i], iDefaultTypeRd));

			aSecurityString.Append( cap);

			aSecurityString.Append(' ');

		}

	}

	capCount = KMaxCapCount;

	if ( iSidExistWr)

	{

		//create sid_wr=0x000000 string, where 0x000000 is aSecurityId  

		TBuf< KUidLengthSet> name;

		name.Num( iSidWr.iUid, EDecimal);

		aSecurityString.Append( KWriteAccessSidString );

		aSecurityString.Append( _L("=") );

		aSecurityString.Append( name );

		aSecurityString.Append(' ');

		capCount = KMaxCapCountSidExist;	

	}

	for ( TInt i(0); i < capCount; i++)

	{

		if ( iCapWr[ i] != TUint8(ECapability_None) )

		{

			aSecurityString.Append( KWriteAccessCapString);

			aSecurityString.Append('=');

			cap.Copy( ConvertCapToStr( iCapWr[ i], iDefaultTypeWr));

			aSecurityString.Append( cap);

			aSecurityString.Append(' ');

		}

	}

	return aSecurityString;

}

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

// CSecuritySetting::ContainsSecuritySettings()

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

//

TBool CSecuritySetting::ContainsSecuritySettings()

{

	return iSidExistWr || iSidExistRd || iCapWr[0] != TUint8(ECapability_None) || iCapRd[0] != TUint8(ECapability_None);

}

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

// CSecuritySetting::CheckAccess()

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

//

TBool CSecuritySetting::CheckAccess( const RMessage2& aMessage, TAccessType aAccessType)

{

	TBool retVal = ETrue;

	if ( aAccessType == EReadAccess || aAccessType == EAccessBoth)

	{

		TInt capCount = KMaxCapCount;

		if ( iSidExistRd)

		{

			capCount = KMaxCapCountSidExist;

			if ( aMessage.SecureId().iId != iSidRd.iUid)

			{

				return EFalse;

			}

		}

		for ( TInt i(0); i < capCount; i++)

		{

			if ( iCapRd[ i] != TUint8(ECapability_None))

			{

				if ( !aMessage.HasCapability( TCapability( iCapRd[ i]), KSuppressPlatSecDiagnosticMagicValue))

				{

					return EFalse;

				}

			}

		}

	}

	if ( aAccessType == EWriteAccess || aAccessType == EAccessBoth)

	{

		TInt capCount = KMaxCapCount;

		if ( iSidExistWr)

		{

			capCount = KMaxCapCountSidExist;

			if ( aMessage.SecureId().iId != iSidWr.iUid)

			{

				return EFalse;

			}

		}

		for ( TInt i(0); i < capCount; i++)

		{

			if ( iCapWr[ i] != TUint8(ECapability_None))

			{

				if ( !aMessage.HasCapability( TCapability( iCapWr[ i]), KSuppressPlatSecDiagnosticMagicValue))

				{

					return EFalse;

				}

			}

		}

	}

	return retVal;

}

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

// CSecuritySetting::AddSid()

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

//

KSettingType CSecuritySetting::Type()

{

	return iType;	

}

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

// CSecuritySetting::AddSid()

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

//

TInt CSecuritySetting::AddSid( TUid aUid)

{

	if ( iSidExistWr)

	{

		return KErrAlreadyExists;

	}

	//enable and set sid

	iSidWr = aUid;

	iSidExistWr = ETrue;

	return KErrNone;

}

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

// CSecuritySetting::RemoveSid()

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

//

TInt CSecuritySetting::RemoveSid()

{

	//disable sid...

	iSidExistWr = EFalse;

	return KErrNone;

}

void CSecuritySetting::CopyCapabilities( CSecuritySetting* aSetting)

{

	//Copy all capabilities from parameter object to this object

	iSidExistWr = aSetting->iSidExistWr;

	iSidWr = aSetting->iSidWr;

	iSidExistRd = aSetting->iSidExistRd;

	iSidRd = aSetting->iSidRd;

	for ( TInt i(0); i < KMaxCapCount; i++)

	{

		iCapRd[i] = aSetting->iCapRd[i];

		iCapWr[i] = aSetting->iCapWr[i];

	}

}

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

// CSecuritySetting::RemoveSid()

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

//

TInt CSecuritySetting::ReadCaps( TLex& aLex)

{

	//read capablities, format: cap_type=cap_value

	using namespace IniConstants;

	TLex lex( aLex);

	lex.SkipSpace();

	TInt err( KErrNone);

	//read until TLex reaches Eos...

	while ( !lex.Eos() && err == KErrNone)

	{	

		//Mark start point

		TLexMark16 mark;

		lex.Mark( mark);

		lex.SkipSpace();

		//get next token, contains capability type

		TPtrC token = lex.NextToken();;

		TPtrC typePtr( token); 

		TPtrC capOrSid;

		//format could be "cap_type=..." or "cap_type =...", try to locate '='-mark from token

		TInt index = token.Locate('=');

		if ( index >= 0)

		{

			typePtr.Set( token.Left( index));

			token.Set( token.Mid( index + 1));

		} 

		//read capabilities from. There could be max 3 caps separated with ','

		TBool capOrSidDetected = EFalse;

		TBool ready = EFalse;

		do

		{

			//read new token if current token is empty

			if ( !token.Length())

			{

				TLexMark subMark;

				lex.Mark( subMark);

				token.Set( lex.NextToken());

				//if token contains only ',', then get new one

				if ( token.Length() == 1 && token[0] == ',')

				{

					token.Set( lex.NextToken());

				}

				//check if capability type changes (e.g. cap_wr -> cap_rd)

				TPtrC ptr( token);

				TInt index = token.Locate('=');

				if ( index >= 0)

				{

					ptr.Set( token.Left(index));

				}

				if ( ptr.CompareF( KReadAccessSidString) == 0  ||

					 ptr.CompareF( KReadAccessCapString) == 0  ||

					 ptr.CompareF( KWriteAccessSidString) == 0 ||

					 ptr.CompareF( KWriteAccessCapString) == 0 )

				{

					token.Set( KNullDesC);

					lex.UnGetToMark( subMark);					

					if ( !capOrSidDetected)

					{

						return KErrCorrupt;

					}

					ready = ETrue;

					continue;

				}

			}

			//read capability or SID

			if ( token.Length() )

			{

				//rome ','-mark if exist

				TInt index = token.Locate(',');		

				if ( index >= 0 )

				{

					capOrSid.Set( token.Left( index ));

					token.Set( token.Mid( index + 1));

				}

				else

				{

					capOrSid.Set( token);

					token.Set( KNullDesC);

				}

				//and cap or SID found add it to the setting

				if ( capOrSid.Length())

				{

					capOrSidDetected = ETrue;

					err = AddSecurityAttributes( typePtr, capOrSid);

				}

			}

			else

			{

				ready = ETrue;

			}

		} while ( !ready && err == KErrNone);

		lex.SkipSpace();

	}

	return err;

}

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

// CSecuritySetting::AddSecurityAttributes()

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

//

TInt CSecuritySetting::AddSecurityAttributes( const TDesC& aType, const TDesC& aValue)

{

	using namespace IniConstants;

	TInt err = KErrGeneral;

	if (  KWriteAccessCapString == aType )

	{

		TUint8 cap;

		if ( ConvertStrToCap( aValue, cap, iDefaultTypeWr) != KErrNone )

		{

			return KErrGeneral;

		}

		err = AddWriteCap( cap );

	}

	else if ( KReadAccessCapString == aType )

	{

		TUint8 cap;

		if ( ConvertStrToCap( aValue, cap, iDefaultTypeRd) != KErrNone )

		{

			return KErrGeneral;

		}

		err = AddReadCap( cap );

	}

	else if ( KReadAccessSidString == aType)

	{

		if ( !iSidExistRd )		

		{

			if ( KErrNone == ConvertStrToSid( aValue, iSidRd))

			{

				iSidExistRd = ETrue;

				err = KErrNone;

			}

		}		

	}

	else if ( KWriteAccessSidString == aType)

	{

		if ( !iSidExistWr )		

		{

			if ( KErrNone == ConvertStrToSid( aValue, iSidWr))

			{

				iSidExistWr = ETrue;

				err = KErrNone;

			}

		}

	}

	return err;	

}

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

// CSecuritySetting::ConvertStrToCab()

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

//

TInt CSecuritySetting::ConvertStrToSid( const TDesC& aStr, TUid& aValue)

{

	TLex lex( aStr);

	TRadix radix = EDecimal;

	if( lex.Peek()=='0')

	{

		lex.Inc();

		if( lex.Peek().GetLowerCase()=='x')

		{

			lex.Inc();

			radix = EHex;

		}

		else

		{

			lex.UnGet();

		}

	}

	TUint32 value;

	TInt err = lex.Val( value, radix);

	aValue.iUid = value;

	return err;

}

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

// CSecuritySetting::ConvertStrToCab()

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

//

TInt CSecuritySetting::ConvertStrToCap( const TDesC& aCab, TUint8& aCapValue, KDefaultType& aType)

{

	TBuf8<40> cap;

	cap.Append( aCab);

	cap.LowerCase();

	if ( cap.CompareF( IniConstants::KAccessAlwaysPass ) == 0)

	{

		aType = EAlwaysPass;

		aCapValue = TUint8(ECapability_None);

		return KErrNone;

	}

	if ( cap.CompareF( IniConstants::KAccessAlwaysFail ) == 0)

	{

		aType = EAlwaysFail;

		aCapValue = TUint8(ECapability_None);

		return KErrNone;

	}

	for ( TInt i(0); i < ECapability_Limit;  i++)	

	{

		TPtrC8 ptr((const TUint8 *) CapabilityNames[i]);

		TBool compareResult = ETrue;

		for ( TInt j(0); j < ptr.Length(); j++)

		{

			TChar ptrChar( ptr[j]);

			TChar aCabChar( aCab[j]);

			ptrChar.LowerCase();

			aCabChar.LowerCase();

			if ( ptrChar != aCabChar )

			{

				compareResult = EFalse;

				break;

			}

		}

		if ( compareResult )

		{

			aCapValue = i;

			return KErrNone;

		}

	}

	return KErrNotFound;

}