diff -r 000000000000 -r 99ef825efeca rtsecuritymanager/rtsecuritymanagerserver/src/rtsecmgrpolicyparser.cpp --- /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 +#include +#include + +#include "rtsecmgrpolicyparser.h" +#include "rtsecmgrdata.h" +#include "rtsecmgrserverdef.h" + +#include +#include +#include +#include +#include + +_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 nodes + while ( childNode) + { + TPtrC nodeName = childNode->NodeName (); + + //ALIAS PARSING + if ( nodeName.CompareF (KAlias)== 0) + { + CMDXMLElement + * aliasNode = dynamic_cast(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(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))// 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))// 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& aCapNodes, const TDesC& aNodeName) + { + if ( aParentDomainNode->HasChildNodes ()) + { + CMDXMLNode* childNode = aParentDomainNode->FirstChild (); + + do + { + if ( childNode) + { + if ( 0==childNode->NodeName().Compare (aNodeName)) + { + CMDXMLElement* pAllowNode = dynamic_cast(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(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(childNode); + + //traverse nodes under + if ( capabilitiesNode->HasChildNodes ()) + { + RCapabilityArray capabilities; + + for (CMDXMLNode + * capabilityNode=capabilitiesNode->FirstChild (); capabilityNode;capabilityNode=capabilityNode->NextSibling ()) + { + //Get the textnode under + if ( capabilityNode) + { + for (CMDXMLNode + * capChildNode=capabilityNode->FirstChild (); capChildNode;capChildNode=capChildNode->NextSibling ()) + { + //Get the textnode under + if ( CMDXMLNode::ETextNode==capChildNode->NodeType ()) + { + CMDXMLText + * capTextNode = dynamic_cast(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 under ")); + } + + } + + 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(childNode); + + //traverse nodes under + if ( capabilitiesNode->HasChildNodes ()) + { + RCapabilityArray capabilities; + + for (CMDXMLNode + * capabilityNode=capabilitiesNode->FirstChild (); capabilityNode;capabilityNode=capabilityNode->NextSibling ()) + { + //Get the textnode under + if ( capabilityNode) + { + for (CMDXMLNode + * capChildNode=capabilityNode->FirstChild (); capChildNode;capChildNode=capChildNode->NextSibling ()) + { + //Get the textnode under + if ( CMDXMLNode::ETextNode==capChildNode->NodeType ()) + { + CMDXMLText + * capTextNode = dynamic_cast(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 under ")); + } + + } + + 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(childNode); + + if ( condNode->HasChildNodes ()) + { + for (CMDXMLNode* condChildNode=condNode->FirstChild (); condChildNode;condChildNode=condChildNode->NextSibling ()) + { + //Get the textnode under + if ( CMDXMLNode::ETextNode==condChildNode->NodeType ()) + { + CMDXMLText + * condition = dynamic_cast(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(childNode); + + if ( condNode->HasChildNodes ()) + { + for (CMDXMLNode* condChildNode=condNode->FirstChild (); condChildNode;condChildNode=condChildNode->NextSibling ()) + { + if ( CMDXMLNode::ETextNode==condChildNode->NodeType ()) + { + CMDXMLText + * condition = dynamic_cast(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; + }