--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsdescription/src/senpolicy.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,493 @@
+/*
+* 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"
+
+#include <SenElement.h>
+#include <SenXmlUtils.h>
+
+#include "senpolicy.h"
+#include "SenIdentityProviderIdArray8.h"
+
+// ============================ LOCAL FUNCTIONS ===============================
+
+namespace
+ {
+ _LIT8(KPolicyLocalName, "Policy");
+ _LIT8(KTransportLocalName, "Transport");
+ _LIT8(KIapIdLocalName, "IapId");
+ _LIT8(KSnapIdLocalName, "SnapId");
+ _LIT8(KIdentityProviderIDsLocalName, "IdentityProviderIDs");
+ _LIT8(KIdentityProviderIDsStrictAttrName, "strict");
+ _LIT8(KIdentityProviderIDsStrictAttrTrue, "true");
+ _LIT8(KIdentityProviderIDLocalName, "IdentityProviderID");
+ }
+
+
+EXPORT_C CSenPolicy* CSenPolicy::NewL()
+ {
+ CSenPolicy* pNew = NewLC();
+ CleanupStack::Pop();
+ return(pNew) ;
+ }
+
+EXPORT_C CSenPolicy* CSenPolicy::NewLC()
+ {
+ CSenPolicy* pNew = new (ELeave) CSenPolicy;
+ CleanupStack::PushL(pNew);
+ pNew->BaseConstructL(KPolicyLocalName());
+ return pNew;
+ }
+
+
+EXPORT_C CSenPolicy* CSenPolicy::NewL(TUint32 aIapId)
+ {
+ CSenPolicy* pNew = NewLC(aIapId);
+ CleanupStack::Pop();
+ return(pNew) ;
+ }
+
+
+EXPORT_C CSenPolicy* CSenPolicy::NewLC(TUint32 aIapId)
+ {
+ CSenPolicy* pNew = new (ELeave) CSenPolicy;
+ CleanupStack::PushL(pNew);
+ pNew->BaseConstructL(KPolicyLocalName(), aIapId);
+ return pNew;
+ }
+
+EXPORT_C CSenPolicy* CSenPolicy::NewL(TUint32 aId, TBool aIsSnapId)
+ {
+ CSenPolicy* pNew = NewLC(aId, aIsSnapId);
+ CleanupStack::Pop();
+ return(pNew) ;
+ }
+
+
+EXPORT_C CSenPolicy* CSenPolicy::NewLC(TUint32 aId, TBool aIsSnapId)
+ {
+ CSenPolicy* pNew = new (ELeave) CSenPolicy;
+ CleanupStack::PushL(pNew);
+ pNew->BaseConstructL(KPolicyLocalName(), aId, aIsSnapId);
+ return pNew;
+ }
+
+
+CSenPolicy::CSenPolicy()
+: iIdpIdList(NULL)
+ {
+ }
+
+CSenPolicy::~CSenPolicy()
+ {
+ delete iIdpIdList;
+ }
+
+EXPORT_C void CSenPolicy::BaseConstructL(const TDesC8& aPolicyLocalName)
+ {
+ CSenBaseFragment::BaseConstructL(aPolicyLocalName);
+ }
+
+EXPORT_C void CSenPolicy::BaseConstructL(const TDesC8& aPolicyLocalName,
+ TUint32 aIapId)
+ {
+ CSenBaseFragment::BaseConstructL(aPolicyLocalName);
+ SetIapIdL(aIapId);
+ }
+
+EXPORT_C void CSenPolicy::BaseConstructL(const TDesC8& aPolicyLocalName,
+ TUint32 aId, TBool aIsSnapId)
+ {
+ CSenBaseFragment::BaseConstructL(aPolicyLocalName);
+ if (aIsSnapId == EFalse)
+ {
+ SetIapIdL(aId);
+ }
+ else
+ {
+ SetSnapIdL(aId);
+ }
+ }
+
+EXPORT_C TBool CSenPolicy::Accepts(MSenPolicy& aPolicyPattern)
+ {
+ TBool retVal(ETrue);
+ TRAPD(err, retVal = AcceptsL(aPolicyPattern));
+ if (err) return EFalse;
+ return retVal;
+ }
+
+TBool CSenPolicy::AcceptsL(MSenPolicy& aPolicyPattern)
+ {
+ TUint32 thisIapID(0);
+ TUint32 patternIapID(0);
+
+ if(aPolicyPattern.IapId(patternIapID) == KErrNone
+ && (IapId(thisIapID) != KErrNone
+ || patternIapID!=thisIapID))
+ {
+ return EFalse; // policies do NOT match(!)
+ }
+
+ const CSenIdentityProviderIdArray8& patternIdps =
+ aPolicyPattern.IdentityProviderIds8L();
+ if(patternIdps.IsStrict())
+ {
+ const CSenIdentityProviderIdArray8& thisIdps = IdentityProviderIds8L();
+ TInt thisCount(thisIdps.Count());
+ TInt pos(-1);
+ TBool matches(EFalse);
+ for(TInt i=0; i<thisCount; i++)
+ {
+ if(patternIdps.Find(thisIdps[i], pos, ECmpNormal)==KErrNone)
+ {
+ matches = ETrue;
+ break;
+ }
+ }
+ return matches;
+ }
+
+ return ETrue;
+ }
+
+
+// Setter for IAP ID
+EXPORT_C void CSenPolicy::SetIapIdL(TUint32 aIapId)
+ {
+ CSenElement* pTransportElement = AsElement().Element(KTransportLocalName);
+ if(aIapId > 0)
+ {
+ if(!pTransportElement)
+ {
+ pTransportElement = &(AsElement().AddElementL(KTransportLocalName));
+ }
+ CSenElement* pSnapIdElement =
+ pTransportElement->Element(KSnapIdLocalName);
+
+ if(pSnapIdElement)
+ {
+ pSnapIdElement = pTransportElement->RemoveElement(KSnapIdLocalName);
+ }
+ CSenElement* pIapIdElement =
+ pTransportElement->Element(KIapIdLocalName);
+ if(!pIapIdElement)
+ {
+ pIapIdElement = &(pTransportElement->AddElementL(KIapIdLocalName));
+ }
+ TBuf8<128> buf;
+ buf.AppendFormat(_L8("%u"), aIapId);
+ pIapIdElement->SetContentL(buf);
+ }
+ else
+ {
+ if(pTransportElement)
+ {
+ CSenElement* pIapIdElement =
+ pTransportElement->Element(KIapIdLocalName);
+
+ if(pIapIdElement)
+ {
+ pIapIdElement = pTransportElement->RemoveElement(KIapIdLocalName);
+ }
+ }
+ }
+
+
+ }
+
+// Getter for IAP ID
+EXPORT_C TInt CSenPolicy::IapId(TUint32& aCurrentIapId)
+ {
+ CSenElement* pTransportElement = AsElement().Element(KTransportLocalName);
+ if(pTransportElement)
+ {
+ CSenElement* pIapIdElement =
+ pTransportElement->Element(KIapIdLocalName);
+ if(pIapIdElement && pIapIdElement->HasContent())
+ {
+ //SENDEBUG((_L("CSenPolicy::IapIdL: content found")));
+ TPtrC8 content = pIapIdElement->Content();
+ TLex8 lex(content);
+
+ TInt err = lex.Val(aCurrentIapId, EDecimal);
+ return err;
+ }
+ //SENDEBUG((_L("CSenPolicy::IapIdL: <IapId> element not found")));
+ }
+ //SENDEBUG((_L("CSenPolicy::IapIdL: <Transport> element not found")));
+ return KErrNotFound;
+ }
+
+// Setter for SNAP ID
+EXPORT_C void CSenPolicy::SetSnapIdL(TUint32 aSnapId)
+ {
+ if(aSnapId > 0)
+ {
+ CSenElement* pTransportElement = AsElement().Element(KTransportLocalName);
+ if(!pTransportElement)
+ {
+ pTransportElement = &(AsElement().AddElementL(KTransportLocalName));
+ }
+
+ CSenElement* pIapIdElement =
+ pTransportElement->Element(KIapIdLocalName);
+
+ if(pIapIdElement)
+ {
+ pIapIdElement = pTransportElement->RemoveElement(KIapIdLocalName);
+ }
+
+ CSenElement* pSnapIdElement =
+ pTransportElement->Element(KSnapIdLocalName);
+ if(!pSnapIdElement)
+ {
+ pSnapIdElement = &(pTransportElement->AddElementL(KSnapIdLocalName));
+ }
+ TBuf8<128> buf;
+ buf.AppendFormat(_L8("%u"), aSnapId);
+ pSnapIdElement->SetContentL(buf);
+ }
+ else
+ {
+ CSenElement* pTransportElement = AsElement().Element(KTransportLocalName);
+ if(pTransportElement)
+ {
+ CSenElement* pSnapIdElement =
+ pTransportElement->Element(KSnapIdLocalName);
+
+ if(pSnapIdElement)
+ {
+ pSnapIdElement = pTransportElement->RemoveElement(KSnapIdLocalName);
+ }
+ }
+ }
+
+ }
+
+// Getter for SNAP ID
+EXPORT_C TInt CSenPolicy::SnapId(TUint32& aCurrentSnapId)
+ {
+ CSenElement* pTransportElement = AsElement().Element(KTransportLocalName);
+ if(pTransportElement)
+ {
+ CSenElement* pSnapIdElement =
+ pTransportElement->Element(KSnapIdLocalName);
+ if(pSnapIdElement && pSnapIdElement->HasContent())
+ {
+ //SENDEBUG((_L("CSenPolicy::SnapIdL: content found")));
+ TPtrC8 content = pSnapIdElement->Content();
+ TLex8 lex(content);
+
+ TInt err = lex.Val(aCurrentSnapId, EDecimal);
+ return err;
+ }
+ //SENDEBUG((_L("CSenPolicy::SnapIdL: <SnapId> element not found")));
+ }
+ //SENDEBUG((_L("CSenPolicy::SnapIdL: <Transport> element not found")));
+ return KErrNotFound;
+ }
+
+// Setter: overrides current values with the given values from the array
+EXPORT_C void CSenPolicy::SetIdentityProviderIdsL(
+ CSenIdentityProviderIdArray8& aList)
+ {
+ CSenElement* pListElement =
+ AsElement().Element(KIdentityProviderIDsLocalName);
+
+ if(pListElement)
+ {
+ CSenElement* pRemoved = AsElement().RemoveElement(*pListElement);
+ delete pRemoved;
+ }
+
+ TInt count(aList.Count());
+ if(count>0)
+ {
+ for(TInt i=0; i<count; i++)
+ {
+ TPtrC8 providerId = aList[i];
+ if(providerId.Length()>0)
+ {
+ AddIdentityProviderIdL(providerId);
+ }
+ }
+ }
+ }
+
+// Adder: adds a new IDP ID value at the end of the current list value(s)
+// Checks for duplicate (does not insert new ID elements with equal content)
+// @return KErrAlreadyExists, if a duplicate is tried to add
+// KErrArgument if a zero-length descriptor is tried
+// to add (aProviderId.Length() == 0)
+//
+// NOTE: allocates a copy of given aProviderId!
+//
+EXPORT_C TInt CSenPolicy::AddIdentityProviderIdL(const TDesC8& aProviderId)
+ {
+ if(aProviderId.Length()>0)
+ {
+ // there is something relevant to add..
+
+ // check next that <IdentityProviderIDs> element exists
+ CSenElement* pListElement =
+ AsElement().Element(KIdentityProviderIDsLocalName);
+
+ // check if this policy is "empty" (no content yet)
+ if(!pListElement)
+ {
+ // add the <IdentityProviderIDs> element..
+ pListElement =
+ &AsElement().AddElementL(KIdentityProviderIDsLocalName);
+ }
+ else
+ {
+ // check if ID being inserted already exists
+ // (prevent inserting a duplicate)
+
+ RPointerArray<CSenElement>& children = pListElement->ElementsL();
+ TInt childCount(children.Count());
+
+ // loop through child elements and check their content
+ for(TInt i=0; i<childCount; i++)
+ {
+ TPtrC8 content = children[i]->Content();
+ if(content == aProviderId)
+ {
+ // duplicate found(!)
+ return KErrAlreadyExists;
+ }
+ }
+
+ }
+
+ CSenElement& added =
+ pListElement->AddElementL(KIdentityProviderIDLocalName);
+
+ added.SetContentL(aProviderId);
+ // content set: ok
+ return KErrNone;
+ }
+ else // tried to add zero length descriptor (aProviderId.Length() == 0)
+ {
+ // return argument error
+ return KErrArgument;
+ }
+ }
+
+// sets (rebuilds) the IAP ID and IDP ID list values from template
+// @return - a error, if at least one addition of new contents has
+// failed OR KerrNone if every property was successfully reset
+EXPORT_C TInt CSenPolicy::RebuildFrom(MSenPolicy& aTemplate)
+ {
+ TInt retVal(KErrNone);
+ TRAPD(err, retVal = RebuildFromL(aTemplate));
+ if (err != KErrNone)
+ {
+ retVal = err;
+ }
+ return retVal;
+ }
+
+TInt CSenPolicy::RebuildFromL(MSenPolicy& aTemplate)
+ {
+ TInt retVal(KErrNone);
+ // check for possible provider policy definition
+
+ TUint32 iapId(0);
+ TInt err = aTemplate.IapId(iapId);
+ if(err==KErrNone)
+ {
+ // update the latest IAP "recommendation"
+ SetIapIdL(iapId);
+ }
+ const CSenIdentityProviderIdArray8& ids =
+ aTemplate.IdentityProviderIds8L();
+ TInt idsCount(ids.MdcaCount());
+ for(TInt j=0; j<idsCount; j++)
+ {
+ TPtrC8 value = ids[j];
+ if(value.Length()>0)
+ {
+ err = AddIdentityProviderIdL(value);
+ if(err!=KErrNone)
+ {
+ retVal = err; // indicate that some IDP could not be added
+ }
+ }
+ }
+ return retVal;
+ }
+
+// Getter: return an empty array if no IDP:s have been spesified
+// or a list of IDP arrays if such value(s) have been set.
+//
+// Ownership of the array remains within this class
+EXPORT_C const CSenIdentityProviderIdArray8&
+ CSenPolicy::IdentityProviderIds8L()
+ {
+ // construct temporary array and fill it with the xml content
+ CSenIdentityProviderIdArray8* pArray =
+ CSenIdentityProviderIdArray8::NewLC();
+
+ // check next that <IdentityProviderIDs> element exists
+ CSenElement* pListElement =
+ AsElement().Element(KIdentityProviderIDsLocalName);
+ if(pListElement)
+ {
+ // Check if strict attribute has "true" value.
+ const TDesC8* pStrictValue =
+ pListElement->AttrValue(KIdentityProviderIDsStrictAttrName);
+ if(pStrictValue && *pStrictValue == KIdentityProviderIDsStrictAttrTrue)
+ {
+ pArray->SetStrict(ETrue);
+ }
+
+ // next check that child elements exist
+ RPointerArray<CSenElement>& elements = pListElement->ElementsL();
+ TInt count(elements.Count());
+ for(TInt i=0; i<count; i++)
+ {
+ CSenElement* element = elements[i];
+ if(element && element->HasContent())
+ {
+ pArray->AppendL(element->Content());
+ }
+ }
+ }
+
+ delete iIdpIdList;
+ iIdpIdList = pArray;
+ CleanupStack::Pop(); // pArray
+ return *iIdpIdList;
+ }
+
+// End of file