diff -r 000000000000 -r 62f9d29f7211 webservices/wsdescription/src/servicepolicy.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsdescription/src/servicepolicy.cpp	Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,819 @@
+/*
+* Copyright (c) 2002-2005 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 FILES
+#include <e32std.h>
+#include <s32strm.h>
+#include "sendebug.h"                 // internal Utils\inc - logging MACROs
+
+#include <SenElement.h>
+#include <SenXmlUtils.h>
+#include "SenXmlElement.h"
+#include "servicepolicy.h"
+#include "SenIdentityProviderIdArray8.h"
+#include "senguidgen.h"
+#include "senlogger.h"
+	
+namespace
+    {
+    _LIT8(KServicePolicyLocalName, "ServicePolicy");
+    _LIT8(KClientServicePolicyLocalName, "ClientPolicy");
+    _LIT8(KPolicyArrayLocalName, "PolicyArray");
+    _LIT8(KMetaDataLocalName, "MetadataEndpoint");
+    _LIT8(KName, "Name");
+    _LIT8(KSenNsUri, "urn:com.nokia.Sen.config.1.0");
+    _LIT8(KPolicyLocalName, "Policy");
+    _LIT8(KWsPolicyNsUri , "http://schemas.xmlsoap.org/ws/2004/09/policy"); // Namespace of WS-Policy
+    _LIT8(KId, "wsu:Id"); 
+	_LIT8(KWsuPrefix, "wsu"); 
+	_LIT8(KWsuNsUri, "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wsswssecurity-utility-1.0.xsd");
+    _LIT8(KAppInfoLocalName, "AppInfo");
+    _LIT8(KApplicationLocalName, "Application");
+    _LIT8(KDeviceOptionsLocalName, "DeviceOptions");
+    _LIT8(KUserAgentLocalName, "UserAgent");
+    _LIT8(KOSLocalName, "OS");
+    //_LIT8(KAppInfoNsUri , "http://schemas.live.com/mws/2006/10/core");
+    }
+
+
+CServicePolicy* CServicePolicy::NewL()
+    {
+    CServicePolicy* pNew = NewLC();
+    CleanupStack::Pop();
+    return(pNew) ;
+    }
+
+CServicePolicy* CServicePolicy::NewLC()
+    {
+    CServicePolicy* pNew = new (ELeave) CServicePolicy();
+    CleanupStack::PushL(pNew);
+    pNew->BaseConstructL(KServicePolicyLocalName());
+    return pNew;
+    }
+
+CServicePolicy::CServicePolicy()
+    {
+    }
+
+CServicePolicy::~CServicePolicy()
+    {
+    TLSLOG_CLOSE(KSenServConnLogChannelBase);
+    //LOG_CLOSE;
+    }
+
+void CServicePolicy::BaseConstructL(const TDesC8& aPolicyLocalName)
+    {
+    CSenBaseFragment::BaseConstructL(aPolicyLocalName);
+#ifdef _SENDEBUG    
+    _LIT(KSenServConn, "SenServicePolicy");
+    _LIT(KSenServConnLog, "SenServicePolicy.log");
+    
+    
+    // Open connection to the file logger server
+    TLSLOG_OPEN(KSenServConnLogChannelBase,KSenServConnLogLevel ,KSenServConn,KSenServConnLog);
+    //LOG_CREATELOG((KSenServConn, KSenServConnLog, EFileLoggingModeOverwrite));
+#endif    
+    }
+
+//Do nothing
+TBool CServicePolicy::Accepts(MSenServicePolicy& aPolicyPattern)
+    {
+    TBool retVal(ETrue);
+    TRAPD(err, retVal = AcceptsL(aPolicyPattern));
+    if (err) return EFalse;
+    return retVal;
+    }
+
+//Do nothing
+TBool CServicePolicy::AcceptsL(MSenServicePolicy& /*aPolicyPattern*/)
+    {
+    return ETrue;
+    }
+
+//Return all of the Services polices from SD only <wsp:Policy> tags
+TInt CServicePolicy::ServicePolicies(RPolicyArray& aPolicies)
+    {
+    TInt err( KErrNone );
+    CSenElement* pPolicyArrayElement = AsElement().Element(KPolicyArrayLocalName);
+    if(pPolicyArrayElement)
+        {
+        TRAP( err, aPolicies = pPolicyArrayElement->ElementsL(); ) //, KWsPolicyNsUri, KPolicyLocalName);
+        if(!err && aPolicies.Count() > 0)
+           {
+           return KErrNone;
+           }
+        return KErrNotFound;
+        }
+    return KErrNotFound;        
+    }
+
+//Adding client policy to SD
+TInt CServicePolicy::AddClientPolicyL(CSenElement* aTemplate)
+    {
+    CSenElement* pServicePolicyElement = AsElement().Element(KServicePolicyLocalName);
+    CSenElement* pClientPolicyElement = AsElement().Element(KClientServicePolicyLocalName);
+    
+    if(!pClientPolicyElement)
+        {
+        pClientPolicyElement = AsElement().Element(KSenNsUri, KClientServicePolicyLocalName);
+        if(!pClientPolicyElement)
+            {
+            pClientPolicyElement = &(AsElement().AddElementL(KClientServicePolicyLocalName));  
+            }
+        }
+    
+    if(!pClientPolicyElement->ConsistsOfL(*aTemplate))
+        {
+        RPointerArray<CSenElement> children = aTemplate->ElementsL();
+        for(TInt i = 0; i< children.Count(); i++)
+            {
+                CSenElement* ele = children[i];
+                
+                if(!ele->LocalName().Compare(KAppInfoLocalName))
+                {
+                    AddApplicationInfoElementsL(ele);
+                }
+                else
+                {
+                     CSenElement& added = pClientPolicyElement->AddElementL(ele->LocalName());
+                     
+                    TPtrC8 sourceContent = ele->Content();
+                    if(sourceContent.Length() > 0)
+                        {
+                        added.SetContentL(sourceContent);
+                        }
+                    RPointerArray<CSenBaseAttribute> sourceAttributes = ele->AttributesL();
+                    if (sourceAttributes.Count() > 0)
+                        {
+                        for (TInt i=0;i<sourceAttributes.Count(); i++)
+                            {
+                            CSenBaseAttribute* pBaseAttribute = sourceAttributes[i];
+                            SenXmlUtils::AddAttributeL(added, pBaseAttribute->Name(), pBaseAttribute->Value());
+                            }
+                        }
+                            
+                }
+                
+            }
+        }
+    return KErrNone;
+    }
+void CServicePolicy::AddApplicationInfoElementsL(CSenElement* aApplicationInfoElement)
+    {
+    CSenElement* pClientPolicyElement = AsElement().Element(KClientServicePolicyLocalName);
+    CSenElement* pAppPolicyElement = pClientPolicyElement->Element(KAppInfoLocalName);
+    
+    if(!pAppPolicyElement)
+        {
+        pAppPolicyElement = pClientPolicyElement->Element(KSenNsUri, KAppInfoLocalName);
+        if(!pAppPolicyElement)
+            {
+            pAppPolicyElement = &(pClientPolicyElement->AddElementL(KAppInfoLocalName));  
+            }
+        }
+             
+    TPtrC8 sourceContent = aApplicationInfoElement->Content();
+    if(sourceContent.Length() > 0)
+        {
+        pAppPolicyElement->SetContentL(sourceContent);
+        }
+        
+    RPointerArray<CSenBaseAttribute> sourceAttributes = aApplicationInfoElement->AttributesL();
+    if (sourceAttributes.Count() > 0)
+        {
+        for (TInt i=0;i<sourceAttributes.Count(); i++)
+            {
+            CSenBaseAttribute* pBaseAttribute = sourceAttributes[i];
+            SenXmlUtils::AddAttributeL(*pAppPolicyElement, pBaseAttribute->Name(), pBaseAttribute->Value());
+            }
+        }
+        
+    RPointerArray<CSenElement> children = aApplicationInfoElement->ElementsL();
+    for(TInt i = 0; i< children.Count(); i++)
+        {
+            CSenElement* ele = children[i];
+            
+            if(!ele->LocalName().Compare(KApplicationLocalName))
+            {
+                AddAppicationElementsL(ele);
+            }
+            else if(!ele->LocalName().Compare(KDeviceOptionsLocalName))
+            {
+                AddDeviceElementsL(ele);
+            }
+            else
+            {
+                CSenElement& added = pAppPolicyElement->AddElementL(ele->LocalName());
+                TPtrC8 sourceContent = ele->Content();
+                if(sourceContent.Length() > 0)
+                    {
+                    added.SetContentL(sourceContent);
+                    }
+                RPointerArray<CSenBaseAttribute> sourceAttributes = ele->AttributesL();
+                if (sourceAttributes.Count() > 0)
+                    {
+                    for (TInt i=0;i<sourceAttributes.Count(); i++)
+                        {
+                        CSenBaseAttribute* pBaseAttribute = sourceAttributes[i];
+                        SenXmlUtils::AddAttributeL(added, pBaseAttribute->Name(), pBaseAttribute->Value());
+                        }
+                    }
+            }
+         }
+
+     }
+void CServicePolicy::AddAppicationElementsL(CSenElement* aApplicationElement)
+    {
+    CSenElement* pClientPolicyElement = AsElement().Element(KClientServicePolicyLocalName);
+    CSenElement* pAppInfoPolicyElement = pClientPolicyElement->Element(KAppInfoLocalName);
+    CSenElement* pAppPolicyElement = pAppInfoPolicyElement->Element(KApplicationLocalName);
+    
+    if(!pAppPolicyElement)
+        {
+        pAppPolicyElement = pAppInfoPolicyElement->Element(KSenNsUri, KApplicationLocalName);
+        if(!pAppPolicyElement)
+            {
+            pAppPolicyElement = &(pAppInfoPolicyElement->AddElementL(KApplicationLocalName));  
+            }
+        }
+    TPtrC8 sourceContent = aApplicationElement->Content();
+    if(sourceContent.Length() > 0)
+        {
+        pAppPolicyElement->SetContentL(sourceContent);
+        }
+        
+    RPointerArray<CSenBaseAttribute> sourceAttributes = aApplicationElement->AttributesL();
+    if (sourceAttributes.Count() > 0)
+        {
+        for (TInt i=0;i<sourceAttributes.Count(); i++)
+            {
+            CSenBaseAttribute* pBaseAttribute = sourceAttributes[i];
+            SenXmlUtils::AddAttributeL(*pAppPolicyElement, pBaseAttribute->Name(), pBaseAttribute->Value());
+            }
+        }
+        
+    RPointerArray<CSenNamespace> sourceNamespaces = aApplicationElement->NamespacesL();
+    if (sourceNamespaces.Count() > 0)
+        {
+        for (TInt i=0;i<sourceNamespaces.Count(); i++)
+            {
+            CSenNamespace* pNameSapce = sourceNamespaces[i];
+            pAppPolicyElement->AddNamespaceL(*pNameSapce,ETrue);
+            }
+        }
+        
+    RPointerArray<CSenElement> children = aApplicationElement->ElementsL();
+    for(TInt i = 0; i< children.Count(); i++)
+        {
+            CSenElement* ele = children[i];
+            CSenElement& added = pAppPolicyElement->AddElementL(ele->LocalName());
+             
+          TPtrC8 sourceContent = ele->Content();
+            if(sourceContent.Length() > 0)
+                {
+                added.SetContentL(sourceContent);
+                }
+            RPointerArray<CSenBaseAttribute> sourceAttributes = ele->AttributesL();
+            if (sourceAttributes.Count() > 0)
+                {
+                for (TInt i=0;i<sourceAttributes.Count(); i++)
+                    {
+                    CSenBaseAttribute* pBaseAttribute = sourceAttributes[i];
+                    SenXmlUtils::AddAttributeL(added, pBaseAttribute->Name(), pBaseAttribute->Value());
+                    }
+                }
+             
+        }
+
+     }
+void CServicePolicy::AddDeviceElementsL(CSenElement* aDeviceElement)
+    {
+    CSenElement* pClientPolicyElement = AsElement().Element(KClientServicePolicyLocalName);
+    CSenElement* pAppPolicyElement = pClientPolicyElement->Element(KAppInfoLocalName);
+    CSenElement* pDevicePolicyElement = pAppPolicyElement->Element(KDeviceOptionsLocalName);
+    
+    if(!pDevicePolicyElement)
+        {
+        pDevicePolicyElement = pAppPolicyElement->Element(KSenNsUri, KDeviceOptionsLocalName);
+        if(!pDevicePolicyElement)
+            {
+            pDevicePolicyElement = &(pAppPolicyElement->AddElementL(KDeviceOptionsLocalName));  
+            }
+        }
+            
+    TPtrC8 sourceContent = aDeviceElement->Content();
+    if(sourceContent.Length() > 0)
+        {
+        pDevicePolicyElement->SetContentL(sourceContent);
+        }
+        
+    RPointerArray<CSenBaseAttribute> sourceAttributes = aDeviceElement->AttributesL();
+    if (sourceAttributes.Count() > 0)
+        {
+        for (TInt i=0;i<sourceAttributes.Count(); i++)
+            {
+            CSenBaseAttribute* pBaseAttribute = sourceAttributes[i];
+            SenXmlUtils::AddAttributeL(*pDevicePolicyElement, pBaseAttribute->Name(), pBaseAttribute->Value());
+            }
+        }
+        
+    RPointerArray<CSenNamespace> sourceNamespaces = aDeviceElement->NamespacesL();
+    if (sourceNamespaces.Count() > 0)
+        {
+        for (TInt i=0;i<sourceNamespaces.Count(); i++)
+            {
+            CSenNamespace* pNameSapce = sourceNamespaces[i];
+            pDevicePolicyElement->AddNamespaceL(*pNameSapce,ETrue);
+            }
+        }
+            
+    RPointerArray<CSenElement> children = aDeviceElement->ElementsL();
+    for(TInt i = 0; i< children.Count(); i++)
+        {
+            CSenElement* ele = children[i];
+                    
+            if(!ele->LocalName().Compare(KUserAgentLocalName))
+            {
+                AddUserAgentElementsL(ele);
+            }
+            else
+            {
+
+            CSenElement& added = pDevicePolicyElement->AddElementL(ele->LocalName());
+             
+          TPtrC8 sourceContent = ele->Content();
+            if(sourceContent.Length() > 0)
+                {
+                added.SetContentL(sourceContent);
+                }
+            RPointerArray<CSenBaseAttribute> sourceAttributes = ele->AttributesL();
+            if (sourceAttributes.Count() > 0)
+                {
+                for (TInt i=0;i<sourceAttributes.Count(); i++)
+                    {
+                    CSenBaseAttribute* pBaseAttribute = sourceAttributes[i];
+                    SenXmlUtils::AddAttributeL(added, pBaseAttribute->Name(), pBaseAttribute->Value());
+                    }
+                }
+                
+            } 
+             
+        }
+
+     }
+void CServicePolicy::AddUserAgentElementsL(CSenElement* aUserAgentElement)
+    {
+    CSenElement* pClientPolicyElement = AsElement().Element(KClientServicePolicyLocalName);
+    CSenElement* pAppPolicyElement = pClientPolicyElement->Element(KAppInfoLocalName);
+    CSenElement* pDevicePolicyElement = pAppPolicyElement->Element(KDeviceOptionsLocalName);
+    CSenElement* pUserAgentElement = pDevicePolicyElement->Element(KUserAgentLocalName);
+    
+    if(!pUserAgentElement)
+        {
+        pUserAgentElement = pDevicePolicyElement->Element(KSenNsUri, KUserAgentLocalName);
+        if(!pUserAgentElement)
+            {
+            pUserAgentElement = &(pDevicePolicyElement->AddElementL(KUserAgentLocalName));  
+            }
+        }
+            
+    TPtrC8 sourceContent = aUserAgentElement->Content();
+    if(sourceContent.Length() > 0)
+        {
+        pUserAgentElement->SetContentL(sourceContent);
+        }
+        
+    RPointerArray<CSenBaseAttribute> sourceAttributes = aUserAgentElement->AttributesL();
+    if (sourceAttributes.Count() > 0)
+        {
+        for (TInt i=0;i<sourceAttributes.Count(); i++)
+            {
+            CSenBaseAttribute* pBaseAttribute = sourceAttributes[i];
+            SenXmlUtils::AddAttributeL(*pUserAgentElement, pBaseAttribute->Name(), pBaseAttribute->Value());
+            }
+        }
+        
+    RPointerArray<CSenElement> children = aUserAgentElement->ElementsL();
+    for(TInt i = 0; i< children.Count(); i++)
+        {
+            CSenElement* ele = children[i];
+            
+            if(!ele->LocalName().Compare(KOSLocalName))
+            {
+                AddOSElementsL(ele);
+            }
+            else
+            {
+
+            CSenElement& added = pUserAgentElement->AddElementL(ele->LocalName());
+             
+          TPtrC8 sourceContent = ele->Content();
+            if(sourceContent.Length() > 0)
+                {
+                added.SetContentL(sourceContent);
+                }
+            RPointerArray<CSenBaseAttribute> sourceAttributes = ele->AttributesL();
+            if (sourceAttributes.Count() > 0)
+                {
+                for (TInt i=0;i<sourceAttributes.Count(); i++)
+                    {
+                    CSenBaseAttribute* pBaseAttribute = sourceAttributes[i];
+                    SenXmlUtils::AddAttributeL(added, pBaseAttribute->Name(), pBaseAttribute->Value());
+                    }
+                }
+             
+            } 
+        }
+
+     }
+void CServicePolicy::AddOSElementsL(CSenElement* aOSElement)
+    {
+    CSenElement* pClientPolicyElement = AsElement().Element(KClientServicePolicyLocalName);
+    CSenElement* pAppPolicyElement = pClientPolicyElement->Element(KAppInfoLocalName);
+    CSenElement* pDevicePolicyElement = pAppPolicyElement->Element(KDeviceOptionsLocalName);
+    CSenElement* pUserAgentElement = pDevicePolicyElement->Element(KUserAgentLocalName);
+    CSenElement* pOSElement = pUserAgentElement->Element(KOSLocalName);
+    
+    if(!pOSElement)
+        {
+        pOSElement = pUserAgentElement->Element(KSenNsUri, KOSLocalName);
+        if(!pOSElement)
+            {
+            pOSElement = &(pUserAgentElement->AddElementL(KOSLocalName));  
+            }
+        }
+            
+    TPtrC8 sourceContent = aOSElement->Content();
+    if(sourceContent.Length() > 0)
+        {
+        pOSElement->SetContentL(sourceContent);
+        }
+        
+    RPointerArray<CSenBaseAttribute> sourceAttributes = aOSElement->AttributesL();
+    if (sourceAttributes.Count() > 0)
+        {
+        for (TInt i=0;i<sourceAttributes.Count(); i++)
+            {
+            CSenBaseAttribute* pBaseAttribute = sourceAttributes[i];
+            SenXmlUtils::AddAttributeL(*pOSElement, pBaseAttribute->Name(), pBaseAttribute->Value());
+            }
+        }
+        
+    RPointerArray<CSenElement> children = aOSElement->ElementsL();
+    for(TInt i = 0; i< children.Count(); i++)
+        {
+            CSenElement* ele = children[i];
+            CSenElement& added = pOSElement->AddElementL(ele->LocalName());
+             
+          TPtrC8 sourceContent = ele->Content();
+            if(sourceContent.Length() > 0)
+                {
+                added.SetContentL(sourceContent);
+                }
+            RPointerArray<CSenBaseAttribute> sourceAttributes = ele->AttributesL();
+            if (sourceAttributes.Count() > 0)
+                {
+                for (TInt i=0;i<sourceAttributes.Count(); i++)
+                    {
+                    CSenBaseAttribute* pBaseAttribute = sourceAttributes[i];
+                    SenXmlUtils::AddAttributeL(added, pBaseAttribute->Name(), pBaseAttribute->Value());
+                    }
+                }
+             
+        }
+
+     }
+
+// Public function for adding a policy
+TInt CServicePolicy::AddPolicyL(CSenElement* aPolicy)
+    {
+    TInt retVal(KErrNotFound);
+    retVal = ValidatePolicy(aPolicy);
+    
+#ifdef _SENDEBUG
+    {
+    TLSLOG(KSenServConnLogChannelBase,KMaxLogLevel,(_L("TInt CServicePolicy::AddPolicyL  POLICY")));
+    TLSLOG(KSenServConnLogChannelBase,KMaxLogLevel,(_L("-----------DIRECT ADDING---------------")));
+    TLSLOG(KSenServConnLogChannelBase,KMaxLogLevel,(_L("---------------------------------------")));
+    TLSLOG(KSenServConnLogChannelBase,KMaxLogLevel,(_L("---------------------------------------")));
+    HBufC8* xml = aPolicy->AsXmlL();
+    if(xml)
+        {
+        TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,(*xml));
+
+        }
+        delete xml;
+    }    
+#endif // _SENDEBUG
+
+    if(retVal)
+        {
+        retVal =  AddWspPolicyL(aPolicy); 
+        }
+    return retVal;
+    }
+//Add a policy to SD
+TInt CServicePolicy::AddWspPolicyL(CSenElement* aPolicy)
+    {
+    TInt retVal(KErrNotFound);
+    CSenElement& pServicePolicy = AsElement();
+    CSenElement* pPolicyArray = pServicePolicy.Element(KPolicyArrayLocalName);
+    //get the PolicyArray which is holding all the <wsp:policy> elements
+    if(!pPolicyArray)
+        {
+        pPolicyArray = pServicePolicy.Element(KSenNsUri, KPolicyArrayLocalName);
+        if(!pPolicyArray)
+            pPolicyArray = &(pServicePolicy.AddElementL(KPolicyArrayLocalName));
+        }
+    //get all the policies from <PolicyArray>        
+    RPointerArray<CSenElement> policies;
+    pPolicyArray->ElementsL(policies,KWsPolicyNsUri,KPolicyLocalName);
+    
+    CSenElement* pPolicy = NULL;
+   
+    TInt count(policies.Count());
+    //If we have existing polcies then verify that this new policy doesnt exist there
+    if(count > 0)
+        {    
+        for(TInt i=0; i<count; i++)
+            {
+            pPolicy = policies[i];
+            if(pPolicy)
+                {
+                    if(pPolicy->LocalName().Compare(aPolicy->LocalName()) == 0 &&
+                    (PolicyIdL(pPolicy).Compare(PolicyIdL(aPolicy)) != 0))	//codescannerwarnings
+                        {
+                        //same policy with same wsu:Id then 
+                        // We are trying to add a policy with endpoint same
+                        // it means that our current policy is expired and we have 
+                        // fetched new policy
+                        // we have to delete here old policy and then add new policy
+                            if(PolicyUriL(pPolicy).Compare(PolicyUriL(aPolicy)) == 0)
+                            {
+                                CSenElement* deletedPolicy = pPolicyArray->RemoveElement(*pPolicy);
+                                delete deletedPolicy;
+                            }
+                        //then add fresh policy here
+                        CSenElement& apol= pPolicyArray->AddElementL(KPolicyLocalName);
+                        apol.CopyFromL(*aPolicy);                        
+                        retVal = KErrNone;
+                        policies.Close();
+                        return retVal;
+                        }
+                }
+
+            }
+        }
+    else //Just add this policy in the <PolicyArray>
+        {
+        
+        CSenElement& apol= pPolicyArray->AddElementL(KPolicyLocalName);
+        apol.CopyFromL(*aPolicy);                                
+        PolicyIdL(&apol);	//codescannerwarnings
+        retVal = KErrNone;
+        }
+     
+     policies.Close();
+    return retVal;
+    }
+
+//Remove a policy from current SD
+TInt CServicePolicy::RemovePolicyL(TDesC8& aPolicyUri)
+    {
+    TInt retVal(KErrNone);
+    CSenElement& pServicePolicy = AsElement();
+    CSenElement* pPolicyArray = pServicePolicy.Element(KPolicyArrayLocalName);
+//get the PolicyArray which is holding all the <wsp:policy> elements
+    if(!pPolicyArray)
+        {
+        pPolicyArray = pServicePolicy.Element(KSenNsUri, KPolicyArrayLocalName);
+        if(!pPolicyArray)
+               retVal = KErrNotFound; 
+        }
+    if(retVal == KErrNone)
+		{
+		//get all the policies from <PolicyArray>        
+		RPointerArray<CSenElement> policies;
+		CleanupClosePushL(policies);
+		pPolicyArray->ElementsL(policies,KWsPolicyNsUri,KPolicyLocalName);
+    
+		CSenElement* pPolicy = NULL;
+   
+		TInt count(policies.Count());
+//If we have existing polcies then verify that this new policy doesnt exist there
+		if(count > 0)
+			{    
+			for(TInt i=0; i<count; i++)
+				{
+				pPolicy = policies[i];
+				if(pPolicy)
+					{
+						if(PolicyNameL(pPolicy).Compare(aPolicyUri) == 0)	//codescannerwarnings
+							{
+                        //same policy with same NAME 
+                        CSenElement* removed = pPolicyArray->RemoveElement(*pPolicy);
+                        delete removed;
+                        retVal = KErrNone; 
+							}
+					}
+
+				}
+			}
+		CleanupStack::PopAndDestroy(); // policies
+		}
+    return retVal;
+    }
+
+
+// sets (rebuilds) the Service Policy in SD from template
+// @return  - a error, if at least one addition of new contents has
+// failed OR KerrNone if every property was successfully reset
+TInt CServicePolicy::RebuildServicePolicyFrom(MSenServicePolicy& aTemplate)
+    {
+    TInt retVal(KErrNone);
+    TRAPD(err, retVal = RebuildServicePolicyFromL(aTemplate));
+    if (err != KErrNone)
+        {
+        retVal = err;
+        }
+    return retVal;
+    }
+
+TInt CServicePolicy::RebuildServicePolicyFromL(MSenServicePolicy& /*aTemplate*/)
+    {
+    TInt retVal(KErrNone);
+    // check for possible provider policy definition
+    return retVal;
+    }
+    
+// Returns a Policy ID value. 
+// If the value not found then generate a random 
+// value and assign it to the policy
+TPtrC8 CServicePolicy::PolicyIdL(CSenElement* aPolicy)	//codescannerwarnings
+    {
+    RPointerArray<CSenBaseAttribute>& attrs = aPolicy->AttributesL();
+    CSenBaseAttribute* bs = NULL;
+    TInt ele_count = attrs.Count();
+    for (TInt j=0; j < ele_count; j++)
+        {
+        bs = (attrs)[j];
+        if(bs && bs->Name().Compare(KId) == 0)
+            {
+            return bs->Value();
+            }
+         }
+    // If there is no ID for a policy, then add a random
+    // Policy ID to the policy and put it into Service Description
+    GenerateDeviceIdL(aPolicy);
+    return PolicyIdL(aPolicy);
+    }
+    
+//Generate a random ID
+void CServicePolicy::GenerateDeviceIdL(CSenElement* aPolicy)	//codescannerwarnings
+    {
+
+    CSenGuidGen* pGuidGenerator = CSenGuidGen::NewLC();
+    HBufC8* iPolicyId = pGuidGenerator->GetRandomGuid8LC();
+    TPtr8 policyIdDes = iPolicyId->Des();
+    policyIdDes.LowerCase();
+    
+    aPolicy->AddAttrL(KId, policyIdDes);
+    aPolicy->AddNamespaceL(KWsuPrefix, KWsuNsUri);
+    
+    CleanupStack::PopAndDestroy(iPolicyId);
+    CleanupStack::PopAndDestroy(pGuidGenerator);
+    }
+
+//return Policy atribute Name
+TPtrC8 CServicePolicy::PolicyNameL(CSenElement* aPolicy)		//codescannerwarnings
+    {
+    RPointerArray<CSenBaseAttribute>& attrs = aPolicy->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() == KName)
+            {
+             return bs->Value();
+            }
+         }
+         return NULL;
+    }
+
+TPtrC8 CServicePolicy::PolicyUriL(CSenElement* aPolicy)
+{
+
+    if(aPolicy == NULL) { User::Leave(KErrGeneral); }
+    
+    RPointerArray<CSenBaseAttribute>& attrs = aPolicy->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(KMetaDataLocalName) == 0)
+            {
+                 return bs->Value();
+            }
+         }
+
+            
+        }
+    return KNullDesC8();
+}
+
+TBool CServicePolicy::ValidatePolicy(CSenElement* /*aPolicy*/)
+    {
+    return ETrue;  
+    }
+CSenElement* CServicePolicy::ClientPolicy()
+{
+    CSenElement* pClientPolicyElement = AsElement().Element(KClientServicePolicyLocalName);
+    
+    if(!pClientPolicyElement)
+        {
+        return AsElement().Element(KSenNsUri, KClientServicePolicyLocalName);
+        }
+        
+    return NULL;
+}    
+TBool CServicePolicy::ClientPolicy(const TDesC8& aKey)
+{
+
+    CSenElement* pClientPolicy = ClientPolicy();
+
+    if(!pClientPolicy)
+        return EFalse;
+    
+    if(pClientPolicy)
+    {
+        CSenElement* result = NULL;
+        result = pClientPolicy->Element(aKey);
+        if(result)
+            return ETrue;
+        else
+            return EFalse;
+    }                    
+
+    return EFalse;
+    
+}
+HBufC8* CServicePolicy::ClientPolicyValue(const TDesC8& aKey)
+    {
+    HBufC8* retVal = NULL;        
+    TInt err(KErrNone);
+    CSenElement* pClientPolicy = ClientPolicy();
+    if( pClientPolicy )
+        {
+        CSenElement* result = NULL;
+        result = pClientPolicy->Element(aKey);
+        if( result && result->HasContent() )
+            {
+            TRAP( err, retVal = result->Content().AllocL(); )
+            if( err ) 
+                {
+                retVal = NULL;
+                }
+            }
+        }                    
+    return retVal;
+    }
+/*    
+RFileLogger* CServicePolicy::Log() const 
+    {
+    return (RFileLogger*) &iLog;
+    }    
+*/
+// End of file