--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/policymanagement/policyengine/policyengineserver/src/PolicyParser.cpp Thu Dec 17 09:07:52 2009 +0200
@@ -0,0 +1,1155 @@
+/*
+* Copyright (c) 2000 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
+*
+*/
+
+
+// INCLUDES
+
+#include "PolicyParser.h"
+#include "ElementBase.h"
+#include "elements.h"
+#include "DataTypes.h"
+#include "debug.h"
+#include "PolicyStorage.h"
+#include "XACMLconstants.h"
+#include "ErrorCodes.h"
+
+#include <f32file.h>
+#include <e32base.h>
+#include <s32file.h>
+
+// MACROS
+// CONSTANTS
+
+_LIT8( KCDataStart, "<![CDATA[");
+const TInt KCDataStartLength = 9;
+const TInt KCDataEndLength = 3;
+_LIT8( KCDataEnd, "]]>");
+
+// DATA TYPES
+// FUNCTION PROTOTYPES
+
+
+namespace ParserUtility
+{
+ // -----------------------------------------------------------------------------
+ // ParserUtility::ContainsCDataField
+ // -----------------------------------------------------------------------------
+ //
+ TBool ContainsCDataField( TPtrC8& aChunk)
+ {
+ //Find CData indicator
+ return 0 <= aChunk.Find( KCDataStart);
+ }
+
+ // -----------------------------------------------------------------------------
+ // ParserUtility::ReadCDataArea
+ // -----------------------------------------------------------------------------
+ //
+ void ReadCDataAreaL( TPtrC8& aCDataArea, TPtrC8& aChunk, TPtrC8& aFinalPart)
+ {
+ //find cdata start index and calculate nested cdata fields
+ TPtrC8 temp = aFinalPart;
+ TInt tempIndex;
+ TInt cdatastart = KErrNotFound;
+
+ TInt cdataCount = 0;
+ while ( KErrNotFound != (tempIndex = temp.Find( KCDataStart)))
+ {
+ if ( cdatastart == KErrNotFound)
+ {
+ //save cdata field start
+ cdatastart = tempIndex;
+ }
+ temp.Set( temp.Mid(tempIndex + KCDataStartLength));
+ cdataCount++;
+ }
+
+ User::LeaveIfError( cdatastart);
+
+ //find end location for cdata field (dismiss nested CDATA end marks)
+ TInt cdataend = 0;
+ temp.Set( aFinalPart);
+
+ while ( cdataCount-- )
+ {
+ TInt current = temp.Find( KCDataEnd);
+ temp.Set( temp.Mid(current + KCDataEndLength ));
+ cdataend += current + KCDataEndLength;
+ }
+
+ if ( cdataCount != -1 )
+ {
+ User::Leave( KErrCorrupt);
+ }
+
+ //set cdata area
+ aCDataArea.Set( aFinalPart.Mid( cdatastart));
+ aCDataArea.Set( aCDataArea.Left( cdataend - cdatastart));
+
+
+ //shrink cdata part from chunk and set aFinalPart to begin after cdata part
+ aChunk.Set( aChunk.Left( cdatastart));
+ aFinalPart.Set( aFinalPart.Mid( cdataend));
+ }
+
+ // -----------------------------------------------------------------------------
+ // ParserUtility::RemoveCDataMarks
+ // -----------------------------------------------------------------------------
+ //
+ void RemoveCDataMarksL( TPtrC8& aData)
+ {
+ TInt index = aData.Find( KCDataStart);
+
+ User::LeaveIfError( index );
+
+ aData.Set( aData.Mid( index + KCDataStartLength));
+
+ TInt validIndex = 0;
+ TInt tempIndex;
+
+ TPtrC8 temp = aData;
+
+ while ( KErrNotFound != ( tempIndex = temp.Find( KCDataEnd)))
+ {
+ validIndex += tempIndex + KCDataEndLength;
+ temp.Set( temp.Mid( tempIndex + KCDataEndLength ));
+ }
+
+ User::LeaveIfError( index );
+
+ aData.Set( aData.Left( validIndex - KCDataEndLength));
+ }
+
+ TInt LineCounter( TPtrC8& aData)
+ {
+ TPtrC8 temp = aData;
+ TInt rowCount = 0;
+ TInt index;
+
+ //ascii code 10 is line feed mark
+ while ( KErrNotFound != ( index = temp.Locate( 10)))
+ {
+ rowCount++;
+ temp.Set( temp.Mid( index + 1 ));
+ }
+
+ return rowCount;
+ }
+
+}
+
+
+// FORWARD DECLARATIONS
+// CLASS DECLARATION
+
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::CPolicyParser
+// -----------------------------------------------------------------------------
+//
+CPolicyParser::CPolicyParser( CPolicyStorage * aStorage)
+ : iStorage( aStorage)
+{
+
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::~CPolicyParser
+// -----------------------------------------------------------------------------
+//
+
+CPolicyParser::~CPolicyParser()
+{
+ delete iElementStack;
+ delete iParser;
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::NewL
+// -----------------------------------------------------------------------------
+//
+
+CPolicyParser* CPolicyParser::NewL( CPolicyStorage * aStorage)
+{
+ //2nd phase constructor
+ CPolicyParser * self = new (ELeave) CPolicyParser( aStorage);
+
+ CleanupStack::PushL( self);
+ self->ConstructL();
+ CleanupStack::Pop( self);
+
+ return self;
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::ConstructL()
+// -----------------------------------------------------------------------------
+//
+
+void CPolicyParser::ConstructL()
+{
+ //2nd phase constructor
+ iElementStack = new (ELeave)CStack<CElementBase, EFalse>;
+ iParser = Xml::CParser::NewL( _L8( "text/xml"), *this );
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::ParseXACMLObjects()
+// -----------------------------------------------------------------------------
+//
+
+CElementBase * CPolicyParser::ParseXACMLObjects( TInt& aError, const TDesC8 &aXACML, TDes8 &aReturnText)
+{
+ //parsing for XACML objects
+ //Set parsing properties
+ iValidCharacterSet = EFalse;
+ iErrorHandling = ETrue;
+ iLanguage = EXACML;
+
+ iElementStack->Reset();
+ iStorage->ResetRealIdValidTest();
+
+ iActiveElement = NULL;
+ iReturnText = ParserErrors::ParsingOk;
+
+ //actual parsing....
+ TRAP( aError, ParseL( aXACML));
+
+ //In error case delete root element...
+ if ( aError != KErrNone )
+ {
+ delete iRootElement;
+ iRootElement = NULL;
+ }
+
+ iStorage->ResetRealIdValidTest();
+
+ aReturnText = iReturnText;
+
+
+ return iRootElement;
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::ParseL()
+// -----------------------------------------------------------------------------
+//
+
+void CPolicyParser::ParseL( const TDesC8 &aXACML)
+{
+ //reset line counter and initialize XML-parser
+ iActiveLine = 0;
+ iParser->ParseBeginL();
+
+ //Max size of chunk (max text length, which go once to parser)
+ const TInt KMaxChunkLength = 1000;
+
+ TPtrC8 xacmlDescription = aXACML;
+ TPtrC8 chunk;
+ TInt length = KMaxChunkLength < xacmlDescription.Length() ? KMaxChunkLength : xacmlDescription.Length();
+
+ do
+ {
+ //max text, which go to parser is one line or KMaxChunkLength. Counter tracks line, where parsing is going
+ iActiveLine++;
+ //Find line feed mark (asciicode 10)
+ TInt index = xacmlDescription.Locate(10);
+
+ if ( index != KErrNotFound)
+ {
+ length = index + 1;
+ }
+
+ //set chunk pointer
+ chunk.Set( xacmlDescription.Left(length));
+ TPtrC8 cdata;
+
+ if ( ParserUtility::ContainsCDataField( chunk))
+ {
+ //cdata mark indicated in chunk, remove cdata area from chunk,
+ ParserUtility::ReadCDataAreaL( cdata, chunk, xacmlDescription);
+
+ if ( iLanguage == EXACML)
+ {
+ iActiveLine += ParserUtility::LineCounter( cdata);
+ }
+ }
+ else
+ {
+ //set remaining XACML description to xacmlDescription
+ xacmlDescription.Set( xacmlDescription.Mid(length));
+ }
+
+
+ //'|' and '~' are not allowed in policy system...
+ if ( iLanguage == EXACML && (chunk.Locate('|') != KErrNotFound || chunk.Locate('~') != KErrNotFound))
+ {
+ HandleErrorL( ParserErrors::InvalidMark, ParserErrors::InvalidMarks);
+ }
+
+ //drive description to parser
+ iParser->ParseL( chunk);
+
+ //in cdata case call directly OnContent
+ if ( cdata.Length())
+ {
+ TInt err = KErrNotFound;
+ OnContentL( cdata, err);
+ }
+
+ length = KMaxChunkLength < xacmlDescription.Length() ? KMaxChunkLength : xacmlDescription.Length();
+ } while ( length);
+
+ //close parser
+ iParser->ParseEndL();
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::ParseL()
+// -----------------------------------------------------------------------------
+//
+
+TInt CPolicyParser::ParseNativeObjects( CElementBase * aSeedElement, const TDesC8 &aNative, TBool aAddToEditableCache)
+{
+ //parsing for native objects
+ //set parsing properties
+ iValidCharacterSet = ETrue;
+ iErrorHandling = EFalse;
+ iLanguage = ENative;
+ iElementStack->Reset();
+ iAddToEditableCache = aAddToEditableCache;
+
+ //seed element is given by function caller
+ iActiveElement = aSeedElement;
+
+ //parsing
+ TRAPD( err, ParseL( aNative));
+
+ return err;
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::SetLineOffset()
+// -----------------------------------------------------------------------------
+//
+
+void CPolicyParser::SetLineOffset( TInt aLine)
+{
+ iLineOffset = aLine;
+}
+
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::HandleErrorL()
+// -----------------------------------------------------------------------------
+//
+void CPolicyParser::HandleErrorL( const TDesC8 &aText)
+ {
+ //if error handling is on....
+ if ( iErrorHandling )
+ {
+ //parse error text
+ iReturnText.Copy( _L8("(Line "));
+ iReturnText.AppendNum( iActiveLine + iLineOffset);
+ iReturnText.Append( _L8(") "));
+ iReturnText.Append( aText);
+ RDEBUG8_2("XACML parser error: %S", &iReturnText);
+ }
+
+ User::Leave( KErrParser );
+ }
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::HandleErrorL()
+// -----------------------------------------------------------------------------
+//
+
+void CPolicyParser::HandleErrorL( const TDesC8 &aText, const TDesC8 &aErrorElement)
+{
+ //parse error text
+
+ TBuf8<KMaxReturnMessageLength> returnText;
+
+ const TInt KErrorMsgLength = 20;
+
+ if ( (aText.Length() + aErrorElement.Length() + KErrorMsgLength) < KMaxReturnMessageLength)
+ {
+ returnText = aText;
+ returnText.Append(_L(": "));
+ returnText.Append( aErrorElement);
+ }
+
+
+ HandleErrorL( returnText);
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::HandleErrorL()
+// -----------------------------------------------------------------------------
+//
+
+void CPolicyParser::HandleErrorL( const TAny * aPointer, const TDesC8 &aError, const TDesC8 &aErrorElement)
+{
+ if ( aPointer != NULL)
+ {
+ HandleErrorL( aError, aErrorElement);
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::HandleNativeErrorL()
+// -----------------------------------------------------------------------------
+//
+
+void CPolicyParser::HandleNativeErrorL( TInt /*aError*/)
+{
+ //When parsing native objects, error messages are not needed
+ User::Leave( KErrNativeParser);
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::Language()
+// -----------------------------------------------------------------------------
+//
+
+TLanguageSelector CPolicyParser::Language()
+{
+ return iLanguage;
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::CreateIdElementsL()
+// -----------------------------------------------------------------------------
+//
+
+void CPolicyParser::CreateIdElementsL( const TDesC8& aIdString )
+{
+#ifndef __POLICY_BASE_CREATOR_TOOL
+
+ TPtrC8 ptr( aIdString);
+ TUint32 policySystemid(0);
+ TBool atLeastOneId = EFalse;
+
+ //parse from id string ids, which belongs to current component.
+ while ( ptr[0] == '|')
+ {
+ //remove delimiter
+ ptr.Set( ptr.Mid(1));
+
+ //find second delimiter
+ TInt index = ptr.Locate('|');
+
+ TPtrC8 elementId( ptr);
+
+ //if second delimiter found set correct length for elementId, otherwise elementId length is allready valid
+ if ( index != KErrNotFound)
+ {
+ elementId.Set( ptr.Left( index));
+ ptr.Set( ptr.Mid( index));
+ }
+
+ //read element id to TUint32 variable (policySystemid)
+ TLex8 lex( elementId);
+ lex.Val( policySystemid, EDecimal);
+
+ CElementBase * element = 0;
+
+ if ( iAddToEditableCache )
+ {
+ element = iStorage->GetEditableElementL( policySystemid);
+ }
+ else
+ {
+ element = iStorage->GetElementL( policySystemid);
+ }
+
+ //add id element (element with id) to active element
+ if ( element )
+ {
+ iActiveElement->AddIdElementL( element);
+ }
+ else
+ {
+ HandleNativeErrorL( KErrParser);
+ }
+
+ //at least one element must be found
+ atLeastOneId = ETrue;
+ }
+
+ if ( !atLeastOneId)
+ {
+ HandleNativeErrorL( KErrParser);
+ }
+
+#endif //__POLICY_BASE_CREATOR_TOOL
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::OnStartDocumentL()
+// -----------------------------------------------------------------------------
+//
+void CPolicyParser::OnStartDocumentL(const Xml::RDocumentParameters& aDocParam, TInt /*aErrorCode*/)
+{
+ if ( aDocParam.CharacterSetName().DesC() == PolicyLanguage::XACML::CharacterSetUTF8)
+ {
+ iValidCharacterSet = ETrue;
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::OnEndDocumentL()
+// -----------------------------------------------------------------------------
+//
+void CPolicyParser::OnEndDocumentL(TInt /*aErrorCode*/)
+{
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::OnStartElementL()
+// -----------------------------------------------------------------------------
+//
+void CPolicyParser::OnStartElementL(const Xml::RTagInfo& aElement, const Xml::RAttributeArray& aAttributes, TInt /*aErrorCode*/)
+{
+ //Debug variables
+ const TDesC8& prefix( aElement.Prefix().DesC());
+ const TDesC8& uri(aElement.Uri().DesC());
+ //Debug variables
+
+ //Set active element name (used in error handling)
+ iActiveElementName.Set( aElement.LocalName().DesC());
+ TPtrC8 elementName = iActiveElementName;
+
+ //if content is XACML, convert it to native language
+ if ( iLanguage == EXACML )
+ {
+ elementName.Set( ConvertElementNamesL( iActiveElementName));
+ }
+
+ TBool createNewElement = ETrue;
+ if ( iActiveElement )
+ {
+ //When activeelement is created (ENotLoaded state) and stack size is 0, parser
+ //assumes that activeelement is seed element and there is no need to create new elelent
+ if ((iActiveElement->iElementState == ENotLoadedEditableElement ||
+ iActiveElement->iElementState == ENotLoaded ) && iElementStack->Count() == 0)
+ {
+ //element must have valid type
+ if ( !iActiveElement->IdentificateElement( elementName))
+ {
+ HandleNativeErrorL( KErrParser);
+ }
+ createNewElement = EFalse;
+ }
+ }
+
+ //Identifie type and create new element
+ CElementBase * element( NULL);
+ if ( createNewElement )
+ {
+ if ( CAttributeValue::IdentificateType( elementName) )
+ {
+ element = CAttributeValue::NewL();
+ } else
+ if ( CSubjectAttributeDesignator::IdentificateType( elementName) )
+ {
+ element = CSubjectAttributeDesignator::NewL();
+ } else
+ if ( CActionAttributeDesignator::IdentificateType( elementName) )
+ {
+ element = CActionAttributeDesignator::NewL();
+ } else
+ if ( CResourceAttributeDesignator::IdentificateType( elementName) )
+ {
+ element = CResourceAttributeDesignator::NewL();
+ } else
+ if ( CEnvironmentAttributeDesignator::IdentificateType( elementName) )
+ {
+ element = CEnvironmentAttributeDesignator::NewL();
+ } else
+ if ( CMatchObject::IdentificateType( elementName) )
+ {
+ element = CMatchObject::NewL(elementName);
+ } else
+ if ( CSubject::IdentificateType( elementName) )
+ {
+ element = CSubject::NewL();
+ } else
+ if ( CAction::IdentificateType( elementName) )
+ {
+ element = CAction::NewL();
+ } else
+ if ( CResource::IdentificateType( elementName) )
+ {
+ element = CResource::NewL();
+ } else
+ if ( CEnvironment::IdentificateType( elementName) )
+ {
+ element = CEnvironment::NewL();
+ } else
+ if ( CSubjects::IdentificateType( elementName) )
+ {
+ element = CSubjects::NewL();
+ } else
+ if ( CActions::IdentificateType( elementName) )
+ {
+ element = CActions::NewL();
+ } else
+ if ( CResources::IdentificateType( elementName) )
+ {
+ element = CResources::NewL();
+ } else
+ if ( CEnvironments::IdentificateType( elementName) )
+ {
+ element = CEnvironments::NewL();
+ } else
+ if ( CRule::IdentificateType( elementName) )
+ {
+ element = CRule::NewL();
+ } else
+ if ( CTarget::IdentificateType( elementName) )
+ {
+ element = CTarget::NewL();
+ } else
+ if ( CPolicy::IdentificateType( elementName) )
+ {
+ element = CPolicy::NewL();
+ } else
+ if ( CPolicySet::IdentificateType( elementName) )
+ {
+ element = CPolicySet::NewL();
+ } else
+ if ( CDescription::IdentificateType( elementName) )
+ {
+ element = CDescription::NewL();
+ } else
+ if ( CApply::IdentificateType( elementName) )
+ {
+ element = CApply::NewL();
+ } else
+ if ( CCondition::IdentificateType( elementName) )
+ {
+ element = CCondition::NewL();
+ }
+ else
+ {
+ HandleErrorL( ParserErrors::InvalidElement, iActiveElementName);
+ }
+
+ //set element to correct state in Native mode
+ if ( iLanguage == ENative)
+ {
+ element->iElementState = iAddToEditableCache ? EEditableCacheElement : ECacheElement;
+ }
+ }
+ else
+ {
+ //and if active element is already created use it....
+ element = iActiveElement;
+ }
+
+ //cleanup...
+ CleanupStack::PushL( element);
+
+ //search eleement attributes
+ for ( TInt i = 0; i < aAttributes.Count(); i++)
+ {
+ Xml::RAttribute attribute( aAttributes[i]);
+
+ //DEBUG VARIABLES
+ const TDesC8& prefixx( attribute.Attribute().Prefix().DesC());
+ const TDesC8& urii(attribute.Attribute().Uri().DesC());
+ const TDesC8& elementNamee( attribute.Attribute().LocalName().DesC());
+ //DEBUG VARIABLES
+
+ TPtrC8 convertedName = attribute.Attribute().LocalName().DesC();
+ TPtrC8 convertedValue = attribute.Value().DesC();
+
+ //if XACML used, convert names to native language
+ if ( iLanguage == EXACML )
+ {
+ convertedName.Set( ConvertAttributesL( attribute.Attribute().LocalName().DesC()));
+ convertedValue.Set( ConvertValues( EXACML, attribute.Value().DesC()));
+ }
+
+ //and add attributes to element
+ element->AddAttributeL( this, convertedName, convertedValue );
+ }
+
+ //add element to element stack
+ iElementStack->PushL( iActiveElement);
+
+ //and if new element created
+ if ( createNewElement )
+ {
+ if ( iActiveElement != NULL)
+ {
+ //if active element exist add element to active element...
+ iActiveElement->AddElementL( this, element);
+ }
+ else
+ {
+ //...otherwise add element to root
+ iRootElement = element;
+ }
+
+ //current element is active element for next element
+ iActiveElement = element;
+ }
+
+ //cleanup: element
+ CleanupStack::Pop( element);
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::OnEndElementL()
+// -----------------------------------------------------------------------------
+//
+
+void CPolicyParser::OnEndElementL(const Xml::RTagInfo& aElement, TInt /*aErrorCode*/)
+{
+ //set active element name
+ iActiveElementName.Set( aElement.LocalName().DesC());
+ TPtrC8 elementName( iActiveElementName);
+
+
+ //if XACML parsing, convert name to native language
+ if ( iLanguage == EXACML)
+ {
+ elementName.Set( ConvertElementNamesL( iActiveElementName));
+ }
+
+ //Check is end stack correct
+ if ( !iActiveElement->IdentificateElement( elementName))
+ {
+ HandleErrorL( ParserErrors::InvalidElement, aElement.LocalName().DesC());
+ }
+
+ //when parsing XACML make validy check for element...
+ if ( iLanguage == EXACML)
+ {
+ if ( !iActiveElement->ValidElement() )
+ {
+ HandleErrorL( ParserErrors::InvalidElement, iActiveElementName);
+ }
+ }
+
+ //previous active element from stack
+ iActiveElement = iElementStack->Pop();
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::OnContentL()
+// -----------------------------------------------------------------------------
+//
+
+void CPolicyParser::OnContentL(const TDesC8& aBytes, TInt /*aErrorCode*/)
+{
+ //activename....
+ iActiveElementName.Set( aBytes);
+
+ TPtrC8 ptr = aBytes;
+
+ //remove tabs, spaces, line feeds and so on
+ ptr.Set( aBytes);
+ if ( ptr.Length() == 1 && (ptr[0] == 9 || ptr[0] == 13 || ptr[0] == 10 || ptr[0] == 32))
+ {
+ //do nothing
+ }
+ else
+ {
+ //remove extra marks before id check
+ //from start
+ while ( ptr[0] == 9 || ptr[0] == 13 || ptr[0] == 10 || ptr[0] == 32)
+ {
+
+ ptr.Set( ptr.Mid(1));
+ if ( ptr.Length() == 0)
+ {
+ break;
+ }
+ }
+
+ //from end
+ TInt index = ptr.Length() - 1;
+ if ( index >= 0 )
+ {
+ while ( ptr[ index] == 9 || ptr[ index] == 13 || ptr[ index] == 10 || ptr[ index] == 32)
+ {
+ ptr.Set( ptr.Ptr(), index);
+ if ( ptr.Length() == 0)
+ {
+ break;
+ }
+
+ index--;
+ }
+ }
+
+ if ( ptr.Length() > 0 )
+ {
+ //if delimiter found, element content contains element ids, which belong to element
+ if ( ptr[0] == KMessageDelimiterChar)
+ {
+ //create ID-elements
+ CreateIdElementsL( ptr);
+ }
+ else
+ {
+ //or add element content
+ iActiveElement->AddContentL( this, ptr);
+ }
+ }
+ }
+
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::SetExternalIdChecked()
+// -----------------------------------------------------------------------------
+//
+
+void CPolicyParser::SetExternalIdChecked( TAllowedExternalIdConflicts aCheckerState)
+{
+ iCheckerState = aCheckerState;
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::SetExternalIdChecked()
+// -----------------------------------------------------------------------------
+//
+
+void CPolicyParser::CheckExternalIdL( const HBufC8 * iExternalId)
+{
+ //make external id check only when parsing XACML
+ if ( iLanguage == EXACML && iCheckerState != KNoExternalIdCheck)
+ {
+ if ( !iStorage->IsRealIdValidL( *iExternalId))
+ {
+ if ( !( iCheckerState == KSameExternalIdAllowedForRoot && iElementStack->Count() == 0 ))
+ {
+ HandleErrorL( ManagementErrors::IdAlreadyExist, *iExternalId);
+ }
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::ActiveElementName()
+// -----------------------------------------------------------------------------
+//
+
+TDesC8& CPolicyParser::ActiveElementName()
+{
+ return iActiveElementName;
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::CheckCompiningAlgorithmsL()
+// -----------------------------------------------------------------------------
+//
+void CPolicyParser::CheckCompiningAlgorithmsL( TNativeElementTypes aType, const TDesC8& aAlgorithmId )
+{
+ //check only when parsinf XACML
+ if ( iLanguage == EXACML)
+ {
+ if ( aAlgorithmId == PolicyLanguage::NativeLanguage::CombiningAlgorithms::RuleDenyOverrides ||
+ aAlgorithmId == PolicyLanguage::NativeLanguage::CombiningAlgorithms::RulePermitOverrides)
+ {
+ if ( aType != EPolicy)
+ {
+ HandleErrorL( ParserErrors::InvalidValue, aAlgorithmId);
+ }
+ }
+ else
+ if ( aAlgorithmId == PolicyLanguage::NativeLanguage::CombiningAlgorithms::PolicyDenyOverrides ||
+ aAlgorithmId == PolicyLanguage::NativeLanguage::CombiningAlgorithms::PolicyPermitOverrides)
+ {
+ if ( aType != EPolicySet)
+ {
+ HandleErrorL( ParserErrors::InvalidValue, aAlgorithmId);
+ }
+ }
+ else
+ {
+ HandleErrorL( ParserErrors::InvalidValue, aAlgorithmId);
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::CheckFunctionIdL()
+// -----------------------------------------------------------------------------
+//
+
+void CPolicyParser::CheckFunctionIdL( const TNativeElementTypes& aType, const TDesC8& aFunctionId )
+{
+ if ( iLanguage == EXACML)
+ {
+ //these functions are valid for apply-component
+ if ( aType == EApply)
+ {
+ if (!( aFunctionId == PolicyLanguage::NativeLanguage::Functions::FunctionAnd ||
+ aFunctionId == PolicyLanguage::NativeLanguage::Functions::FunctionNot ||
+ aFunctionId == PolicyLanguage::NativeLanguage::Functions::FunctionOr ||
+ aFunctionId == PolicyLanguage::NativeLanguage::Functions::FunctionCertificatedSession ||
+ aFunctionId == PolicyLanguage::NativeLanguage::Functions::FunctionRuleTargetStructure ||
+ aFunctionId == PolicyLanguage::NativeLanguage::Functions::FunctionUserAcceptCorpPolicy ||
+ aFunctionId == PolicyLanguage::NativeLanguage::Functions::FunctionBooleanEqualId ||
+ aFunctionId == PolicyLanguage::NativeLanguage::Functions::FunctionStringEqualId ))
+ {
+ HandleErrorL( ParserErrors::InvalidValue, aFunctionId );
+ }
+ } //and these are valid also for other elements (match elements in practice)
+ else if (!(aFunctionId == PolicyLanguage::NativeLanguage::Functions::FunctionStringEqualId ||
+ aFunctionId == PolicyLanguage::NativeLanguage::Functions::FunctionBooleanEqualId ||
+ aFunctionId == PolicyLanguage::NativeLanguage::Functions::FunctionUserAcceptCorpPolicy ||
+ aFunctionId == PolicyLanguage::NativeLanguage::Functions::TrustedRoleMatch ||
+ aFunctionId == PolicyLanguage::NativeLanguage::Functions::TrustedSubjectMatch))
+ {
+ HandleErrorL( ParserErrors::InvalidValue, aFunctionId );
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::CheckEffectL()
+// -----------------------------------------------------------------------------
+//
+
+void CPolicyParser::CheckEffectL( const TDesC8& aEffect )
+{
+ if ( iLanguage == EXACML)
+ {
+ if (!(aEffect == PolicyLanguage::NativeLanguage::Rule::Deny ||
+ aEffect == PolicyLanguage::NativeLanguage::Rule::Permit ))
+ {
+ HandleErrorL( ParserErrors::InvalidValue, aEffect );
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::CheckDataTypeL()
+// -----------------------------------------------------------------------------
+//
+
+void CPolicyParser::CheckDataTypeL( const TDesC8& aDataType )
+{
+ if ( iLanguage == EXACML)
+ {
+ if (!(aDataType == PolicyLanguage::NativeLanguage::AttributeValues::StringDataType ||
+ aDataType == PolicyLanguage::NativeLanguage::AttributeValues::BooleanDataType ))
+ {
+ HandleErrorL( ParserErrors::InvalidValue, aDataType );
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::OnStartPrefixMappingL()
+// -----------------------------------------------------------------------------
+//
+void CPolicyParser::OnStartPrefixMappingL(const RString& /*aPrefix*/, const RString& /*aUri*/, TInt /*aErrorCode*/)
+{
+
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::OnEndPrefixMappingL()
+// -----------------------------------------------------------------------------
+//
+void CPolicyParser::OnEndPrefixMappingL(const RString& /*aPrefix*/, TInt /*aErrorCode*/)
+{
+
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::OnIgnorableWhiteSpaceL()
+// -----------------------------------------------------------------------------
+//
+void CPolicyParser::OnIgnorableWhiteSpaceL(const TDesC8& /*aBytes*/, TInt /*aErrorCode*/)
+ {
+
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::OnSkippedEntityL()
+// -----------------------------------------------------------------------------
+//
+void CPolicyParser::OnSkippedEntityL(const RString& /*aName*/, TInt /*aErrorCode*/)
+{
+
+}
+
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::OnProcessingInstructionL()
+// -----------------------------------------------------------------------------
+//
+void CPolicyParser::OnProcessingInstructionL(const TDesC8& /*aTarget*/, const TDesC8& /*aData*/, TInt /*aErrorCode*/)
+{
+
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::OnError()
+// -----------------------------------------------------------------------------
+//
+void CPolicyParser::OnError(TInt /*aErrorCode*/)
+ {
+ // we need to leave here because Policy Engine traps parser errors, even though
+ // this function does not have L in it's name.
+ HandleErrorL( ParserErrors::SyntaxError );
+ }
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::GetExtendedInterface()
+// -----------------------------------------------------------------------------
+//
+TAny* CPolicyParser::GetExtendedInterface(const TInt32 /*aUid*/)
+ {
+
+ return NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::ConvertElementNamesL()
+// -----------------------------------------------------------------------------
+//
+const TDesC8& CPolicyParser::ConvertElementNamesL( const TDesC8& aElementName )
+{
+ using namespace PolicyLanguage;
+
+ //Conver name from XACML to native language (maybe array structure should be used to avoid editing when values is added)
+ if ( AttributeDesignators::SubjectAttributeDesignator[ EXACML ] == aElementName ) return AttributeDesignators::SubjectAttributeDesignator[ ENative];
+ if ( AttributeDesignators::ActionAttributeDesignator[ EXACML ] == aElementName ) return AttributeDesignators::ActionAttributeDesignator[ ENative];
+ if ( AttributeDesignators::ResourceAttributeDesignator[ EXACML ] == aElementName ) return AttributeDesignators::ResourceAttributeDesignator[ ENative];
+ if ( AttributeDesignators::EnvironmentAttributeDesignator[ EXACML ] == aElementName ) return AttributeDesignators::EnvironmentAttributeDesignator[ ENative];
+
+ if ( AttributeValues::AttributeValue[ EXACML ] == aElementName ) return AttributeValues::AttributeValue[ ENative];
+
+ if ( MatchObject::SubjectMatch[ EXACML ] == aElementName ) return MatchObject::SubjectMatch[ ENative];
+ if ( MatchObject::ActionMatch[ EXACML ] == aElementName ) return MatchObject::ActionMatch[ ENative];
+ if ( MatchObject::EnvironmentMatch[ EXACML ] == aElementName ) return MatchObject::EnvironmentMatch[ ENative];
+ if ( MatchObject::ResourceMatch[ EXACML ] == aElementName ) return MatchObject::ResourceMatch[ ENative];
+
+ if ( MatchContainers::Subject[ EXACML ] == aElementName ) return MatchContainers::Subject[ ENative];
+ if ( MatchContainers::Subjects[ EXACML ] == aElementName ) return MatchContainers::Subjects[ ENative];
+ if ( MatchContainers::Action[ EXACML ] == aElementName ) return MatchContainers::Action[ ENative];
+ if ( MatchContainers::Actions[ EXACML ] == aElementName ) return MatchContainers::Actions[ ENative];
+ if ( MatchContainers::Resource[ EXACML ] == aElementName ) return MatchContainers::Resource[ ENative];
+ if ( MatchContainers::Resources[ EXACML ] == aElementName ) return MatchContainers::Resources[ ENative];
+ if ( MatchContainers::Environment[ EXACML ] == aElementName ) return MatchContainers::Environment[ ENative];
+ if ( MatchContainers::Environments[ EXACML ] == aElementName ) return MatchContainers::Environments[ ENative];
+
+ if ( Rule::Rule[ EXACML ] == aElementName ) return Rule::Rule[ ENative];
+ if ( Rule::Target[ EXACML ] == aElementName ) return Rule::Target[ ENative];
+ if ( PolicySet::PolicySet[ EXACML ] == aElementName ) return PolicySet::PolicySet[ ENative];
+ if ( Policy::Policy[ EXACML ] == aElementName ) return Policy::Policy[ ENative];
+
+ if ( Expressions::Apply[ EXACML ] == aElementName ) return Expressions::Apply[ ENative];
+ if ( Expressions::Condition[ EXACML ] == aElementName ) return Expressions::Condition[ ENative];
+
+ if ( Description::Description[ EXACML ] == aElementName ) return Description::Description[ ENative];
+
+ HandleErrorL( ParserErrors::InvalidElement, aElementName);
+
+ return aElementName;
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::ConvertAttributesL()
+// -----------------------------------------------------------------------------
+//
+const TDesC8& CPolicyParser::ConvertAttributesL( const TDesC8& aType )
+{
+ using namespace PolicyLanguage;
+
+ //Conver name from XACML to native language (maybe array structure should be used to avoid editing when values is added)
+ if ( AttributeDesignators::AttributeId[ EXACML ] == aType ) return AttributeDesignators::AttributeId[ ENative];
+ if ( AttributeDesignators::DataType[ EXACML ] == aType ) return AttributeDesignators::DataType[ ENative];
+
+ if ( AttributeValues::DataType[ EXACML ] == aType ) return AttributeValues::DataType[ ENative];
+
+ if ( MatchObject::MatchId[ EXACML ] == aType ) return MatchObject::MatchId[ ENative];
+
+ if ( Rule::RuleId[ EXACML ] == aType ) return Rule::RuleId[ ENative];
+ if ( Rule::Effect[ EXACML ] == aType ) return Rule::Effect[ ENative];
+
+ if ( Expressions::FunctionId[ EXACML ] == aType ) return Expressions::FunctionId[ ENative];
+
+ if ( Policy::PolicyId[ EXACML ] == aType ) return Policy::PolicyId[ ENative];
+ if ( Policy::RuleCombiningAlgId[ EXACML ] == aType ) return Policy::RuleCombiningAlgId[ ENative];
+
+ if ( PolicySet::PolicySetId[ EXACML ] == aType ) return PolicySet::PolicySetId[ ENative];
+ if ( PolicySet::PolicyCombiningAlgId[ EXACML ] == aType ) return PolicySet::PolicyCombiningAlgId[ ENative];
+
+ HandleErrorL( ParserErrors::InvalidElement, aType);
+
+ return aType;
+}
+
+// -----------------------------------------------------------------------------
+// CPolicyParser::ConvertValues()
+// -----------------------------------------------------------------------------
+//
+const TDesC8& CPolicyParser::ConvertValues( TLanguageSelector aLanguage, const TDesC8& aValue)
+{
+ using namespace PolicyLanguage;
+
+ //Conver name from XACML (or native depends on aLanguage variable) to native (or XACML) language
+ //(maybe array structure should be used to avoid editing when values is added)
+
+ //destination langauge, aLanguage is source language
+ TLanguageSelector destLang = ENative;
+
+ if ( aLanguage == ENative)
+ {
+ destLang = EXACML;
+ }
+
+ if ( AttributeValues::StringDataType[ aLanguage ] == aValue ) return AttributeValues::StringDataType[ destLang];
+ if ( AttributeValues::BooleanDataType[ aLanguage ] == aValue ) return AttributeValues::BooleanDataType[ destLang];
+ if ( AttributeValues::BooleanTrue[ aLanguage ] == aValue ) return AttributeValues::BooleanTrue[ destLang];
+ if ( AttributeValues::BooleanFalse[ aLanguage ] == aValue ) return AttributeValues::BooleanFalse[ destLang];
+
+ if ( Rule::Permit[ aLanguage ] == aValue ) return Rule::Permit[ destLang];
+ if ( Rule::Deny[ aLanguage ] == aValue ) return Rule::Deny[ destLang];
+
+ if ( Functions::TrustedRoleMatch[ aLanguage ] == aValue ) return Functions::TrustedRoleMatch[ destLang];
+ if ( Functions::TrustedSubjectMatch[ aLanguage ] == aValue ) return Functions::TrustedSubjectMatch[ destLang];
+ if ( Functions::FunctionStringEqualId[ aLanguage ] == aValue ) return Functions::FunctionStringEqualId[ destLang];
+ if ( Functions::FunctionBooleanEqualId[ aLanguage ] == aValue ) return Functions::FunctionBooleanEqualId[ destLang];
+
+ if ( Functions::FunctionOr[ aLanguage ] == aValue ) return Functions::FunctionOr[ destLang];
+ if ( Functions::FunctionAnd[ aLanguage ] == aValue ) return Functions::FunctionAnd[ destLang];
+ if ( Functions::FunctionAnd[ aLanguage ] == aValue ) return Functions::FunctionAnd[ destLang];
+
+ if ( Functions::FunctionCertificatedSession[ aLanguage ] == aValue ) return Functions::FunctionCertificatedSession[ destLang];
+ if ( Functions::FunctionUserAcceptCorpPolicy[ aLanguage ] == aValue ) return Functions::FunctionUserAcceptCorpPolicy[ destLang];
+ if ( Functions::FunctionRuleTargetStructure[ aLanguage ] == aValue ) return Functions::FunctionRuleTargetStructure[ destLang];
+
+ if ( CombiningAlgorithms::RuleDenyOverrides[ aLanguage ] == aValue ) return CombiningAlgorithms::RuleDenyOverrides[ destLang];
+ if ( CombiningAlgorithms::PolicyDenyOverrides[ aLanguage ] == aValue ) return CombiningAlgorithms::PolicyDenyOverrides[ destLang];
+ if ( CombiningAlgorithms::RulePermitOverrides[ aLanguage ] == aValue ) return CombiningAlgorithms::RulePermitOverrides[ destLang];
+ if ( CombiningAlgorithms::PolicyPermitOverrides[ aLanguage ] == aValue ) return CombiningAlgorithms::PolicyPermitOverrides[ destLang];
+
+
+ return aValue;
+}
+