1 /*

     2 * Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:    

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 #include "PolicyMerger.h"

    22 

    23 #include <XmlEngDdom.h>

    24 #include "wssecuritypolicy.h"

    25 #include "WSPolicy.h"

    26 

    27 using namespace WSPolicy;

    28 

    29 CPolicyMerger* CPolicyMerger::NewL()

    30 {

    31     CPolicyMerger* pSelf =

    32         CPolicyMerger::NewLC();

    33     CleanupStack::Pop(pSelf);

    34     return pSelf;

    35 }

    36 CPolicyMerger* CPolicyMerger::NewLC()

    37 {

    38     CPolicyMerger* pSelf = new (ELeave) CPolicyMerger();

    39     CleanupStack::PushL(pSelf);

    40     pSelf->ConstructL();

    41     return pSelf;  

    42 }

    43 void CPolicyMerger::ConstructL()

    44 {

    45    iSecurityPolicyDomain =    CWsSecurityPolicy::NewL();   

    46 }

    47 CPolicyMerger::~CPolicyMerger()

    48 {

    49    iPolicy1.Close(); 

    50    iPolicy2.Close();

    51     

    52    delete iSecurityPolicyDomain;

    53    

    54 }

    55 CPolicyMerger::CPolicyMerger()

    56 {

    57     

    58 }

    59 

    60 TXmlEngElement CPolicyMerger::MergeL(TDesC& /*aFirstPolicy*/, TDesC& /*aSecondPolicy*/)

    61 {

    62 /*

    63     TDOMImplementation domImpl = XmlEngine::DOM::DOMImplementationSource::DOMImplementationL (XmlEngine::DOM::KImplementationID);  

    64     RDOMParser parser = domImpl.CreateDOMParser();

    65 

    66     iPolicy1 = parser.ParseFileL( aFirstPolicy );

    67     iPolicy2 = parser.ParseFileL( aSecondPolicy );

    68 

    69     TXmlEngElement& pPolicy1 = iPolicy1.AsElement();

    70     TXmlEngElement& pPolicy2 = iPolicy2.AsElement();

    71     

    72     TXmlEngElement result = MergeL(pPolicy1,pPolicy2);

    73 

    74     return result;

    75       */

    76       return NULL;

    77 }

    78 

    79 

    80 TXmlEngElement CPolicyMerger::MergeL(TXmlEngElement aFirstPolicy, TXmlEngElement aSecondPolicy)

    81 {

    82     RXmlEngDocument mergedPolicyDoc = aFirstPolicy.OwnerDocument().CloneDocumentL();

    83     TXmlEngElement& newIntersectedPolicy = mergedPolicyDoc.AsElement();

    84 

    85     RXmlEngNodeList<TXmlEngElement> listPolicynew;

    86     newIntersectedPolicy.GetChildElements(listPolicynew); //get the children of policy  

    87 

    88     if(listPolicynew.HasNext()) 

    89     {

    90         iMergedPolicyElement = listPolicynew.Next();

    91         iMergedPolicyElement.RemoveChildren();

    92     }

    93 

    94     RXmlEngNodeList<TXmlEngElement> listPolicyFirst;

    95     aFirstPolicy.GetChildElements(listPolicyFirst); //get the children of policy

    96 

    97     RXmlEngNodeList<TXmlEngElement> listPolicySecond;

    98     aSecondPolicy.GetChildElements(listPolicySecond); //get the children of policy

    99     

   100     TXmlEngElement XOR = iMergedPolicyElement.AddNewElementSameNsL(WSPolicy::KXorCompositeAssertion);

   101     

   102     

   103     if(listPolicyFirst.HasNext() && listPolicySecond.HasNext()) 

   104     {

   105         TXmlEngElement policyElement = listPolicyFirst.Next();

   106         TPtrC8 localName = policyElement.TagName();

   107                 

   108         RXmlEngNodeList<TXmlEngElement> xorList; //get the only xor element

   109         policyElement.GetElementsByTagNameL(xorList, WSPolicy::KXorCompositeAssertion, WSPolicy::KWsPolicyNsUri);

   110         TXmlEngElement pXORFirst = NULL;

   111         

   112         if(xorList.HasNext())

   113             pXORFirst = xorList.Next();

   114         //get all AND elements from the above xor. 

   115         

   116         RXmlEngNodeList<TXmlEngElement> andListFirst; //get the only xor element from First Policy

   117         pXORFirst.GetElementsByTagNameL(andListFirst, WSPolicy::KAndCompositeAssertion, WSPolicy::KWsPolicyNsUri);

   118 

   119 

   120 

   121     //second policy

   122         TXmlEngElement policyElementSec = listPolicySecond.Next();

   123         

   124         TPtrC8 localName2 = policyElementSec.TagName();

   125 

   126                 

   127         RXmlEngNodeList<TXmlEngElement> xorListSec; //get the only xor element

   128         policyElementSec.GetElementsByTagNameL(xorListSec, WSPolicy::KXorCompositeAssertion, WSPolicy::KWsPolicyNsUri);

   129         TXmlEngElement pXORSec = NULL;

   130         

   131         if(xorListSec.HasNext())

   132             pXORSec = xorListSec.Next();

   133         //we have to get all AND elements from the above xor. we will do it in loop

   134         

   135         

   136         while (andListFirst.HasNext())

   137         {

   138             TXmlEngElement AND = XOR.AddNewElementSameNsL(WSPolicy::KAndCompositeAssertion);

   139             

   140             TXmlEngElement andEleF = andListFirst.Next();

   141             

   142             TPtrC8 localName = andEleF.TagName();

   143             //find all assertions in this AND element

   144             

   145             

   146             MergeCompareSecondAssertionsL(andEleF, pXORSec, AND);

   147         }

   148   

   149     }

   150 

   151     return XOR;

   152 }

   153 

   154 

   155 TXmlEngElement CPolicyMerger::MergeCompareSecondAssertionsL(TXmlEngElement aFirstElement, TXmlEngElement aSecondElement, TXmlEngElement aIntersectedAND)

   156 {

   157 

   158     RXmlEngNodeList<TXmlEngElement> assertionListF; //get all of first assrtions

   159     aFirstElement.GetChildElements(assertionListF);

   160 

   161     RXmlEngNodeList<TXmlEngElement> andListSec; //get all of AND elements

   162     aSecondElement.GetElementsByTagNameL(andListSec, WSPolicy::KAndCompositeAssertion, WSPolicy::KWsPolicyNsUri);

   163     

   164     RArray<TXmlEngElement> result;

   165     while(andListSec.HasNext())

   166     {

   167     //for every of AND element, loop for every AND element in first policy

   168         TXmlEngElement andEleS = andListSec.Next();

   169         

   170         TPtrC8 localNameS = andEleS.TagName();

   171         //find all assertions in this AND element

   172         

   173         RXmlEngNodeList<TXmlEngElement> assertionListS; //get the only xor element

   174         andEleS.GetChildElements(assertionListS);

   175         //RESOLVE all assertion from same AND element  

   176 

   177          MergeAllANDAssertionsL(aFirstElement, andEleS, result);

   178          if(result.Count() > 0)             

   179          {

   180            for (TInt i = 0; i<result.Count(); i++) 

   181            {

   182                 TXmlEngElement resultEle = result[i].CopyL();

   183                 aIntersectedAND.AppendChildL(resultEle);

   184            }

   185            result.Reset();

   186          }

   187         //if result then we have merged policy else we have NULL here

   188          

   189     }

   190     return NULL;

   191 }

   192 

   193 void CPolicyMerger::MergeAllANDAssertionsL(TXmlEngElement aFirstElement, TXmlEngElement aSecondElement, RArray<TXmlEngElement>& aResult)

   194 {

   195     TInt outcount = 0;

   196     TInt inCount = 0;

   197 

   198     RXmlEngNodeList<TXmlEngElement> assertionListF; //get all of first assrtions

   199     aFirstElement.GetChildElements(assertionListF);

   200     

   201     while (assertionListF.HasNext())

   202     {

   203         TXmlEngElement assertionFirst = assertionListF.Next();

   204 

   205         TPtrC8 localName1 = assertionFirst.TagName();

   206         outcount++;

   207 

   208         RXmlEngNodeList<TXmlEngElement> assertionListS; //get all of AND elements

   209         aSecondElement.GetChildElements(assertionListS);

   210 

   211         while(assertionListS.HasNext())

   212         {

   213             TXmlEngElement assertionSecond = assertionListS.Next();

   214 

   215             TPtrC8 localName2 = assertionSecond.TagName();

   216             inCount++;

   217             if((localName1.Compare(localName2) == 0) && 

   218             VerifyNamespace(assertionFirst, assertionSecond))            

   219             {

   220                 //call domain specific policy to resolve

   221                 //check the namespaces here to find which domain we need to process

   222                 //both namespaces should be checked and if they are same then we can intersect them

   223                 TPtrC8 namespaceUri1 = assertionFirst.NamespaceUri();

   224                 //if its ws security policy

   225                 if(namespaceUri1.Compare(KWsSecurityPolicyNsUri) == 0)

   226                 {

   227 /*                

   228                     TXmlEngElement result = iSecurityPolicyDomain->Merge(localName1, assertionFirst, assertionSecond);

   229                     if(result.NotNull())

   230                     {

   231                         aResult.Append(result);

   232                     }

   233                     else

   234                     {

   235                         aResult.Append(assertionFirst);

   236                         aResult.Append(assertionSecond);

   237                     }

   238 */                    

   239                 }                

   240             }

   241         }

   242         

   243     }

   244     

   245 }

   246 

   247 TInt CPolicyMerger::VerifyNamespace(TXmlEngElement aFirstElement, TXmlEngElement aSecondElement)

   248 {

   249     TPtrC8 namespaceUri1 = aFirstElement.NamespaceUri();

   250     TPtrC8 namespaceUri2 = aSecondElement.NamespaceUri();

   251     

   252     if(namespaceUri1 != KNullDesC8() && namespaceUri2 != KNullDesC8())

   253     {

   254       if(namespaceUri1.Compare(namespaceUri2) == 0)

   255         return ETrue;  

   256     }

   257 

   258   return KErrNotFound;  

   259 }