diff -r 000000000000 -r 62f9d29f7211 webservices/wsstar/wsstarpolicy/src/WsdlPolicyAttachment.cpp
--- /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
+
+