/*
* Copyright (c) 2005 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:  source file for dm acl parser
*
*/

#include "nsmldmaclparser.h"


// ===============================================================================================
// class CNSmlDmACLParser
// ===============================================================================================


// ---------------------------------------------------------------------------
// TInt CNSmlDmACLParser::NewLC()
// Returns pointer to newly created CNSmlDmACLParser instance
// ---------------------------------------------------------------------------
CNSmlDmACLParser* CNSmlDmACLParser::NewLC()
	{
	CNSmlDmACLParser* self = new (ELeave) CNSmlDmACLParser();
	CleanupStack::PushL( self );
	return self;
	}


// ---------------------------------------------------------------------------
// CNSmlDmACLParser::~CNSmlDmACLParser()
// Destructor
// ---------------------------------------------------------------------------
CNSmlDmACLParser::~CNSmlDmACLParser()
	{
	Reset();
	}

// ---------------------------------------------------------------------------
// CNSmlDmACLParser::ParseL()
// Parses ACL data and keeps data until Reset() is called or instance
// is destructed
// ---------------------------------------------------------------------------
TInt CNSmlDmACLParser::ParseL(const TDesC8& aACL)
	{
	Reset();
	for(TInt i=EAclExecute;i>=EAclAdd;i--)
		{
		TInt aclStart = 0;
		TBool found=EFalse;
		switch(i)
			{
			case EAclAdd:
				aclStart = aACL.Find(KNSmlDmAclAddEqual);
				found = aclStart>=0;
				aclStart=aclStart+KNSmlDmAclAddEqual().Length();
				break;
			case EAclReplace:
				aclStart = aACL.Find(KNSmlDmAclReplaceEqual);
				found = aclStart>=0;
				aclStart=aclStart+KNSmlDmAclReplaceEqual().Length();
				break;
			case EAclDelete:
				aclStart = aACL.Find(KNSmlDmAclDeleteEqual);
				found = aclStart>=0;
				aclStart=aclStart+KNSmlDmAclDeleteEqual().Length();
				break;
			case EAclGet:
				aclStart = aACL.Find(KNSmlDmAclGetEqual);
				found = aclStart>=0;
				aclStart=aclStart+KNSmlDmAclGetEqual().Length();
				break;
			case EAclExecute:
				aclStart = aACL.Find(KNSmlDmAclExecEqual);
				found = aclStart>=0;
				aclStart=aclStart+KNSmlDmAclExecEqual().Length();
				break;
			default:
				User::Panic(KSmlDmTreeDbHandlerPanic,KErrArgument);
				break;

			}
		if(found)
			{
			TInt aclStop = aACL.Right(aACL.Length()-aclStart).
				Locate(KNSmlDMAclCommandSeparator);

			if(aclStop<0)
				{
				aclStop = aACL.Length()-aclStart;
				}

			TPtrC8 commandAcl = aACL.Mid(aclStart,aclStop);

			CNSmlAclElement* aclElement = new(ELeave) CNSmlAclElement();

			aclElement->iCommandType = (TNSmlDmCmdType)i;
			aclElement->iNext = iCommandAcls;
			iCommandAcls=aclElement;

			if(commandAcl.Compare(KNSmlDmAclAll)==0)
				{
				aclElement->iAllServers=ETrue;
				}
			else
				{
				TBool end = EFalse;

				TInt serverIdStart=0;
				while(!end)
					{
					TPtrC8 serverIdPtr =
						commandAcl.Right(commandAcl.Length()-serverIdStart);
						
					TInt serverIdStop =
						serverIdPtr.Locate(KNSmlDMAclSeparator);
						
					if(serverIdStop == KErrNotFound)
						{
						serverIdStop=commandAcl.Length();
						end=ETrue;
						}
					HBufC8* serverId =
						serverIdPtr.Left(serverIdStop).AllocL();
						
					aclElement->iServerIds.AppendL(serverId);
					serverIdStart=serverIdStart+serverIdStop+1;
					}
				}
			}
		}
	return KErrNone;
	}

// ---------------------------------------------------------------------------
// CNSmlDmACLParser::GenerateL()
// Generates ACL data string from the kept data.
// ---------------------------------------------------------------------------
HBufC8* CNSmlDmACLParser::GenerateL()
	{
	CBufBase *acl = CBufFlat::NewL(32);
	CleanupStack::PushL(acl);

	CNSmlAclElement* aclElement=iCommandAcls;

	while(aclElement)
		{
		TBool anyServerIds=EFalse;
		if(aclElement->iAllServers||aclElement->iServerIds.Count())
			{
			anyServerIds = ETrue;
			switch(aclElement->iCommandType)
				{
				case EAclAdd:
					acl->InsertL(acl->Size(),KNSmlDmAclAddEqual);
					break;
				case EAclReplace:
					acl->InsertL(acl->Size(),KNSmlDmAclReplaceEqual);
					break;
				case EAclDelete:
					acl->InsertL(acl->Size(),KNSmlDmAclDeleteEqual);
					break;
				case EAclGet:
					acl->InsertL(acl->Size(),KNSmlDmAclGetEqual);
					break;
				case EAclExecute:
					acl->InsertL(acl->Size(),KNSmlDmAclExecEqual);
					break;
				default:
					User::Panic(KSmlDmTreeDbHandlerPanic,KErrArgument);
					break;
				}
			if(aclElement->iAllServers)
				{
				acl->InsertL(acl->Size(),KNSmlDmAclAll);
				}
			else
				{
				for(TInt i=0;i<aclElement->iServerIds.Count();i++)
					{
					acl->InsertL(acl->Size(),*aclElement->iServerIds[i]);
					if(i<aclElement->iServerIds.Count()-1)
						{
						acl->InsertL(acl->Size(),KNSmlDmAclServerIdSeparator);
						}
					}
				}
			}

		aclElement=aclElement->iNext;
		if(aclElement&&anyServerIds)
			{
			acl->InsertL(acl->Size(),KNSmlDmAclSeparator);
			}
		}
	
	HBufC8 *aclBuf = HBufC8::NewL(acl->Size());
	TPtr8 bufPtr = aclBuf->Des();
	acl->Read(0,bufPtr,acl->Size());
	CleanupStack::PopAndDestroy(); //acl
	return aclBuf;
	}

// ---------------------------------------------------------------------------
// CNSmlDmACLParser::RemoveAllReferences()
// Removes all references to aServerId
// ---------------------------------------------------------------------------
void CNSmlDmACLParser::RemoveAllReferences(const TDesC8& aServerId)
	{
	CNSmlAclElement* aclElement=iCommandAcls;


	while(aclElement)
		{
		for(TInt i=0;i<aclElement->iServerIds.Count();i++)
			{
			if(aclElement->iServerIds[i]->Compare(aServerId)==0)
				{
				delete aclElement->iServerIds[i];
				aclElement->iServerIds.Remove(i);
				break;
				}
			}
		aclElement=aclElement->iNext;
		}
	}

// ---------------------------------------------------------------------------
// CNSmlDmACLParser::ShouldDelete()
// Check if the instance contains any data to generate acl string.
// If not acl can be deleted
// ---------------------------------------------------------------------------
TBool CNSmlDmACLParser::ShouldDelete()
	{
	CNSmlAclElement* aclElement=iCommandAcls;

	while(aclElement)
		{
		if(aclElement->iAllServers||aclElement->iServerIds.Count())
			{
			return EFalse;
			}
		aclElement=aclElement->iNext;
		}
	return ETrue;	
	}

// ---------------------------------------------------------------------------
// CNSmlDmACLParser::HasRights()
// Check if the aServerId server has rights for command aCommand type
// ---------------------------------------------------------------------------
TBool CNSmlDmACLParser::HasRights(const TDesC8& aServerId,
	TNSmlDmCmdType aCommandType)
	{
	CNSmlAclElement* aclElement=iCommandAcls;
	TBool ret = EFalse;

	while(aclElement)
		{
		if(aclElement->iCommandType==aCommandType)
			{
			if(aclElement->iAllServers)
				{
				ret = ETrue;
				}
			else
				{
				for(TInt i=0;i<aclElement->iServerIds.Count();i++)
					{
					if(aclElement->iServerIds[i]->Compare(aServerId)==0)
						{
						ret = ETrue;
						break;
						}
					}
				}
			if(ret)
				{
				break;
				}
			}
		aclElement=aclElement->iNext;
		}
	return ret;	
	}

// ---------------------------------------------------------------------------
// CNSmlDmACLParser::Reset()
// Resets the instance data
// ---------------------------------------------------------------------------
 void CNSmlDmACLParser::Reset()
	{
	CNSmlAclElement* aclElement=iCommandAcls;

	while(iCommandAcls)
		{
		aclElement = iCommandAcls->iNext;
		delete iCommandAcls;
		iCommandAcls=aclElement;
		}
	}


// ===============================================================================================
// class CNSmlAclElement
// ===============================================================================================

// ---------------------------------------------------------------------------
// CNSmlAclElement::CNSmlAclElement()
// constructor
// ---------------------------------------------------------------------------
CNSmlAclElement::CNSmlAclElement()
	{
	}
	
// ---------------------------------------------------------------------------
// CNSmlAclElement::~CNSmlAclElement()
// destructor
// ---------------------------------------------------------------------------
CNSmlAclElement::~CNSmlAclElement()
	{
	iServerIds.ResetAndDestroy();
	}