--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsstar/wsstarplugin/src/wsstarpolicy.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,689 @@
+/*
+* Copyright (c) 2006-2006 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 "wsstarpolicy.h"
+#include "wsstarpolicyhandler.h"
+#include "wsstarcons.h"
+
+namespace
+{
+ _LIT8(KServicePolicyLocalName, "ServicePolicy");
+ _LIT8(KClientServicePolicyLocalName, "ClientPolicy");
+ _LIT8(KSenNsUri, "urn:com.nokia.Sen.config.1.0");
+
+ _LIT8(KHeader, "Header");
+ _LIT8(KBody, "Body");
+ _LIT8(KNamespace, "Namespace");
+}
+/*
+
+CWSStarPolicy* CWSStarPolicy::NewL()
+{
+ CWSStarPolicy* pSelf =
+ CWSStarPolicy::NewLC();
+ CleanupStack::Pop(pSelf);
+ return pSelf;
+}
+CWSStarPolicy* CWSStarPolicy::NewLC()
+{
+ CWSStarPolicy* pSelf =
+ new (ELeave) CWSStarPolicy();
+ CleanupStack::PushL(pSelf);
+ pSelf->ConstructL();
+ return pSelf;
+}
+CWSStarPolicy::~CWSStarPolicy()
+{
+
+}
+CWSStarPolicy::CWSStarPolicy()
+{
+
+}
+void CWSStarPolicy::ConstructL()
+{
+}
+
+
+void CWSStarPolicy::SetPolicy(CSenElement* aPolicy)
+{
+}
+
+*/
+CSenElement* CWSStarPolicy::GetPolicyL(MSenHandlerContext& aCtx, MSenServiceDescription* aSD) //codescannerwarnings
+{
+
+ CWSStarPlugin* SIF = (CWSStarPlugin*)aCtx.GetAnyL(HandlerContextKey::KSIF());//codescannerwarnings
+ if(SIF)
+ {
+ CSenSessionHandler* pPolicyHandler = (CSenSessionHandler*)SIF->Handler(WSStarConfig::KPolicyValue);
+ if(pPolicyHandler)
+ {
+ CWSStarPolicyHandler* pHandler = (CWSStarPolicyHandler*)pPolicyHandler;
+ if( pHandler )
+ {
+ TPtrC8 contract(KWSStarSTSContract());
+ return pHandler->PolicyL(aSD); //codescannerwarnings
+ }
+ }
+ }
+ return NULL;
+}
+
+TPtrC8 CWSStarPolicy::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();
+}
+
+TPtrC8 CWSStarPolicy::GetNSPrefixL(const TDesC8& aNamespaceUri, CSenElement* aElement)
+{
+ RPointerArray<CSenNamespace> sourceNamespaces = aElement->NamespacesL();
+ if (sourceNamespaces.Count() > 0)
+ {
+ for (TInt i=0;i<sourceNamespaces.Count(); i++)
+ {
+ CSenNamespace* pNamespace = sourceNamespaces[i];
+ if(pNamespace->URI().Compare(aNamespaceUri) == 0)
+ {
+ return pNamespace->Prefix();
+ }
+ }
+ }
+
+ return KNullDesC8();
+}
+TInt CWSStarPolicy::ChildCountL(CSenElement* aTerm) //codescannerwarnings
+{
+ RPointerArray<CSenElement>& children = aTerm->ElementsL();
+
+ TInt childCount = children.Count();
+ return childCount;
+
+}
+TBool CWSStarPolicy::CheckPolicyValueL(const TDesC8& aKey, MSenServiceDescription* aSD)
+ {
+
+ CSenWSDescription* pSD = (CSenWSDescription*)aSD;
+// CSenElement* pServicePolicy = pSD->AsElement().Element(KServicePolicyLocalName);
+ MSenServicePolicy* pServicePolicy = pSD->ServicePolicy();
+ // Cant be possible :p
+ if(!pServicePolicy)
+ return EFalse;
+
+// CSenElement* pClientPolicy = pServicePolicy->Element(KClientServicePolicyLocalName);
+ CSenElement* pClientPolicy = pServicePolicy->ClientPolicy();
+/*
+ if(!pClientPolicy)
+ {
+ pClientPolicy = pServicePolicy->Element(KSenNsUri, KClientServicePolicyLocalName);
+ }
+ */
+ //now start worrying
+ if(!pClientPolicy)
+ return EFalse;
+
+ if(pClientPolicy)
+ {
+ CSenElement* result = NULL;
+ result = pClientPolicy->Element(aKey);
+ if(result)
+ return ETrue;
+ else
+ return EFalse;
+ }
+
+ return EFalse;
+ }
+HBufC8* CWSStarPolicy::GetPolicyValueL(const TDesC8& aKey, MSenServiceDescription* aSD)
+ {
+
+ CSenWSDescription* pSD = (CSenWSDescription*)aSD;
+ CSenElement* pServicePolicy = pSD->AsElement().Element(KServicePolicyLocalName);
+ HBufC8* value = NULL;
+ // Cant be possible :p
+ if(!pServicePolicy)
+ return value;
+ CSenElement* pClientPolicy = pServicePolicy->Element(KClientServicePolicyLocalName);
+ if(!pClientPolicy)
+ {
+ pClientPolicy = pServicePolicy->Element(KSenNsUri, KClientServicePolicyLocalName);
+ }
+ //now start worrying
+ if(!pClientPolicy)
+ return value;
+
+ if(pClientPolicy)
+ {
+ CSenElement* result = NULL;
+ result = pClientPolicy->Element(aKey);
+ if(result && result->HasContent())
+ {
+ value = result->Content().AllocL();
+ }
+ }
+ return value;
+ }
+TInt CWSStarPolicy::SearchForElementsL(CSenElement* aPolicy, TPtrC8 aKey, RPointerArray<CSenElement>& aElements)
+{
+ RPointerArray<CSenElement>& children = aPolicy->ElementsL();
+ TInt count(children.Count());
+ CSenElement* req = NULL;
+ CSenElement* result = NULL;
+ for (TInt i = 0; i < count; i++)
+ {
+ req = children[i];
+ TPtrC8 nimi = req->LocalName();
+ if(nimi.Compare(aKey) == 0)
+ {
+ result = req;
+ aElements.Append(result);
+ }
+
+ if(!result)
+ SearchForElementsL(req, aKey, aElements);
+// if (result)
+// break;
+ }
+
+ return aElements.Count();
+
+}
+CSenElement* CWSStarPolicy::SearchForElementL(CSenElement* aPolicy, TPtrC8 aKey) //codescannerwarnings
+{
+
+ RPointerArray<CSenElement>& children = aPolicy->ElementsL();
+ TInt count(children.Count());
+ CSenElement* req = NULL;
+ CSenElement* result = NULL;
+ for (TInt i = 0; i < count; i++)
+ {
+ req = children[i];
+ TPtrC8 nimi = req->LocalName();
+ if(nimi.Compare(aKey) == 0)
+ {
+ result = req;
+ }
+ if(!result)
+ result = SearchForElementL(req, aKey); //codescannerwarnings
+ if (result)
+ break;
+ }
+
+ return result;
+}
+
+HBufC8* CWSStarPolicy::GetPolicyValueL(const TDesC8& aKey, const TDesC8& aSubKey, CWSStarPlugin& aWSStarPlugin, MSenServiceDescription* aSD)
+ {
+ HBufC8* result = NULL;
+ CSenElement* policy = NULL;
+
+ CSenSessionHandler* pPolicyHandler = (CSenSessionHandler*)(aWSStarPlugin.Handler(WSStarConfig::KPolicyValue()));
+ if(pPolicyHandler)
+ {
+ CWSStarPolicyHandler* phand = (CWSStarPolicyHandler*)pPolicyHandler;
+ if(phand)
+ {
+ TPtrC8 contract(KWSStarSTSContract());
+ policy = phand->PolicyL(aSD); //Policy(aSD); //codescannerwarnings
+
+ }
+
+ }
+ if(policy)
+ {
+ CSenElement* token = SearchForElementL(policy, aKey); //codescannerwarnings
+ CSenElement* subValue = NULL;
+ if(token)
+ {
+ if(aSubKey.Length() > 0)
+ subValue = SearchForElementL(token, aSubKey); //codescannerwarnings
+ else
+ subValue = token;
+
+ if(subValue)
+ {
+ if(ChildCountL(subValue) > 0) //codescannerwarnings
+ {
+ //not supprted now
+ }
+ if(subValue->HasContent())
+ {
+ result = subValue->Content().AllocL();
+ }
+ }
+ }
+ }
+ return result;
+ }
+HBufC8* CWSStarPolicy::GetPolicyValueL(const TDesC8& aKey, const TDesC8& aSubKey, MSenHandlerContext& aCtx, MSenServiceDescription* aSD)
+ {
+ RPointerArray<CSenElement> aElements;
+ return GetPolicyValueL(aKey, aSubKey, aCtx, aSD, aElements);
+ }
+HBufC8* CWSStarPolicy::GetPolicyValueL(const TDesC8& aTokenType, const TDesC8& aKey, const TDesC8& aSubKey, MSenHandlerContext& aCtx, MSenServiceDescription* aSD)
+ {
+ RPointerArray<CSenElement> aElements;
+ return GetPolicyValueL(aTokenType, aKey, aSubKey, aCtx, aSD, aElements);
+ }
+HBufC8* CWSStarPolicy::GetPolicyValueL(const TDesC8& aTokenType, const TDesC8& aKey, const TDesC8& aSubKey, MSenHandlerContext& aCtx, MSenServiceDescription* aSD, RPointerArray<CSenElement>& aElements)
+{
+ HBufC8* result = NULL;
+ CSenElement* policy = GetPolicyL(aCtx, aSD); //codescannerwarnings
+ if(policy)
+ {
+ RPointerArray<CSenElement> elements;
+ CleanupClosePushL(elements);
+
+ TInt count = SearchForElementsL(policy, aKey, elements);
+
+ for (TInt i = 0; i< count; i++)
+ {
+
+ CSenElement* token = elements[i];
+ CSenElement* ele = SearchForElementL(token, _L8("TokenType")); //codescannerwarnings
+ if(ele)
+ {
+ if(ele->HasContent())
+ {
+ TPtrC8 contents = ele->Content();
+ if(contents == aTokenType)
+ {
+ CSenElement* subValue = NULL;
+ if(token)
+ {
+ if(aSubKey.Length() > 0)
+ subValue = SearchForElementL(token, aSubKey); //codescannerwarnings
+ else
+ subValue = token;
+
+ if(subValue)
+ {
+ if(ChildCountL(subValue) > 0) //codescannerwarnings
+ {
+ // All of the elements
+ aElements = subValue->ElementsL();
+ //OuterXML
+ HBufC8* data = subValue->AsXmlL();
+ if(data && data->Length() > 0)
+ {//parse the tag name and return the child tags only
+ TInt start = data->Locate('>');
+ TInt end = data->LocateReverse('<');
+ if(start+1 < end-1 && start != KErrNotFound && end != KErrNotFound)
+ {
+ TInt length = end-1-start;
+ TPtrC8 dataq(data->Mid(start+1,length));
+ result = HBufC8::NewL(dataq.Length());
+ TPtr8 id16 = result->Des();
+ id16.Copy(dataq);
+ }
+
+ }
+ delete data;
+ }
+ else if(subValue->HasContent())
+ {
+ result = subValue->Content().AllocL();
+ }
+
+ }
+ }
+
+
+
+ }
+ }
+ }
+
+ }
+ CleanupStack::Pop(&elements);
+ elements.Close();
+ }
+
+ return result;
+
+}
+HBufC8* CWSStarPolicy::GetPolicyValueL(const TDesC8& aKey, const TDesC8& aSubKey, MSenHandlerContext& aCtx, MSenServiceDescription* aSD, RPointerArray<CSenElement>& aElements)
+{
+ HBufC8* result = NULL;
+ CSenElement* policy = GetPolicyL(aCtx, aSD); //codescannerwarnings
+ if(policy)
+ {
+ CSenElement* token = SearchForElementL(policy, aKey); //codescannerwarnings
+ CSenElement* subValue = NULL;
+ if(token)
+ {
+ if(aSubKey.Length() > 0)
+ subValue = SearchForElementL(token, aSubKey); //codescannerwarnings
+ else
+ subValue = token;
+
+ if(subValue)
+ {
+ if(ChildCountL(subValue) > 0) //codescannerwarnings
+ {
+ // All of the elements
+ aElements = subValue->ElementsL();
+ //OuterXML
+ HBufC8* data = subValue->AsXmlL();
+ if(data && data->Length() > 0)
+ {//parse the tag name and return the child tags only
+ TInt start = data->Locate('>');
+ TInt end = data->LocateReverse('<');
+ if(start+1 < end-1 && start != KErrNotFound && end != KErrNotFound)
+ {
+ TInt length = end-1-start;
+ TPtrC8 dataq(data->Mid(start+1,length));
+ result = HBufC8::NewL(dataq.Length());
+ TPtr8 id16 = result->Des();
+ id16.Copy(dataq);
+ }
+
+ }
+ delete data;
+ }
+ else if(subValue->HasContent())
+ {
+ result = subValue->Content().AllocL();
+ }
+
+ }
+ }
+
+ }
+
+ return result;
+}
+
+void CWSStarPolicy::GetPolicyValueL(const TDesC8& aKey, const TDesC8& aSubKey,MSenServiceDescription* aSD,RPointerArray<CSenElement>& aElements)
+ {
+
+ CSenWSDescription* pSD = (CSenWSDescription*)aSD;
+ CSenElement* pServicePolicy = pSD->AsElement().Element(KServicePolicyLocalName);
+
+ // Cant be possible :p
+ if(!pServicePolicy)
+ return;
+ CSenElement* pClientPolicy = pServicePolicy->Element(KClientServicePolicyLocalName);
+ if(!pClientPolicy)
+ {
+ pClientPolicy = pServicePolicy->Element(KSenNsUri, KClientServicePolicyLocalName);
+ }
+ //now start worrying
+ if(!pClientPolicy)
+ return;
+
+ if(pClientPolicy)
+ {
+ CSenElement* resultKey = NULL;
+ resultKey = pClientPolicy->Element(aKey);
+ if(resultKey)
+ {
+ CSenElement* resultSubKey = NULL;
+ resultSubKey = resultKey->Element(aSubKey);
+
+ if(resultSubKey)
+ {
+ aElements = resultSubKey->ElementsL();
+
+ }
+
+ }
+
+ }
+ return;
+ }
+void CWSStarPolicy::GetPolicyValueL(const TDesC8& aKey, const TDesC8& aSubKey, MSenHandlerContext& aCtx, MSenServiceDescription* aSD, RPointerArray<HBufC8>& aList)
+ {
+ CSenElement* policy = GetPolicyL(aCtx, aSD); //codescannerwarnings
+ if (policy)
+ {
+ GetValueL(aKey, aSubKey, policy, aList);
+ }
+ }
+void CWSStarPolicy::GetPolicyValueL(const TDesC8& aKey, const TDesC8& aSubKey, CWSStarPolicyHandler* aPolicyHandler, MSenServiceDescription* aSD, RPointerArray<HBufC8>& aList)
+ {
+ CSenElement* policy = aPolicyHandler->PolicyL(aSD); //codescannerwarnings
+ if (policy)
+ {
+ GetValueL(aKey, aSubKey, policy, aList);
+ }
+ /*if (aList.Count() == 0 && aKey == WSPolicy::KSignedParts)
+ {
+ aList.ResetAndDestroy();
+ aList.Append(_L8("MessageID").AllocL());
+ aList.Append(_L8("http://schemas.xmlsoap.org/ws/2004/08/addressing").AllocL());
+ aList.Append(_L8("ReplyTo").AllocL());
+ aList.Append(_L8("http://schemas.xmlsoap.org/ws/2004/08/addressing").AllocL());
+ aList.Append(_L8("To").AllocL());
+ aList.Append(_L8("http://schemas.xmlsoap.org/ws/2004/08/addressing").AllocL());
+ aList.Append(_L8("Action").AllocL());
+ aList.Append(_L8("http://schemas.xmlsoap.org/ws/2004/08/addressing").AllocL());
+ aList.Append(_L8("Timestamp").AllocL());
+ aList.Append(_L8("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd").AllocL());
+ }*/
+ }
+
+void CWSStarPolicy::GetValueL(const TDesC8& aKey, const TDesC8& aSubKey, CSenElement* aPolicy, RPointerArray<HBufC8>& aList)
+ {
+ CSenElement* token = SearchForElementL(aPolicy, aKey); //codescannerwarnings
+ CSenElement* subValue = NULL;
+ if(token)
+ {
+ if(aSubKey.Length() > 0)
+ subValue = SearchForElementL(token, aSubKey); //codescannerwarnings
+ else
+ subValue = token;
+
+ if(subValue)
+ {
+ if(aKey == WSPolicy::KSignedParts || aSubKey == WSPolicy::KSignedParts)
+ {
+ CEncryptedSignedPartsI* signedParts = CEncryptedSignedPartsI::NewL(subValue);
+ if(signedParts->Header() || signedParts->Body())
+ {
+ //return the list of elements to be signed or Enrypted
+ //If Body element is found in list then whole body should be signed/encrypted
+ //If Header Element is found then All headers should be signed/encrypted
+ //If individual elements are found then only those elements
+ // in Header should be signed/encrypted
+ signedParts->ElementsL(aList); //codescannerwarnings
+
+ }
+ delete signedParts;
+ }
+ }
+ }
+ }
+CSenElement* CWSStarPolicy::GetElementL(const TDesC8& aKey, const TDesC8& aSubKey, MSenHandlerContext& aCtx, MSenServiceDescription* aSD)
+{
+ CSenElement* policy = GetPolicyL(aCtx, aSD); //codescannerwarnings
+ if(policy)
+ {
+ CSenElement* token = SearchForElementL(policy, aKey); //codescannerwarnings
+ CSenElement* subValue = NULL;
+ if(token)
+ {
+ if(aSubKey.Length() > 0)
+ subValue = SearchForElementL(token, aSubKey); //codescannerwarnings
+ else
+ subValue = token;
+
+ if(subValue)
+ {
+ if(aKey == WSPolicy::KDictionaries || aSubKey == WSPolicy::KDictionary)
+ {
+ return subValue;
+ }
+ }
+ }
+
+ }
+ return NULL;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+////// CEncryptedSignedPartsI
+///////////////////////////////////////////////////////////////////////
+CEncryptedSignedPartsI* CEncryptedSignedPartsI::NewL(CSenElement* aAssertion)
+{
+ CEncryptedSignedPartsI* pSelf = CEncryptedSignedPartsI::NewLC(aAssertion);
+ CleanupStack::Pop(pSelf);
+ return pSelf;
+}
+
+CEncryptedSignedPartsI* CEncryptedSignedPartsI::NewLC(CSenElement* aAssertion)
+{
+
+ CEncryptedSignedPartsI* pSelf = new (ELeave) CEncryptedSignedPartsI();
+ CleanupStack::PushL(pSelf);
+ pSelf->ConstructL(aAssertion);
+ return pSelf;
+}
+CEncryptedSignedPartsI::~CEncryptedSignedPartsI()
+{
+ iHeaders.Close();
+}
+
+TBool CEncryptedSignedPartsI::IsEqualEncryptedSignedParts(CEncryptedSignedPartsI* aAssertion)
+{
+ if(Body() == aAssertion->Body() && Header() == aAssertion->Header())
+ {
+ return ETrue;
+ }
+
+ return EFalse;
+}
+
+TBool CEncryptedSignedPartsI::Header()
+{
+ return iHeader;
+}
+TBool CEncryptedSignedPartsI::Body()
+{
+ return iBody;
+}
+void CEncryptedSignedPartsI::ElementsL(RPointerArray<HBufC8>& aElements) //codescannerwarnings
+{
+ if(iBody)
+ {
+ aElements.Append(KBody().AllocL());
+ aElements.Append(KNullDesC8().AllocL());
+ }
+
+ if(iHeader && iHeaders.Count() == 0)
+ {
+ aElements.Append(KHeader().AllocL());
+ }
+ else if(iHeader && iHeaders.Count() > 0)
+ {
+ for(TInt i = 0; i< iHeaders.Count(); i++)
+ {
+ SoapHeader header(iHeaders[i]);
+ TPtrC8 name(header.iName);
+ if(name != KNullDesC8())
+ {
+ aElements.Append(name.AllocL());
+ aElements.Append(header.iNsUri.AllocL());
+ }
+
+ }
+ }
+}
+void CEncryptedSignedPartsI::ConstructL(CSenElement* aAssertion)
+{
+//No need to rip off caz there wont be any policy elements here
+
+ RPointerArray<CSenElement>& tokenChildren = aAssertion->ElementsL(); //find the policy element
+
+ if(tokenChildren.Count() < 0)
+ {
+ iHeader = ETrue;
+ iBody = ETrue;
+ return;
+ }
+
+ CSenElement* child = NULL;
+ SoapHeader header;
+ for (TInt i = 0; i< tokenChildren.Count(); i++) //while (tokenChildren.HasNext()) // Get all the elements
+ {
+ child = tokenChildren[i];
+
+ TPtrC8 localName = child->LocalName();
+
+ if(localName.Compare(KBody) == 0)
+ {
+ iBody = ETrue;
+ }
+ else if(localName.Compare(KHeader) == 0)
+ {
+ iHeader = ETrue;
+ //get header attributes
+
+ TPtrC8 headerName = CWSStarPolicy::GetAttributeValueL(WSPolicy::KName, child);
+ if(headerName != KNullDesC8())
+ {
+
+ header.iName.Set(headerName);
+ }
+
+ TPtrC8 nsUri = CWSStarPolicy::GetAttributeValueL(KNamespace, child);
+ //if(nsUri != KNullDesC8())
+ //{
+ header.iNsUri.Set(nsUri);
+ // header.iNsPrefix.Set(CWSStarPolicy::GetNSPrefixL(nsUri, child));
+ //}
+ iHeaders.Append(header);
+
+ }
+ }
+}
+CEncryptedSignedPartsI::CEncryptedSignedPartsI()
+:
+ iHeader(EFalse),
+ iBody(EFalse)
+{
+
+}
+// End of file