--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsstar/wsstarpolicy/src/WsdlPolicyAttachment.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,910 @@
+/*
+* Copyright (c) 2009 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:
+*
+*/
+
+
+
+
+#include "wsdlpolicyattachment.h"
+#include "wspolicyreader.h"
+#include "wspolicywriter.h"
+#include "policyassertion.h"
+#include "wspolicy.h"
+using namespace WsdlPolicyAttachment;
+
+EXPORT_C CWsdlPolicyAttachment* CWsdlPolicyAttachment::NewL(const TDesC8& aWsdlFileName)
+ {
+ CWsdlPolicyAttachment* pSelf = CWsdlPolicyAttachment::NewLC(aWsdlFileName);
+ CleanupStack::Pop(pSelf);
+ return pSelf;
+ }
+
+EXPORT_C CWsdlPolicyAttachment* CWsdlPolicyAttachment::NewLC(const TDesC8& aWsdlFileName)
+ {
+ CWsdlPolicyAttachment* pSelf = new (ELeave) CWsdlPolicyAttachment();
+ CleanupStack::PushL(pSelf);
+ pSelf->ConstructL(aWsdlFileName);
+ return pSelf;
+ }
+
+CWsdlPolicyAttachment::~CWsdlPolicyAttachment()
+ {
+ iOriginalPolicies.Reset();
+ iNormalizedPolicies.Reset();
+ if( iRegistry )
+ {
+ iRegistry->ResetRegistry();
+ }
+ delete iRegistry;
+ }
+
+void CWsdlPolicyAttachment::ConstructL(const TDesC8& aWsdlFileName)
+ {
+ iRegistry = CPolicyRegistry::NewL();
+ CreateWsdlPolicyL( aWsdlFileName );
+ }
+
+CWsdlPolicyAttachment::CWsdlPolicyAttachment() :
+iOriginalPolicies(ETrue,ETrue),
+iNormalizedPolicies(ETrue, ETrue),
+iParsed(EFalse)
+ {
+ }
+
+void CWsdlPolicyAttachment::CreateWsdlPolicyL( const TDesC8& aWsdlContent )
+ {
+ TInt size = aWsdlContent.Length();
+ if(size > 0)
+ {
+ iXmlReader = CSenXmlReader::NewL( KXmlParserMimeType ); // use libxml2 sax parser + CodeScannerWarnings
+ TRAPD (err, ParseL( aWsdlContent ));
+ delete iXmlReader;
+ iXmlReader = NULL;
+
+ if(err == KErrNone)
+ {
+ iParsed = ETrue;
+ iPolicy = &AsElement();
+ iRegistry->PopulateRegistryL(iPolicy);
+ }
+ }
+}
+
+TPtrC8 CWsdlPolicyAttachment::GetAttributeValueL(const TDesC8& aAttribute, CSenElement* aElement)
+{
+ RPointerArray<CSenBaseAttribute>& attrs = aElement->AttributesL();
+
+ CSenBaseAttribute* bs = NULL;
+ TInt ele_count = attrs.Count();
+
+ for (TInt j=0; j < ele_count; j++)
+ {
+
+ bs = (attrs)[j];
+ if(bs)
+
+ if(bs->Name().Compare(aAttribute) == 0)
+ {
+ return bs->Value();
+ }
+ }
+ return KNullDesC8();
+}
+
+EXPORT_C CSenElement* CWsdlPolicyAttachment::GetEffectiveServicePolicyL( const TDesC8& aService )
+ {
+ //wsdl:service
+ CSenElement* pServicePolicy = GetServicePolicyL( aService );
+ RPointerArray<CSenElement> array;
+ CleanupClosePushL( array );
+ if( pServicePolicy )
+ {
+ array.Append( pServicePolicy );
+ }
+ CWSPolicy* pol = GetEffectivePolicyL( array, iRegistry );
+ CleanupStack::PopAndDestroy( &array ); //array.Close();
+ //CSenElement* policy = NULL;
+ //return policy;
+ return NULL;
+ }
+
+
+EXPORT_C CSenElement* CWsdlPolicyAttachment::GetEffectiveEndpointPolicyL(
+ const TDesC8& aService,
+ const TDesC8& aPort )
+{
+ //wsdl:port
+ //wsdl:portType
+ //wsdl:binding
+ CSenElement* portPolicy = GetPortPolicyL(aService, aPort);
+ RPointerArray<CSenElement> array;
+ CleanupClosePushL( array );
+ if( portPolicy )
+ {
+ array.Append(portPolicy);
+ }
+ CSenElement* portTypePolicy = GetPortTypePolicyL(aService, aPort);
+ if(portTypePolicy)
+ {
+ array.Append(portTypePolicy);
+ }
+
+ CSenElement* bindingPolicy = GetBindingPolicyL(aService, aPort);
+ if(bindingPolicy)
+ {
+ array.Append(bindingPolicy);
+ }
+
+ // (!) Merge these policies to get effective one:
+ CWSPolicy* pol = GetEffectivePolicyL(array, iRegistry); //merge these policies to get effective one
+ if( pol )
+ {
+ // Serialize into file:
+ RFs fss;
+ User::LeaveIfError(fss.Connect());
+ CleanupClosePushL(fss);
+
+ CSenElement* poli = pol->PolicyL();
+ _LIT( KFileNameOut, "c:\\logs\\WsSecurity10Sign.svc.xml");
+ HBufC8* temp = poli->AsXmlL();
+ CleanupStack::PushL(temp);
+ TFileName iFileName12(KFileNameOut);
+ RFile xmlFilew;
+ xmlFilew.Replace(fss , iFileName12, EFileWrite );
+ xmlFilew.Write(temp->Des());
+ xmlFilew.Close();
+ CleanupStack::PopAndDestroy(temp);
+ CleanupStack::PopAndDestroy(&fss);
+ }
+ CleanupStack::PopAndDestroy( &array ); // array.Close();
+ return NULL;
+ }
+
+EXPORT_C CSenElement* CWsdlPolicyAttachment::GetEffectiveOperationPolicyL( const TDesC8& aService,
+ const TDesC8& aPortName,
+ const TDesC8& aOpName )
+ {
+ // wsdl:portType/wsdl:operation
+ // wsdl:binding/wsdl:operation
+ CSenElement* portTypePolicy = GetPortTypeOperationPolicyL(aService, aPortName, aOpName);
+ RPointerArray<CSenElement> array;
+ CleanupClosePushL( array );
+ if(portTypePolicy)
+ {
+ array.Append(portTypePolicy);
+ }
+ CSenElement* bindingPolicy = GetBindingOperationPolicyL(aService, aPortName, aOpName);
+ if(bindingPolicy)
+ {
+ array.Append(bindingPolicy);
+ }
+ // (!) Merge these policies to get effective one:
+ GetEffectivePolicyL(array, iRegistry);
+ CleanupStack::PopAndDestroy( &array ); // array.Close();
+ // CSenElement* policy = NULL;
+ // return policy;
+ return NULL;
+ }
+
+EXPORT_C CSenElement* CWsdlPolicyAttachment::GetEffectiveInputPolicyL(const TDesC8& aService, const TDesC8& aPortName, const TDesC8& aOpName)
+ {
+ // wsdl:message
+ // wsdl:portType/wsdl:operation/wsdl:input
+ // wsdl:binding/wsdl:operation/wsdl:input
+ CSenElement* messagePolicy = GetMessagePolicyL(aService, aPortName, aOpName, ETrue);
+ RPointerArray<CSenElement> array;
+ CleanupClosePushL( array );
+ if( messagePolicy )
+ {
+ array.Append(messagePolicy);
+ }
+ CSenElement* portTypePolicy = GetPortTypeOperationInputOutputPolicyL(aService, aPortName, aOpName, ETrue);
+ if( portTypePolicy )
+ {
+ array.Append(portTypePolicy);
+ }
+ CSenElement* bindingPolicy = GetBindingOperationInputOutputPolicyL(aService, aPortName, aOpName, ETrue);
+ if( bindingPolicy )
+ {
+ array.Append(bindingPolicy);
+ }
+ // (!) Merge these policies to get effective one:
+ GetEffectivePolicyL(array, iRegistry);
+ CleanupStack::PopAndDestroy( &array ); // array.Close();
+ //CSenElement* policy = NULL;
+ //return policy;
+ return NULL;
+ }
+
+EXPORT_C CSenElement* CWsdlPolicyAttachment::GetEffectiveOutputPolicyL(const TDesC8& aService, const TDesC8& aPortName, const TDesC8& aOpName)
+ {
+ // wsdl:message
+ // wsdl:portType/wsdl:operation/wsdl:output
+ // wsdl:binding/wsdl:operation/wsdl:output
+ CSenElement* messagePolicy = GetMessagePolicyL(aService, aPortName, aOpName, EFalse);
+ RPointerArray<CSenElement> array;
+ if( messagePolicy )
+ {
+ array.Append(messagePolicy);
+ }
+ CSenElement* portTypePolicy = GetPortTypeOperationInputOutputPolicyL(aService, aPortName, aOpName, EFalse);
+ if( portTypePolicy )
+ {
+ array.Append(portTypePolicy);
+ }
+ CSenElement* bindingPolicy = GetBindingOperationInputOutputPolicyL(aService, aPortName, aOpName, EFalse);
+ if( bindingPolicy )
+ {
+ array.Append(bindingPolicy);
+ }
+ // (!) Merge these policies to get effective one:
+ GetEffectivePolicyL( array, iRegistry );
+ CleanupStack::PopAndDestroy( &array ); // array.Close();
+ // CSenElement* policy = NULL;
+ // return policy;
+ return NULL;
+}
+
+EXPORT_C CSenElement* CWsdlPolicyAttachment::GetEffectiveFaultPolicyL( /*QName aService, */
+ const TDesC8& /*aPortName*/,
+ const TDesC8& /*aOpName*/ )
+ {
+
+ // wsdl:message
+ // wsdl:portType/wsdl:operation/wsdl:fault
+ // wsdl:binding/wsdl:operation/wsdl:fault
+ return NULL;
+ }
+
+////////////////////////////////////////////////////////////////////////
+//PRIVATE FUNCTIONS
+////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////
+CSenElement* CWsdlPolicyAttachment::GetServicePolicyL( const TDesC8& aServiceName )
+ {
+ // RPointerArray<CSenElement>& list = iPolicy->ElementsL(); //get the definitions elements
+ // TInt count = list.Count();
+ // for(TInt i = 0; i< count; i++)
+ // {
+ // CSenElement* definitions = list[i];
+ // TPtrC8 localName = definitions->LocalName();
+
+ RPointerArray<CSenElement> serviceList; // get the wsdl:service
+ iPolicy->ElementsL(serviceList, KService); //KWsdlNsUri, KService);
+ CleanupClosePushL( serviceList );
+ TInt count2 = serviceList.Count();
+ for( TInt j = 0; j< count2; j++ )
+ {
+ CSenElement* service = serviceList[j];
+
+ TPtrC8 localServiceName = service->LocalName();
+
+ TPtrC8 serviceName = GetAttributeValueL(KName, service);
+ if(serviceName != KNullDesC8())
+ {
+ if (serviceName.Compare(aServiceName) == 0)
+ { //we have right service tag, search its children for PolicyReference
+ serviceList.Close();
+ return GetPolicyReferenceL(service);
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( &serviceList ); // serviceList.Close();
+ return NULL;
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetPortPolicyL(const TDesC8& aServiceName, const TDesC8& aPort)
+ {
+ CSenElement* result = GetServiceElementL(aServiceName);
+ if (result)
+ {
+ result = GetPortElementL(aPort, result);
+ if (result)
+ {
+ return GetPolicyReferenceL(result);
+ }
+
+ }
+ return NULL;
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetPortTypePolicyL( const TDesC8& aServiceName,
+ const TDesC8& aPort )
+ {
+ //from service get port
+ //from port get binding
+ //from binding get porttype
+ CSenElement* result = GetServiceElementL(aServiceName);
+ if (result)
+ {
+ result = GetPortElementL(aPort, result);
+ if (result)
+ {
+ // get binding from port
+ TPtrC8 bindingQName = GetAttributeValueL(KBinding, result);
+
+ TPtrC8 bindingPrefix = bindingQName.Left(bindingQName.Find(KColon));
+ TPtrC8 bindingName = bindingQName.Right(bindingQName.Length() - bindingPrefix.Length()-1);
+
+ result = GetBindingElementL(bindingName);
+ if(result)
+ {
+ //we got the right binding, now get the portType
+ TPtrC8 portTypeQName = GetAttributeValueL(KType, result);
+ //actually this is buinding type
+ TPtrC8 portTypePrefix = portTypeQName.Left(portTypeQName.Find(KColon));
+ TPtrC8 portTypeName = portTypeQName.Right(portTypeQName.Length() - portTypePrefix.Length()-1);
+ //here we have port Name
+ //now look for this port type in wsdl
+ result = GetPortTypeElementL(portTypeName);
+ if(result)
+ {
+ return GetPolicyReferenceL(result);
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+ }
+ }
+ return NULL;
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetBindingPolicyL( const TDesC8& aServiceName,
+ const TDesC8& aPort )
+ {
+ //the aBindingName is obtained from the port operation.
+ //so Use that Name and then jsut search for that particualr binding
+ CSenElement* result = GetServiceElementL(aServiceName);
+ if (result)
+ {
+ result = GetPortElementL(aPort, result);
+ if (result)
+ {
+ // get binding from port and
+ TPtrC8 bindingQName = GetAttributeValueL(KBinding, result);
+
+ TPtrC8 bindingPrefix = bindingQName.Left(bindingQName.Find(KColon));
+ TPtrC8 bindingName = bindingQName.Right(bindingQName.Length() - bindingPrefix.Length()-1);
+ result = GetBindingElementL(bindingName);
+ if( result )
+ {
+ //we got the right binding, now get the policy
+ result = GetPolicyReferenceL( result );
+ //if ( result )
+ // //we got a policy TAG for the binding
+ // {
+ return result;
+ }
+ }
+ }
+ return NULL;
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetPortTypeOperationPolicyL( const TDesC8& aServiceName, const TDesC8& aPort, const TDesC8& aOpName )
+ {
+ CSenElement* result = GetServiceElementL(aServiceName);
+ if ( result )
+ {
+ result = GetPortElementL(aPort, result);
+ if ( result )
+ {
+ // get binding from port and
+ TPtrC8 bindingQName = GetAttributeValueL(KBinding, result);
+ TPtrC8 bindingPrefix = bindingQName.Left(bindingQName.Find(KColon));
+ TPtrC8 bindingName = bindingQName.Right(bindingQName.Length() - bindingPrefix.Length()-1);
+ result = GetBindingElementL(bindingName);
+ if( result )
+ {
+ // we got the right binding, now get the portType
+ TPtrC8 portTypeQName = GetAttributeValueL(KType, result);
+ //actually this is buinding type
+ TPtrC8 portTypePrefix = portTypeQName.Left(portTypeQName.Find(KColon));
+ TPtrC8 portTypeName = portTypeQName.Right(portTypeQName.Length() - portTypePrefix.Length()-1);
+ // here we have port Name
+ // now look for this port type in wsdl
+ result = GetPortTypeElementL( portTypeName );
+ if( result ) //we got the portType
+ {
+ // now get the operation in this element
+ result = GetOperationPolicyL( aOpName, result );
+ return result;
+ }
+ }
+ }
+ }
+ return NULL;
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetBindingOperationPolicyL( const TDesC8& aServiceName, const TDesC8& aPort, const TDesC8& aOpName )
+ {
+ CSenElement* result = GetServiceElementL(aServiceName);
+ if ( result )
+ {
+ result = GetPortElementL(aPort, result);
+ if ( result )
+ {
+ //get binding from port and
+ TPtrC8 bindingQName = GetAttributeValueL(KBinding, result);
+ TPtrC8 bindingPrefix = bindingQName.Left(bindingQName.Find(KColon));
+ TPtrC8 bindingName = bindingQName.Right(bindingQName.Length() - bindingPrefix.Length()-1);
+ result = GetBindingElementL(bindingName);
+ if(result) //we got the right binding,
+ // now get the OperationPolicy from this binding
+ {
+ result = GetOperationPolicyL(aOpName, result);
+ return result;
+ }
+ }
+ }
+ return NULL;
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetOperationPolicyL( const TDesC8& aOpName,
+ CSenElement* aElement )
+ {
+ RPointerArray<CSenElement> operationList;
+ aElement->ElementsL(operationList, KWsdlNsUri, KOperation);
+ CleanupClosePushL( operationList );
+ TInt count = operationList.Count();
+ CSenElement* result = NULL;
+ for(TInt i = 0; i< count; i++)
+ {
+ CSenElement* operation = operationList[i];
+ TPtrC8 operationName = GetAttributeValueL(KName, operation);
+ if(operationName.Compare(aOpName) == 0)
+ {
+ //we got the rigth operation element
+ //now retrieve policy from this element
+ result = GetPolicyReferenceL(operation);
+ //if( result )
+ // {
+ // //we got a policy TAG for the binding
+ //
+ // }
+ }
+ }
+ CleanupStack::PopAndDestroy( &operationList ); // operationList.Close();
+ return result;
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetMessagePolicyL( const TDesC8& aServiceName,
+ const TDesC8& aPort,
+ const TDesC8& aOpName, TBool aInput )
+ {
+ CSenElement* result = GetServiceElementL(aServiceName);
+ if ( result )
+ {
+ result = GetPortElementL(aPort, result);
+ if ( result )
+ {
+ //get binding from port and
+ TPtrC8 bindingQName = GetAttributeValueL(KBinding, result);
+ TPtrC8 bindingPrefix = bindingQName.Left(bindingQName.Find(KColon));
+ TPtrC8 bindingName = bindingQName.Right(bindingQName.Length() - bindingPrefix.Length()-1);
+ result = GetBindingElementL(bindingName);
+ if( result )
+ {
+ // we got the right binding, now get the Operation from this binding
+ // if aInput == ETrue then its Input policy else its output policy
+ // we get binding now find the input/output for that aOpName
+ RPointerArray<CSenElement> operationList;
+ result->ElementsL(operationList, KWsdlNsUri, KOperation);
+ CleanupClosePushL(operationList);
+ TInt count = operationList.Count();
+ for(TInt i = 0; i< count; i++)
+ {
+ CSenElement* operation = operationList[i];
+ TPtrC8 operationName = GetAttributeValueL(KName, operation);
+ if(operationName.Compare(aOpName) == 0)
+ {
+ //we got the rigth operation element
+ //now retrieve input/output element
+ RPointerArray<CSenElement> operationInOutList;
+ CleanupClosePushL(operationInOutList);
+ if(aInput)
+ {
+ operation->ElementsL(operationInOutList, KWsdlNsUri, KInput);
+ }
+ else
+ {
+ operation->ElementsL(operationInOutList, KWsdlNsUri, KOutput);
+ }
+ TInt operationListCount = operationInOutList.Count();
+ for( TInt j = 0; j< operationListCount; j++ )
+ {
+ //should be only one, no more then one input.
+ //if there are more, then weired but the fucntion
+ //will return on first instance of input/output
+
+ CSenElement* inputoutput = operationInOutList[j];
+ //get the message attribute of this input/output operation
+ if(inputoutput)
+ {
+ TPtrC8 messageName = GetAttributeValueL(KMessage, inputoutput);
+ if(messageName != KNullDesC8())
+ {
+
+ // if Qname then retrieve the name from Qname
+
+ CSenElement* result = GetMessageElementL(messageName);
+ if( result )
+ {
+ result = GetPolicyReferenceL(result);
+ CleanupStack::PopAndDestroy(&operationInOutList);
+ CleanupStack::PopAndDestroy(&operationList);
+ return result;
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(&operationInOutList);
+ CleanupStack::PopAndDestroy(&operationList);
+ return NULL;
+ }
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy(&operationInOutList);
+ }
+ }
+ CleanupStack::PopAndDestroy(&operationList);
+ }
+ }
+ }
+ return NULL;
+ }
+
+
+CSenElement* CWsdlPolicyAttachment::GetPortTypeOperationInputOutputPolicyL(const TDesC8& aServiceName, const TDesC8& aPort, const TDesC8& aOpName, TBool aInput)
+ {
+ CSenElement* result = GetServiceElementL(aServiceName);
+ if (result)
+ {
+ result = GetPortElementL(aPort, result);
+ if (result)
+ {
+ // get binding from port and
+ TPtrC8 bindingQName = GetAttributeValueL(KBinding, result);
+ TPtrC8 bindingPrefix = bindingQName.Left(bindingQName.Find(KColon));
+ TPtrC8 bindingName = bindingQName.Right(bindingQName.Length() - bindingPrefix.Length()-1);
+ result = GetBindingElementL( bindingName );
+ if( result )
+ {
+ // we got the right binding, now get the portType
+ TPtrC8 portTypeQName = GetAttributeValueL(KType, result);
+ // actually this is buinding type
+ TPtrC8 portTypePrefix = portTypeQName.Left(portTypeQName.Find(KColon));
+ TPtrC8 portTypeName = portTypeQName.Right(portTypeQName.Length() - portTypePrefix.Length()-1);
+ //here we have port Name
+ //now look for this port type in wsdl
+ result = GetPortTypeElementL(portTypeName);
+ if( result ) //we got the portType
+ {
+ // now get the operation input output policy from this element
+ return GetOperationInputOutputPolicyL(aOpName, result, aInput);
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+ }
+ }
+ return NULL;
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetBindingOperationInputOutputPolicyL(const TDesC8& aServiceName, const TDesC8& aPort, const TDesC8& aOpName, TBool aInput)
+ {
+ CSenElement* result = GetServiceElementL(aServiceName);
+ if (result)
+ {
+ result = GetPortElementL(aPort, result);
+ if (result)
+ {
+ // get binding from port and
+ TPtrC8 bindingQName = GetAttributeValueL(KBinding, result);
+
+ TPtrC8 bindingPrefix = bindingQName.Left(bindingQName.Find(KColon));
+ TPtrC8 bindingName = bindingQName.Right(bindingQName.Length() - bindingPrefix.Length()-1);
+
+ result = GetBindingElementL(bindingName);
+ if(result) //we got the right binding,
+
+ {
+ // now get the Operation from this binding
+ // if aInput == ETrue then its Input policy else its output policy
+
+ result = GetOperationInputOutputPolicyL(aOpName, result, aInput);
+ if(result)
+ {
+ return result;
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+ }
+ }
+ return NULL;
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetOperationInputOutputPolicyL(const TDesC8& aOpName, CSenElement* aElement, TBool aInput)
+{
+ RPointerArray<CSenElement> operationList;
+ aElement->ElementsL( operationList, KWsdlNsUri, KOperation );
+ CleanupClosePushL( operationList );
+ TInt count = operationList.Count();
+ for( TInt i = 0; i< count; i++ )
+ {
+ CSenElement* operation = operationList[i];
+ TPtrC8 operationName = GetAttributeValueL(KName, operation);
+ if(operationName.Compare(aOpName) == 0)
+ {
+ // we got the rigth operation element
+ // now retrieve input/output element
+ RPointerArray<CSenElement> operationInOutList;
+ if(aInput)
+ operation->ElementsL(operationInOutList, KWsdlNsUri, KInput);
+ else
+ operation->ElementsL(operationInOutList, KWsdlNsUri, KOutput);
+
+ CleanupClosePushL(operationInOutList);
+ TInt operationInOutListCount = operationInOutList.Count();
+ for(TInt j = 0; j< operationInOutListCount; j++)
+ {
+ //should be only one, no more then one input.
+ //if there are then weired but the fucntion will return on first instance of input/output
+ CSenElement* inputoutput = operationInOutList[j];
+ if(inputoutput)
+ {
+ CleanupStack::PopAndDestroy(&operationInOutList);
+ CleanupStack::PopAndDestroy(&operationList);
+ return GetPolicyReferenceL(inputoutput);
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(&operationInOutList);
+ CleanupStack::PopAndDestroy(&operationList);
+ return NULL;
+ }
+ }
+ CleanupStack::PopAndDestroy(&operationInOutList);
+ }
+ }
+ CleanupStack::PopAndDestroy(&operationList);
+ return NULL;
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetPolicyReferenceL(CSenElement* aElement)
+ {
+ RPointerArray<CSenElement> policyRef; //find the policyReference from input child aElement
+ aElement->ElementsL(policyRef, KWspNsUri, KWspPolicyReference);
+ //now we have PolicyReference tag in our PolicyRef List
+ //get its URI and get teh hell out of here
+ CleanupClosePushL(policyRef);
+ //there shud be only ONE count here otherwise seems to me a problem
+ TInt count = policyRef.Count();
+ for(TInt i = 0; i< count; i++)
+ {
+ CSenElement* policyReference = policyRef[i];
+ TPtrC8 policyUri = GetAttributeValueL(KUri, policyReference);
+ //may be only uri is enough at the moment.
+ CSenElement* resultPolicy = GetPolicyL(policyUri);
+ if(resultPolicy) //it should exist
+ {
+ CleanupStack::PopAndDestroy(&policyRef);
+ return resultPolicy;
+ }
+ }
+ CleanupStack::PopAndDestroy(&policyRef);
+ return NULL;
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetPolicyL(const TDesC8& aUri)
+ {
+ //only take an input URI and return corresponding policy Element from wsdl file
+ if(aUri.Length() < 1)
+ return NULL;
+
+ TPtrC8 reqPolicy = aUri.Right(aUri.Length()-1);
+
+ RPointerArray<CSenElement> policyList; //get the wsp:policy elements
+ iPolicy->ElementsL(policyList, KWspNsUri, KPolicy);
+ CleanupClosePushL(policyList);
+ TInt policyListcount = policyList.Count();
+
+ CSenElement* requiredPolicy;
+ for (TInt j = 0; j< policyListcount; j++)
+ {
+ requiredPolicy = policyList[j];
+ if(requiredPolicy)
+ {
+ TPtrC8 policyId = GetAttributeValueL(KWsuId, requiredPolicy);
+ if(policyId.Compare(reqPolicy) == 0)
+ {
+ CleanupStack::PopAndDestroy(&policyList);
+ return requiredPolicy;
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy(&policyList);
+ return NULL;
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetServiceElementL(const TDesC8& aServiceName)
+ {
+ return GetElementL(aServiceName, KService);
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetPortElementL(const TDesC8& aPortName, CSenElement* aElement)
+ {
+ return GetElementL(aPortName, KPort, aElement);
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetPortTypeElementL(const TDesC8& aPortTypeName)
+ {
+ return GetElementL(aPortTypeName, KPortType);
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetBindingElementL(const TDesC8& aBindingName)
+ {
+ return GetElementL(aBindingName, KBinding);
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetMessageElementL(const TDesC8& aMessageName)
+ {
+ return GetElementL(aMessageName, KMessage);
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetElementL(const TDesC8& aName, const TDesC8& aType)
+ {
+ RPointerArray<CSenElement> list;
+ //get the wsdl:definitions child elements with aType name
+ iPolicy->ElementsL(list, KWsdlNsUri, aType);
+ CleanupClosePushL(list);
+ TInt count = list.Count();
+ CSenElement* ele = NULL;
+ for (TInt j = 0; j< count; j++)
+ {
+ ele = list[j];
+ TPtrC8 localName = ele->LocalName();
+ TPtrC8 name = GetAttributeValueL(KName, ele);
+ if(name.Compare(aName) == 0) //We got the right name
+ {
+ CleanupStack::PopAndDestroy(&list);
+ return ele;
+ }
+ ele = NULL;
+ }
+ CleanupStack::PopAndDestroy(&list);
+ return NULL;
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetElementL(const TDesC8& aName, const TDesC8& aType, CSenElement* aElement)
+ {
+ RPointerArray<CSenElement> list; //get the wsdl:definitions child elements with aType name
+ aElement->ElementsL(list, KWsdlNsUri, aType);
+ CleanupClosePushL(list);
+
+ TInt count = list.Count();
+ CSenElement* ele = NULL;
+ for (TInt j = 0; j< count; j++)
+ {
+ ele = list[j];
+ TPtrC8 localName = ele->LocalName();
+
+ TPtrC8 name = GetAttributeValueL(KName, ele);
+ if(name.Compare(aName) == 0) //We got the right name
+ {
+ CleanupStack::PopAndDestroy(&list);
+ return ele;
+ }
+ ele = NULL;
+ }
+ CleanupStack::PopAndDestroy(&list);
+ return NULL;
+ }
+
+CWSPolicy* CWsdlPolicyAttachment::GetPolicyToSenL(CPolicyAssertion* aPolicy)
+ {
+ _LIT8(KN, "name");
+ TPtrC8 nimi(KN);
+ CWSPolicyWriter* iWriter = CWSPolicyWriter::NewLC();
+ CWSPolicy* policy = NULL;
+ if(aPolicy)
+ {
+ CBufFlat *pBuf = CBufFlat::NewL(128);
+ CleanupStack::PushL(pBuf);
+ TPtrC8 p = iWriter->WriteToBufL(*pBuf, aPolicy);
+ policy = CWSPolicy::NewL(nimi, p);
+ if(policy)
+ policy->NormalizePolicyL(NULL);
+
+ CleanupStack::PopAndDestroy(pBuf);
+ }
+ CleanupStack::PopAndDestroy(iWriter);
+ return policy;
+ }
+
+CPolicyAssertion* CWsdlPolicyAttachment::GetSenToPolicyL(CSenElement* aPolicy, CPolicyRegistry* aReg)
+ {
+ CWSPolicyReader* iReader = CWSPolicyReader::NewLC();
+ CPolicyAssertion* policyTerm = iReader->GetPolicyL(aPolicy);
+ CPolicyAssertion* policy = NULL;
+ if(policyTerm)
+ {
+ CleanupStack::PushL(policyTerm);
+ policy = (CPolicyAssertion*)policyTerm->NormalizeL(aReg);
+ CleanupStack::PopAndDestroy(policyTerm);
+ }
+ CleanupStack::PopAndDestroy(iReader);
+ return policy;
+ }
+
+CWSPolicy* CWsdlPolicyAttachment::GetEffectivePolicyL(RPointerArray<CSenElement>& aPolicyArray, CPolicyRegistry* aReg)
+ {
+ TInt count = aPolicyArray.Count();
+
+
+ CPolicyAssertion* policyTerm = NULL;
+ CPolicyAssertion* policyTerm2 = NULL;
+ CSenElement* policy = NULL;
+
+ for(TInt i = 0; i< count; i++)
+ {
+ policy = aPolicyArray[i];
+ if(policy && policy->LocalName().Compare(WSPolicy::KWsPolicy) == 0)
+ {
+ policyTerm2 = GetSenToPolicyL(policy, aReg);
+
+ if(policyTerm == NULL)
+ {
+ policyTerm = policyTerm2;
+ }
+ else
+ {
+ CleanupStack::PushL(policyTerm);
+ CleanupStack::PushL(policyTerm2);
+ CPolicyAssertion* temp = (CPolicyAssertion*)policyTerm->MergeL(policyTerm2, NULL);
+ CleanupStack::PopAndDestroy(policyTerm2);
+ CleanupStack::PopAndDestroy(policyTerm);
+ policyTerm = temp;
+ }
+ }
+ }
+
+ if (policyTerm && !policyTerm->IsNormalized())
+ {
+ CleanupStack::PushL(policyTerm);
+ CPolicyAssertion* temp = (CPolicyAssertion*) policyTerm->NormalizeL();
+ CleanupStack::PopAndDestroy(policyTerm);
+ policyTerm = temp;
+ }
+ return GetPolicyToSenL(policyTerm);
+ }
+
+CSenElement* CWsdlPolicyAttachment::GetEffectivePolicyL(const TDesC8& /*aUri*/)
+ {
+ // will be a merged from all policies
+ // input should be array of URIs or array of CSenElement*::PolicyElements
+ return NULL;
+ }
+
+// END OF FILE
+
+