/*

* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:       Utility XML parser to parse trust and access policy files

 *

*/

#include <e32std.h>

#include <w32std.h>

#include <f32file.h>

#include "rtsecmgrpolicyparser.h"

#include "rtsecmgrdata.h"

#include "rtsecmgrserverdef.h"

#include <gmxmldocument.h>

#include <gmxmlelement.h>

#include <gmxmlcharacterdata.h>

#include <gmxmltext.h>

#include <gmxmlnode.h>

_LIT (KPolicy, "policy");

_LIT (KAllow, "allow");

_LIT (KUser, "user");

_LIT (KDomain, "domain");

_LIT (KNameAttr, "name");

_LIT (KCondition, "condition");

_LIT (KCapabilities, "capabilities");

_LIT (KDefCondition, "defaultCondition");

_LIT (KText, "#TEXT");

_LIT (KComment, "comment");

_LIT (KAlias, "alias");

CPolicyParser::CPolicyParser()

	{

	}

CPolicyParser* CPolicyParser::NewL()

	{

	CPolicyParser* self = CPolicyParser::NewLC ();

	//nothing to construct as of now

	CleanupStack::Pop (self);

	return self;

	}

CPolicyParser* CPolicyParser::NewLC()

	{

	CPolicyParser* self = new (ELeave) CPolicyParser();

	CleanupStack::PushL (self);

	//nothing to construct as of now

	return self;

	}

CPolicyParser::~CPolicyParser()

	{

	if ( iDomParser)

		{

		delete iDomParser;

		iDomParser = NULL;

		}

	}

TInt CPolicyParser::GetPolicyInfo(RFile& aSecPolicy,

		RProtectionDomains& aPolicyInfo, RAliasGroup& aAliasGroup)

	{

	isTrustInfo = EFalse;

	if ( iDomParser)

		{

		delete iDomParser;

		iDomParser = NULL;

		}

	iDomParser = CMDXMLParser::NewL (this);

	iLastError = KErrNone;

	RFile parseHandle;

	User::LeaveIfError ( parseHandle.Duplicate ( aSecPolicy));

	iPolicyInfo.Reset (); //cleans-up the array, but doesn't delete the entries..

	iAliasGroup.Reset ();

	iLastError = iDomParser->ParseFile (parseHandle); //xml file read operation

	if ( KErrNone == iLastError)

		iWaitScheduler.Start (); //actual parsing starts here asynchronously

	if ( KErrNone==iLastError)   //parsing is successful

	{

		aPolicyInfo = iPolicyInfo;

		aAliasGroup = iAliasGroup;

	}

	return iLastError;

	}

// Call back function called when a parsing operation completes.

void CPolicyParser::ParseFileCompleteL()

	{

	iLastError = iDomParser->Error();

	if(iLastError == KErrXMLMissingDocTypeTag)

	    iLastError = KErrNone;

	iWaitScheduler.AsyncStop ();

	if(iLastError!=KErrNone)

		{

		    return;

		}

	else

	    {

          	if ( iDomParser && !isTrustInfo) //pre-requisite that the DOM instance is intact

        		{

        		CMDXMLDocument* documentNode = iDomParser->DetachXMLDoc ();

        		if ( documentNode)

        			{

        			CleanupStack::PushL(documentNode);

        			//Gets the root element of the DOM tree.

        			CMDXMLElement* rootElemNode = documentNode->DocumentElement ();

        			CMDXMLNode* rootNode = rootElemNode->FirstChild ();

        			if ( !rootNode)

        				{

        				iLastError = EErrInvalidRootNode;

        				CleanupStack::PopAndDestroy(documentNode);

        				return;

        				}

        			TBool isValid = EFalse;

        			for (; rootNode;rootNode=rootNode->NextSibling ())

        				{

        				if ( rootNode->NodeType ()==CMDXMLNode::EElementNode)

        					{

        					if ( 0==rootNode->NodeName().CompareF (KPolicy ()))

        						{

        						isValid = ETrue;

        						break;

        						}

        					else

        						continue;

        					}

        				else

        					{

        					 if(KErrNone == rootNode->NodeName().CompareF(KText))

        						{

        						iLastError = EErrJunkContent;

        						iPolicyInfo.ResetAndDestroy ();

        						iAliasGroup.ResetAndDestroy ();

        						CleanupStack::PopAndDestroy(documentNode);

        						return;										

        						}

        					}

        				}

        			if ( !isValid)

        				{

        				iLastError = EErrInvalidRootNode;

        				iPolicyInfo.ResetAndDestroy ();

        				iAliasGroup.ResetAndDestroy ();

        				CleanupStack::PopAndDestroy(documentNode);

        				return;

        				}

        			TPtrC attrVal;

        			if ( rootNode->HasChildNodes ())

        				{

        				CMDXMLNode* childNode = rootNode->FirstChild ();

        				//Now get the list of <alias> nodes

        				while ( childNode)

        					{

        					TPtrC nodeName = childNode->NodeName ();

        					//ALIAS PARSING

        					if ( nodeName.CompareF (KAlias)== 0)

        						{

        						CMDXMLElement

        								* aliasNode = dynamic_cast<CMDXMLElement*>(childNode);

        						//store alias information in object

        						CPermission* aliasObj = NULL;

        							{//Get the attribute "name" to get the alias name		    								    		

        							aliasNode->GetAttribute(KNameAttr, attrVal);

        							if ( attrVal.Length ()>0)

        								{

        									if ( isAliasPresent (attrVal))

        									{

        									//invalid xml file

        									if(aliasObj)

        										delete aliasObj;

        									iPolicyInfo.ResetAndDestroy ();

        									iAliasGroup.ResetAndDestroy ();

        									iLastError = EErrRepeatedAliasTag;

        									CleanupStack::PopAndDestroy(documentNode);

        									return;

        									}

        									aliasObj = CPermission::NewL();

        									aliasObj->SetPermName(attrVal);

        								}

        							else

        								{

        								//alias name is invalid

        								//check whether TPerm / alias name should be deleted

        								if(aliasObj)

        									delete aliasObj;

        								iPolicyInfo.ResetAndDestroy ();

        								iAliasGroup.ResetAndDestroy ();

        								iLastError = EErrInvalidAliasName;

        								CleanupStack::PopAndDestroy(documentNode);

        								return;

        								}

        							if ( aliasNode->HasChildNodes ())

        								{

        									CPermissionSet *aliasCaps = CPermissionSet::NewL();

        									TBool result = GetCapabilitiesForGroup(

        														(CMDXMLElement*)aliasNode,

        														*aliasCaps, *aliasObj); //get list of uncond caps

        									if(result < 0)

        									{

        										//Invalid capability string in policy file

        										if(aliasObj)

        											delete aliasObj;

        										if(aliasCaps)

        											delete aliasCaps;

        										iPolicyInfo.ResetAndDestroy ();

        										iAliasGroup.ResetAndDestroy ();

        										iLastError = result;  //EErrInvalidCapability or EErrRepeatedCaps

        										CleanupStack::PopAndDestroy(documentNode);

        										return;

        									}

        									if(aliasCaps)

        										delete aliasCaps;

        								}

        							}

        							if(aliasObj)

        								iAliasGroup.AppendL(aliasObj); 

        						}

        					//check if the domain name is already present..

        					//need to check to avoid repeated domain tags..

        					if ( nodeName.CompareF (KDomain)== 0)

        						{

        						CMDXMLElement

        								* domainNode = dynamic_cast<CMDXMLElement*>(childNode);

        						CProtectionDomain* pPolicy=  NULL;

        							{//Get the attribute "name" to get the domain name		    								    		

        							domainNode->GetAttribute (KNameAttr, attrVal);

        							if ( attrVal.Length ()>0)

        								{

        								if ( isDomainPresent (attrVal))

        									{

        									//invalid xml file

        									//delete pPolicy;

        									iPolicyInfo.ResetAndDestroy ();

        									iAliasGroup.ResetAndDestroy ();

        									iLastError = EErrRepeatedDomainTag;

        									CleanupStack::PopAndDestroy(documentNode);

        									return;

        									}

        								pPolicy = CProtectionDomain::NewL ();

        								pPolicy->SetDomainName (attrVal);

        								}

        							else

        								{

        								//domain name is invalid

        								if ( pPolicy)

        									delete pPolicy;

        								iPolicyInfo.ResetAndDestroy ();

        								iAliasGroup.ResetAndDestroy ();

        								iLastError = EErrInvalidDomainName;

        								CleanupStack::PopAndDestroy(documentNode);

        								return;

        								}

        							if ( domainNode->HasChildNodes ())

        								{

        								CPermissionSet* caps = CPermissionSet::NewL ();

        								CMDXMLNode

        										* domainChildNode = domainNode->FirstChild ();

        								for (; domainChildNode;domainChildNode=domainChildNode->NextSibling ())

        									{

        									if ( domainChildNode->NodeType ()==CMDXMLNode::EElementNode)

        										{

        										if ( 0==domainChildNode->NodeName().CompareF (KAllow))//<Allow> unconditional node

        											{

        												TBool result = GetCapabilities(

        														(CMDXMLElement*)domainChildNode,

        														*caps); //get list of uncond caps

        												if(result < 0)

        												{

        													//Invalid capability string in policy file

        													if ( pPolicy)

        														delete pPolicy;

        													if(caps)

        														delete caps;

        													iPolicyInfo.ResetAndDestroy ();

        													iAliasGroup.ResetAndDestroy ();

        													iLastError = result;  //EErrInvalidCapability or EErrRepeatedCaps

        													CleanupStack::PopAndDestroy(documentNode);

        													return;

        												}

        											}	

        										else if ( 0==domainChildNode->NodeName().CompareF (KUser))//<User> Conditional node

        											{

        												//Get UGCaps

        												TUserPromptOption upOption(RTUserPrompt_UnDefined);

        												TInt error = GetConditions ((CMDXMLElement*)domainChildNode, upOption);//Get conditions

        												if(EErrInvalidPermission == error)

        												{

        													// invalid permission is specified

        													if ( pPolicy)

        														delete pPolicy;

        													if(caps)

        														delete caps;

        													iLastError = EErrInvalidPermission;

        													iPolicyInfo.ResetAndDestroy ();

        													iAliasGroup.ResetAndDestroy ();

        													CleanupStack::PopAndDestroy(documentNode);

        													return;

        												}

        												TUserPromptOption

        														defCond = GetDefaultCondition ((CMDXMLElement*)domainChildNode);

        												if(RTUserPrompt_UnDefined == defCond)

        													{

        													//default condition is not specified

        													if ( pPolicy)

        														delete pPolicy;

        													if(caps)

        														delete caps;

        													iLastError = EErrNoDefaultCondition;

        													iPolicyInfo.ResetAndDestroy ();

        													iAliasGroup.ResetAndDestroy ();

        													CleanupStack::PopAndDestroy(documentNode);

        													return;

        													}

        												//default condition is specified

        												error = GetCapabilities (

        															(CMDXMLElement*)domainChildNode,

        															*caps,

        															upOption,

        															ETrue, defCond); //get list of ug caps	

        												if(error < 0)

        												{

        													//Invalid capability string in policy file

        													if ( pPolicy)

        														delete pPolicy;

        													if(caps)

        														delete caps;

        													iPolicyInfo.ResetAndDestroy ();

        													iAliasGroup.ResetAndDestroy ();

        													iLastError = error;  //EErrInvalidCapability or EErrRepeatedCaps

        													CleanupStack::PopAndDestroy(documentNode);

        													return;

        												}

        											}

        											else  	// neither USER nor ALLOW node

        											{

        												//checking for misplaced alias tag

        												if((KErrNone == domainChildNode->NodeName().CompareF(KAlias)))

        												{

        													if ( pPolicy)

        														delete pPolicy;

        													if(caps)

        														delete caps;

        													iLastError = EErrMisplacedAlias;

        													iAliasGroup.ResetAndDestroy ();

        													iPolicyInfo.ResetAndDestroy ();

        													CleanupStack::PopAndDestroy(documentNode);

        													return;										

        												}

        											}

        										}

        										else

        										{

        											//the node is not an element node

        											//hence it should be comment / junk content

        											if((KErrNone == domainChildNode->NodeName().CompareF(KText)))

        											{

        												if ( pPolicy)

        													delete pPolicy;

        												if (caps)

        													delete caps;

        												iLastError = EErrJunkContent;

        												iPolicyInfo.ResetAndDestroy ();

        												iAliasGroup.ResetAndDestroy ();

        												CleanupStack::PopAndDestroy(documentNode);

        												return;										

        											}

        											else if(KErrNone == domainChildNode->NodeName().CompareF(KComment))

        												continue;

        										}

        									}									

        								if ( pPolicy)

        									pPolicy->SetCapInfo (caps);

        								}

        							}

        						if ( pPolicy)

        							iPolicyInfo.AppendL (pPolicy);

        						}

        						else if((KErrNone == nodeName.CompareF(KText)))

        						{

        							iLastError = EErrJunkContent;

        							iPolicyInfo.ResetAndDestroy ();

        							iAliasGroup.ResetAndDestroy ();

        							CleanupStack::PopAndDestroy(documentNode);

        							return;										

        						}

        					childNode = childNode->NextSibling (); //traverse to the next sibling node			    			

        					}

        				} //rootNode->HasChildNodes()

        			else

        				{

        				//No policy information in the xml file

        				//Treat this as an error

        				iLastError = EErrNoPolicyInfo;

        				iPolicyInfo.ResetAndDestroy ();

        				iAliasGroup.ResetAndDestroy ();

        				CleanupStack::PopAndDestroy(documentNode);

        				return;

        				}

        			CleanupStack::PopAndDestroy(documentNode);

        			}

        		else

        			{

        			iLastError = EErrInvalidDocNode;

        			return;

        			}

        		}

	    }

	}

TInt CPolicyParser::GetCapsNode(CMDXMLElement* aParentDomainNode,

		RPointerArray<CMDXMLElement>& aCapNodes, const TDesC& aNodeName)

	{

	if ( aParentDomainNode->HasChildNodes ())

		{

		CMDXMLNode* childNode = aParentDomainNode->FirstChild ();

		do

			{

			if ( childNode)

				{

				if ( 0==childNode->NodeName().Compare (aNodeName))

					{

					CMDXMLElement* pAllowNode = dynamic_cast<CMDXMLElement*>(childNode);

					aCapNodes.AppendL (pAllowNode);

					}

				childNode = childNode->NextSibling ();

				}

			}

		while (NULL != childNode);

		}

	return EErrNone; //No other possible return err code...

	}

CMDXMLElement* CPolicyParser::GetCapsNode(CMDXMLElement* aParentDomainNode,

		const TDesC& aNodeName)

	{

	if ( aParentDomainNode->HasChildNodes ())

		{

		CMDXMLNode* childNode = aParentDomainNode->FirstChild ();

		do

			{

			if ( childNode)

				{

				if ( 0==childNode->NodeName().Compare (aNodeName))

					{

					CMDXMLElement* pAllowNode = dynamic_cast<CMDXMLElement*>(childNode);

					return pAllowNode;

					}

				childNode = childNode->NextSibling ();

				}

			}

		while (NULL != childNode);

		}

	return NULL;

	}

TInt CPolicyParser::GetCapabilities(CMDXMLElement* aParentNode,

		CPermissionSet& aCapInfo, TUserPromptOption aUpOpt, TBool aUGCaps,