--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/rtsecuritymanager/rtsecuritymanagerserver/src/rtsecmgrpolicyparser.cpp Mon Mar 30 12:51:20 2009 +0300
@@ -0,0 +1,1158 @@
+/*
+* 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,
+ TUserPromptOption aDefUpOpt)
+ {
+ if ( aParentNode->HasChildNodes ())
+ {
+ CMDXMLNode* childNode = aParentNode->FirstChild ();
+
+ do
+ {
+ if ( childNode)
+ {
+ CMDXMLNode* capabilitiesNode= NULL;
+ if ( 0==childNode->NodeName().CompareF (KCapabilities))
+ {
+ capabilitiesNode = dynamic_cast<CMDXMLElement*>(childNode);
+
+ //traverse <capability/> nodes under <capabilities/>
+ if ( capabilitiesNode->HasChildNodes ())
+ {
+ RCapabilityArray capabilities;
+
+ for (CMDXMLNode
+ * capabilityNode=capabilitiesNode->FirstChild (); capabilityNode;capabilityNode=capabilityNode->NextSibling ())
+ {
+ //Get the textnode under <capability/>
+ if ( capabilityNode)
+ {
+ for (CMDXMLNode
+ * capChildNode=capabilityNode->FirstChild (); capChildNode;capChildNode=capChildNode->NextSibling ())
+ {
+ //Get the textnode under <capability/>
+ if ( CMDXMLNode::ETextNode==capChildNode->NodeType ())
+ {
+ CMDXMLText
+ * capTextNode = dynamic_cast<CMDXMLText*>(capChildNode);
+ //Extract text out of this node
+ TCapability
+ cap = GetCapability (capTextNode->Data ());
+
+ if ((ECapability_None!=cap))
+ {
+
+ // Get LOGIC for the storage of Group capability
+
+ if ( aUGCaps)
+ {
+ if ( (!IsPresent(aCapInfo,cap)) && (!IsUserGrantPresent(aCapInfo,cap)))
+ {
+ capabilities.Append(cap);
+
+ if ( RTUserPrompt_UnDefined==aUpOpt)
+ {
+ CPermission* perm = CPermission::NewL(capabilities, aDefUpOpt,aDefUpOpt);
+ aCapInfo.AppendPermission (*perm);
+ }
+
+ else
+ {
+ CPermission* perm = CPermission::NewL(capabilities, aDefUpOpt,aUpOpt);
+ aCapInfo.AppendPermission (*perm);
+ }
+ }
+ else
+ {
+ return EErrRepeatedCaps;
+ }
+ }
+ else
+ {
+ //Check before appending unconditional capability that
+ //whether the capability is already added or not...
+ if ( (!IsPresent(aCapInfo,cap)) && (!IsUserGrantPresent(aCapInfo,cap)))
+ {
+ aCapInfo.AppendUncondCap (cap);
+ }
+ else
+ {
+ //capability string given more than once.. hence invalid
+ return EErrRepeatedCaps;
+ }
+ }
+ }
+ else
+ {
+ TBool invalidCaps = ETrue;
+
+ for(TInt idx = 0; idx < iAliasGroup.Count(); idx++)
+ {
+ CPermission *tempObj = iAliasGroup[idx];
+ TPtrC name = tempObj->PermName();
+
+ if ((KErrNone == capTextNode->Data().CompareF(name)))
+ {
+ //it is not a text node. so is an alias group
+
+ //alias group name is found. so obtain the caps
+ TUint32 capAlias = tempObj->PermissionData();
+ invalidCaps = EFalse;
+ if( aUGCaps)
+ {
+ for(TInt idx1 = 0; idx1 < 20; idx1++)
+ {
+ TUint32 tempCapToCheck(KDefaultEnableBit);
+ tempCapToCheck = tempCapToCheck << (idx1);
+
+ if(capAlias & tempCapToCheck)
+ capabilities.Append((TCapability)idx1);
+
+ }
+ if ( RTUserPrompt_UnDefined==aUpOpt)
+ {
+ CPermission* perm = CPermission::NewL(capabilities, aDefUpOpt,aDefUpOpt);
+ perm->SetPermName(name);
+ aCapInfo.AppendPermission (*perm);
+ }
+
+ else
+ {
+ CPermission* perm = CPermission::NewL(capabilities, aDefUpOpt,aUpOpt);
+ perm->SetPermName(name);
+ aCapInfo.AppendPermission (*perm);
+ }
+ }
+ else
+ {
+ TUint32 capPresent = aCapInfo.UnconditionalCaps();
+ TUint32 capAfter = capAlias | capPresent;
+ TUint32 capRep = capAlias ^ capPresent;
+ TUint32 errChk = capRep & capAfter; //error if capAfter and error are different
+
+ if(!(errChk & capAfter))
+ {
+ //capability string given more than once.. hence invalid
+ return EErrRepeatedCaps;
+ }
+
+ aCapInfo.AppendUncondCapabilities(capAfter);
+ }
+ }
+ }
+
+ if (invalidCaps)
+ {
+ //just log the error message
+ RDebug::Print (_L ("CPolicyParser::GetCapabilities : Invalid capability string"));
+ return EErrInvalidCapability;
+ }
+ }
+
+ }
+ }
+ }
+ capabilities.Close();
+ }
+ }
+ else
+ {
+ RDebug::Print (_L ("CPolicyParser::GetCapabilities : No <capability> under <capabilities/>"));
+ }
+
+ }
+
+ childNode = childNode->NextSibling ();
+ }
+ else
+ {
+ RDebug::Print (_L ("CPolicyParser::GetCapabilities : Childnode NULL"));
+ }
+ }
+ while (NULL != childNode);
+ }
+
+ return EErrNone;
+ }
+
+TInt CPolicyParser::GetCapabilitiesForGroup(CMDXMLElement* aParentNode,
+ CPermissionSet& aCapInfo, CPermission& aAliasInfo, TUserPromptOption aUpOpt, TBool aUGCaps,
+ TUserPromptOption aDefUpOpt)
+ {
+ if ( aParentNode->HasChildNodes ())
+ {
+ CMDXMLNode* childNode = aParentNode->FirstChild ();
+
+ do
+ {
+ if ( childNode)
+ {
+ CMDXMLNode* capabilitiesNode= NULL;
+ if ( 0==childNode->NodeName().CompareF (KCapabilities))
+ {
+ capabilitiesNode = dynamic_cast<CMDXMLElement*>(childNode);
+
+ //traverse <capability/> nodes under <capabilities/>
+ if ( capabilitiesNode->HasChildNodes ())
+ {
+ RCapabilityArray capabilities;
+
+ for (CMDXMLNode
+ * capabilityNode=capabilitiesNode->FirstChild (); capabilityNode;capabilityNode=capabilityNode->NextSibling ())
+ {
+ //Get the textnode under <capability/>
+ if ( capabilityNode)
+ {
+ for (CMDXMLNode
+ * capChildNode=capabilityNode->FirstChild (); capChildNode;capChildNode=capChildNode->NextSibling ())
+ {
+ //Get the textnode under <capability/>
+ if ( CMDXMLNode::ETextNode==capChildNode->NodeType ())
+ {
+ CMDXMLText
+ * capTextNode = dynamic_cast<CMDXMLText*>(capChildNode);
+ //Extract text out of this node
+ TCapability
+ cap = GetCapability (capTextNode->Data ());
+
+
+ if ((ECapability_None!=cap))
+ {
+
+ // Get LOGIC for the storage of Group capability
+
+ if ( aUGCaps)
+ {
+ //For ALIAS GROUP this condition is not true and foll stm are not executed
+ if ( (!IsPresent(aCapInfo,cap)) && (!IsUserGrantPresent(aCapInfo,cap)))
+ {
+ capabilities.Append(cap);
+
+ if ( RTUserPrompt_UnDefined==aUpOpt)
+ {
+ CPermission* perm = CPermission::NewL(capabilities, aDefUpOpt,aDefUpOpt);
+
+ aCapInfo.AppendPermission (*perm);
+ }
+
+ else
+ {
+ CPermission* perm = CPermission::NewL(capabilities, aDefUpOpt,aUpOpt);
+
+ aCapInfo.AppendPermission (*perm);
+ }
+ }
+ else
+ {
+ return EErrRepeatedCaps;
+ }
+ }
+ else
+ {
+ //Check before appending unconditional capability that
+ //whether the capability is already added or not...
+ if ( (!IsPresent(aCapInfo,cap) && (!IsUserGrantPresent(aCapInfo,cap))) && (!IsCapsAliasPresent(aAliasInfo,cap)))
+ {
+ aCapInfo.AppendUncondCap (cap);
+ aAliasInfo.AppendCapPermData(cap);
+ }
+ else
+ {
+ //capability string given more than once.. hence invalid
+ return EErrRepeatedCaps;
+ }
+ }
+ }
+ else
+ {
+ TBool invalidCaps = ETrue;
+ for(TInt idx = 0; idx < iAliasGroup.Count(); idx++)
+ {
+ CPermission *tempObj = iAliasGroup[idx];
+ TPtrC name = tempObj->PermName();
+
+ if ((KErrNone == capTextNode->Data().CompareF(name)))
+ {
+ invalidCaps = EFalse;
+ //it is not a text node. so is an alias group
+
+ //alias group name is found. so obtain the caps
+ TUint32 capAlias = tempObj->PermissionData();
+ TUint32 capPresent = aCapInfo.UnconditionalCaps();
+ TUint32 capAfter = capAlias | capPresent;
+ TUint32 capRep = capAlias ^ capPresent;
+ TUint32 errChk = capRep & capAfter; //error if capAfter and error are different
+
+ if(!(errChk & capAfter))
+ {
+ //capability string given more than once.. hence invalid
+ return EErrRepeatedCaps;
+ }
+
+ aCapInfo.AppendUncondCapabilities(capAfter);
+ aAliasInfo.SetPermissionData(capAfter);
+ }
+ }
+
+ if (invalidCaps)
+ {
+ //just log the error message
+ RDebug::Print (_L ("CPolicyParser::GetCapabilities : Invalid capability string"));
+ return EErrInvalidCapability;
+ }
+ }
+
+ }
+ }
+ }
+
+
+ capabilities.Close();
+ }
+ }
+ else
+ {
+ RDebug::Print (_L ("CPolicyParser::GetCapabilities : No <capability> under <capabilities/>"));
+ }
+
+ }
+
+ childNode = childNode->NextSibling ();
+ }
+ else
+ {
+ RDebug::Print (_L ("CPolicyParser::GetCapabilities : Childnode NULL"));
+ }
+
+ }
+ while (NULL != childNode);
+ }
+
+ return EErrNone;
+ }
+
+TInt CPolicyParser::GetConditions(CMDXMLElement* aParentNode, TUserPromptOption& aUserPromptOpt)
+ {
+ TUint32 ret(RTUserPrompt_UnDefined);
+
+ if ( aParentNode->HasChildNodes ())
+ {
+ CMDXMLNode* childNode = aParentNode->FirstChild ();
+
+ do
+ {
+ if ( childNode)
+ {
+ CMDXMLNode* condNode= NULL;
+ if ( 0==childNode->NodeName().CompareF (KCondition))
+ {
+ condNode = dynamic_cast<CMDXMLElement*>(childNode);
+
+ if ( condNode->HasChildNodes ())
+ {
+ for (CMDXMLNode* condChildNode=condNode->FirstChild (); condChildNode;condChildNode=condChildNode->NextSibling ())
+ {
+ //Get the textnode under <condition/>
+ if ( CMDXMLNode::ETextNode==condChildNode->NodeType ())
+ {
+ CMDXMLText
+ * condition = dynamic_cast<CMDXMLText*>(condChildNode);
+
+ if ( condition)
+ {
+ TInt32 returnVal = GetUserPromptOption (condition->Data ());
+
+ if(RTUserPrompt_UnDefined == returnVal)
+ {
+ aUserPromptOpt = (TUserPromptOption)returnVal;
+ return EErrInvalidPermission;
+ }
+
+ ret |= returnVal;
+ }
+ }
+ }
+ }
+ }
+ childNode = childNode->NextSibling ();
+ }
+
+ }
+ while (NULL != childNode);
+ }
+
+ aUserPromptOpt = (TUserPromptOption)ret;
+ return EErrNone;
+ }
+
+TBool CPolicyParser::isDomainPresent(const TDesC& aDomainName)
+ {
+ TBool isPresent(EFalse);
+
+ for (TInt i(0); i!=iPolicyInfo.Count ();++i)
+ {
+ if ( 0==iPolicyInfo[i]->DomainName().CompareF (aDomainName))
+ {
+ isPresent=ETrue;
+ break;
+ }
+ }
+
+ return isPresent;
+ }
+
+TBool CPolicyParser::IsPresent(const CPermissionSet& aCapInfo, TCapability aCap)
+ {
+ TUint32 uncondCaps = aCapInfo.UnconditionalCaps ();
+
+ TUint32 tempCapToCheck(KDefaultEnableBit);
+ tempCapToCheck = tempCapToCheck << (aCap);
+
+ return (uncondCaps & tempCapToCheck);
+ }
+
+TBool CPolicyParser::IsCapsAliasPresent(const CPermission& aAliasInfo, TCapability aCap)
+ {
+ TUint32 uncondCaps = aAliasInfo.PermissionData ();
+
+ TUint32 tempCapToCheck(KDefaultEnableBit);
+ tempCapToCheck = tempCapToCheck << (aCap);
+
+ return (uncondCaps & tempCapToCheck);
+ }
+
+TBool CPolicyParser::IsUserGrantPresent(const CPermissionSet& aCapInfo,
+ TCapability aCap)
+ {
+ TUint32 perms(KDefaultNullBit);
+ //RPermissions tempPerms = aCapInfo.Permissions();
+ for (TInt i(0); i!=(aCapInfo.Permissions()).Count ();++i)
+ {
+ TUint32 temp(KDefaultEnableBit);
+ RCapabilityArray capabilities;
+ (aCapInfo.Permissions())[i]->Capabilitilites(capabilities);
+ for(TInt capIdx(0);capIdx!=capabilities.Count();++capIdx)
+ {
+ temp = temp << (capabilities[capIdx]);
+ perms |= temp;
+ }
+ capabilities.Close();
+ }
+
+ TUint32 temp(KDefaultEnableBit);
+ temp = temp << (aCap);
+ return (perms & temp);
+ }
+
+TUserPromptOption CPolicyParser::GetDefaultCondition(CMDXMLElement* aParentNode)
+ {
+ if ( aParentNode->HasChildNodes ())
+ {
+ CMDXMLNode* childNode = aParentNode->FirstChild ();
+
+ do
+ {
+ if ( childNode)
+ {
+ CMDXMLNode* condNode= NULL;
+ if ( 0==childNode->NodeName().CompareF (KDefCondition))
+ {
+ condNode = dynamic_cast<CMDXMLElement*>(childNode);
+
+ if ( condNode->HasChildNodes ())
+ {
+ for (CMDXMLNode* condChildNode=condNode->FirstChild (); condChildNode;condChildNode=condChildNode->NextSibling ())
+ {
+ if ( CMDXMLNode::ETextNode==condChildNode->NodeType ())
+ {
+ CMDXMLText
+ * condition = dynamic_cast<CMDXMLText*>(condChildNode);
+
+ if ( condition)
+ {
+ return GetUserPromptOption (condition->Data ());
+ }
+ }
+ }
+ }
+ }
+
+ childNode = childNode->NextSibling ();
+ }
+
+ }
+ while (NULL != childNode);
+ }
+
+ return RTUserPrompt_UnDefined;
+ }
+
+TCapability CPolicyParser::GetCapability(const TDesC& aUserPromptOpt)
+ {
+ TCapability cap(ECapability_None);
+
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityTCB))
+ {
+ cap=ECapabilityTCB;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityCommDD))
+ {
+ cap=ECapabilityCommDD;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityPowerMgmt))
+ {
+ cap=ECapabilityPowerMgmt;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityMultimediaDD))
+ {
+ cap=ECapabilityMultimediaDD;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityReadDeviceData))
+ {
+ cap=ECapabilityReadDeviceData;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityWriteDeviceData))
+ {
+ cap=ECapabilityWriteDeviceData;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityDRM))
+ {
+ cap=ECapabilityDRM;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityTrustedUI))
+ {
+ cap=ECapabilityTrustedUI;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityProtServ))
+ {
+ cap=ECapabilityProtServ;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityDiskAdmin))
+ {
+ cap=ECapabilityDiskAdmin;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityNetworkControl))
+ {
+ cap=ECapabilityNetworkControl;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityAllFiles))
+ {
+ cap=ECapabilityAllFiles;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilitySwEvent))
+ {
+ cap=ECapabilitySwEvent;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityNetworkServices))
+ {
+ cap=ECapabilityNetworkServices;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityLocalServices))
+ {
+ cap=ECapabilityLocalServices;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityReadUserData))
+ {
+ cap=ECapabilityReadUserData;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityWriteUserData))
+ {
+ cap=ECapabilityWriteUserData;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityLocation))
+ {
+ cap=ECapabilityLocation;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilitySurroundingsDD))
+ {
+ cap=ECapabilitySurroundingsDD;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KCapabilityUserEnvironment))
+ {
+ cap=ECapabilityUserEnvironment;
+ }
+ return cap;
+ }
+
+TUserPromptOption CPolicyParser::GetUserPromptOption(const TDesC& aUserPromptOpt)
+ {
+ TUserPromptOption userPromptOpt = RTUserPrompt_UnDefined;
+
+ if ( 0==aUserPromptOpt.CompareF (KUserPromptOneShot))
+ {
+ userPromptOpt=RTUserPrompt_OneShot;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KUserPromptSession))
+ {
+ userPromptOpt=RTUserPrompt_Session;
+ }
+ else
+ if ( 0==aUserPromptOpt.CompareF (KUserPromptBlanket))
+ {
+ userPromptOpt=RTUserPrompt_Permanent;
+ }
+ return userPromptOpt;
+ }
+
+TBool CPolicyParser::isAliasPresent(const TDesC& aAliasName)
+ {
+ TBool isPresent(EFalse);
+
+ for(TInt idx = 0; idx < iAliasGroup.Count(); idx++)
+ {
+ if( KErrNone == iAliasGroup[idx]->PermName().CompareF(aAliasName))
+ {
+ isPresent = ETrue;
+ break;
+ }
+
+ }
+
+ return isPresent;
+ }