--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsdescription/src/senxmlservicedescription.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,1208 @@
+/*
+* 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 FILESS
+#include <e32base.h>
+#include <e32des8.h> // HBufC8
+
+#include "SenDateUtils.h"
+
+#include "SenXmlServiceDescription.h"
+#include "SenBaseFragment.h"
+#include "SenXmlUtils.h"
+#include "sendebug.h"
+
+#include "SenCredential.h"
+#include "senproviderpolicy.h"
+#include "senservicepolicy.h"
+#include "SenFacet.h"
+#include "SenXmlUtils.h"
+
+#include <SenServiceConnection.h> // for KErrSenNoEndpoint
+
+
+namespace
+ {
+ // Local names for XML element:
+ _LIT8(KServiceDescriptionLocalName, "ServiceDescription");
+ _LIT8(KEndpointLocalname, "Endpoint");
+ _LIT8(KContractLocalname, "Contract");
+ _LIT8(KProviderPolicyLocalName, "ProviderPolicy");
+ _LIT8(KServicePolicyLocalName, "ServicePolicy");
+ _LIT8(KClientServicePolicyLocalName, "ClientPolicy");
+ _LIT8(KSenIdpProviderIdLocalname, "ProviderID");
+ // Names for XML attributes:
+ _LIT8(KNotOnOrAfter, "notOnOrAfter");
+ _LIT8(KFramework, "framework");
+ _LIT8(KCue, "cue");
+ _LIT8(KTouch, "touch");
+ }
+
+
+EXPORT_C CSenXmlServiceDescription* CSenXmlServiceDescription::NewL()
+ {
+ CSenXmlServiceDescription* pNew = NewLC();
+ CleanupStack::Pop();
+ return(pNew) ;
+ }
+
+EXPORT_C CSenXmlServiceDescription* CSenXmlServiceDescription::NewLC()
+ {
+ CSenXmlServiceDescription* pNew =
+ new (ELeave) CSenXmlServiceDescription(EXmlServiceDescription);
+ CleanupStack::PushL(pNew);
+ pNew->ConstructL();
+ return pNew;
+ }
+
+EXPORT_C void CSenXmlServiceDescription::ConstructL()
+ {
+ BaseConstructL(NewElementName());
+ // Create empty policy
+ iProviderPolicy = CSenProviderPolicy::NewL();
+ CSenElement& element = iProviderPolicy->AsElement();
+ AsElement().AddElementL(element);
+ iServicePolicy = CSenServicePolicy::NewL();
+ CSenElement& servicePolicyElement = iServicePolicy->AsElement();
+ AsElement().AddElementL(servicePolicyElement);
+ }
+
+EXPORT_C const TDesC8& CSenXmlServiceDescription::NewElementName()
+ {
+ return KServiceDescriptionLocalName();
+ }
+
+EXPORT_C CSenXmlServiceDescription* CSenXmlServiceDescription::NewL(
+ const TDesC8& aNamespaceURI)
+ {
+ CSenXmlServiceDescription* pNew = NewLC(aNamespaceURI);
+ CleanupStack::Pop();
+ return(pNew) ;
+ }
+
+EXPORT_C CSenXmlServiceDescription* CSenXmlServiceDescription::NewLC(
+ const TDesC8& aNamespaceURI)
+ {
+ CSenXmlServiceDescription* pNew =
+ new (ELeave) CSenXmlServiceDescription(EXmlServiceDescription);
+ CleanupStack::PushL(pNew);
+ pNew->ConstructL(aNamespaceURI);
+ return pNew;
+ }
+
+EXPORT_C void CSenXmlServiceDescription::ConstructL(const TDesC8& aNamespaceURI)
+ {
+ BaseConstructL(aNamespaceURI, NewElementName());
+ // create empty policy
+ iProviderPolicy = CSenProviderPolicy::NewL();
+ CSenElement& element = iProviderPolicy->AsElement();
+ AsElement().AddElementL(element);
+ iServicePolicy = CSenServicePolicy::NewL();
+ CSenElement& servicePolicyElement = iServicePolicy->AsElement();
+ AsElement().AddElementL(servicePolicyElement);
+ }
+
+EXPORT_C CSenXmlServiceDescription* CSenXmlServiceDescription::NewL(
+ const TDesC8& aEndPoint,
+ const TDesC8& aContract)
+ {
+ CSenXmlServiceDescription* pNew = NewLC(aEndPoint, aContract);
+ CleanupStack::Pop();
+ return(pNew) ;
+ }
+
+EXPORT_C CSenXmlServiceDescription* CSenXmlServiceDescription::NewLC(
+ const TDesC8& aEndPoint,
+ const TDesC8& aContract)
+ {
+ CSenXmlServiceDescription* pNew =
+ new (ELeave) CSenXmlServiceDescription(EXmlServiceDescription);
+ CleanupStack::PushL(pNew);
+ pNew->ConstructL(aEndPoint, aContract);
+ return pNew;
+ }
+
+EXPORT_C void CSenXmlServiceDescription::ConstructL(const TDesC8& aEndPoint,
+ const TDesC8& aContract)
+ {
+ BaseConstructL(NewElementName());
+ if(aEndPoint.Length()>0)
+ {
+ SetContentOfL(KEndpointLocalname, aEndPoint);
+ }
+
+ if(aContract.Length()>0)
+ {
+ SetContentOfL(KContractLocalname, aContract);
+ }
+ // create empty policy
+ iProviderPolicy = CSenProviderPolicy::NewL();
+ CSenElement& element = iProviderPolicy->AsElement();
+ AsElement().AddElementL(element);
+ iServicePolicy = CSenServicePolicy::NewL();
+ CSenElement& servicePolicyElement = iServicePolicy->AsElement();
+ AsElement().AddElementL(servicePolicyElement);
+ }
+
+
+EXPORT_C CSenXmlServiceDescription::CSenXmlServiceDescription(
+ TDescriptionClassType aType)
+:
+ iType(aType),
+ iServicePolicy(NULL),
+ iCredential(NULL),
+ iNotOnOrAfter(Time::NullTTime()), // sets this session to be valid if read from db
+ iProviderPolicy(NULL)
+
+ {
+ }
+
+EXPORT_C CSenXmlServiceDescription::~CSenXmlServiceDescription()
+ {
+ // Bugfix 2004-07-27
+ if(iCredential)
+ {
+ TInt index(KErrNotFound);
+ index = iCredentialList.Find(iCredential);
+ if(index==KErrNotFound)
+ {
+ delete iCredential; // otherwise deleted by ResetAndDestroy()
+ }
+ }
+
+
+ iCredentialList.ResetAndDestroy(); // owns
+
+ if( iProviderPolicy )
+ {
+ iProviderPolicy->ExtractElement();
+ }
+ delete iProviderPolicy;
+ if( iServicePolicy )
+ {
+ iServicePolicy->ExtractElement();
+ }
+ delete iServicePolicy;
+ }
+
+EXPORT_C MSenServiceDescription::TDescriptionClassType
+ CSenXmlServiceDescription::DescriptionClassType()
+ {
+ return iType;
+ }
+
+
+EXPORT_C void CSenXmlServiceDescription::SetAttributesL(const RAttributeArray& aAttributes)
+ {
+ // Call superclass for namespace attributes only
+ CSenBaseFragment::SetAttributesL(aAttributes);
+
+ // SenXmlUtils::AttrValue returns KNullDesC8 if attribute is not found:
+ const TDesC8& id = SenXmlUtils::AttrValue(aAttributes, KFramework);
+ if( id.Length()>0 )
+ {
+ // Add real attribute for ServiceDescription -element. If "framework"
+ // attribute already exists, it's value will be overwritten:
+ SenXmlUtils::AddAttributeL(AsElement(), KFramework, id);
+ }
+ const TDesC8& touch = SenXmlUtils::AttrValue(aAttributes, KTouch);
+ if( touch.Length()>0 )
+ {
+ // Add touch attribute for ServiceDescription -element. If "touch"
+ // attribute already exists, it's value will be overwritten:
+
+ CSenElement* elem = &AsElement();
+ elem->AddAttrL(KTouch, touch);
+
+ }
+ const TDesC8& userInfoPrompt = SenXmlUtils::AttrValue(aAttributes, KSenAttrPromptUserInfo);
+ if( userInfoPrompt.Length() > 0 )
+ {
+ SenXmlUtils::AddAttributeL(AsElement(), KSenAttrPromptUserInfo, userInfoPrompt );
+ }
+ }
+
+EXPORT_C RCredentialList& CSenXmlServiceDescription::Credentials()
+ {
+ return iCredentialList;
+ }
+
+EXPORT_C TBool CSenXmlServiceDescription::Matches( MSenServiceDescription& aOtherServiceDescription )
+ {
+ TPtrC8 patternEndpoint = aOtherServiceDescription.Endpoint();
+ TPtrC8 thisEndpoint = Endpoint();
+
+ if(patternEndpoint.Length()>0)
+ {
+ if(!(thisEndpoint.Length()>0 && patternEndpoint == thisEndpoint))
+ {
+ return EFalse;
+ }
+ }
+
+ TPtrC8 patternContract = aOtherServiceDescription.Contract();
+ TPtrC8 thisContract = Contract();
+
+ if(patternContract.Length()>0)
+ {
+ if(!(thisContract.Length()>0 && patternContract == thisContract))
+ {
+ return EFalse;
+ }
+ }
+
+ TBool match(ETrue);
+
+ TRAPD(retVal,
+ RFacetArray otherFacets;
+ CleanupClosePushL(otherFacets);
+ aOtherServiceDescription.FacetsL(otherFacets);
+
+ TPtrC8 facetName;
+ TInt leave(KErrNone);
+ TInt count(otherFacets.Count());
+ for (TInt i=0; i<count && match; i++)
+ {
+ facetName.Set(otherFacets[i]->Name());
+ TRAP( leave, HasFacetL(facetName, match); )
+ }
+ otherFacets.ResetAndDestroy();
+ CleanupStack::Pop(); // otherFacets
+ );
+
+ return match;
+ }
+
+
+EXPORT_C TPtrC8 CSenXmlServiceDescription::Contract()
+ {
+ return ContentOf(KContractLocalname());
+ }
+
+
+EXPORT_C TPtrC8 CSenXmlServiceDescription::Endpoint()
+ {
+ return ContentOf(KEndpointLocalname());
+ }
+
+EXPORT_C TPtrC8 CSenXmlServiceDescription::FrameworkId()
+ {
+ const TDesC8* value = AsElement().AttrValue(KFramework);
+ if(value)
+ {
+ return *value;
+ }
+ else
+ {
+ return KNullDesC8();
+ }
+ }
+
+EXPORT_C TPtrC8 CSenXmlServiceDescription::FrameworkVersion()
+ {
+ return KNullDesC8();
+ }
+
+EXPORT_C void CSenXmlServiceDescription::SetContractL(const TDesC8& aContract)
+ {
+ SetContentOfL(KContractLocalname(), aContract);
+ }
+
+
+EXPORT_C void CSenXmlServiceDescription::SetEndPointL(const TDesC8& aEndPoint)
+ {
+ SetContentOfL(KEndpointLocalname(), aEndPoint);
+ }
+
+EXPORT_C void CSenXmlServiceDescription::SetFrameworkIdL(const TDesC8& aFrameworkId)
+ {
+ if ( aFrameworkId != KNullDesC8 )
+ {
+ // overwrites the value of "framework" attribute, if such attribute exists
+ SenXmlUtils::AddAttributeL(AsElement(), KFramework, aFrameworkId);
+ }
+ else
+ {
+ // If there would not have been RemoveAttributeL() method,
+ // then AddAtributeL(KNullDesC8) could have been used
+ delete SenXmlUtils::RemoveAttributeL(AsElement(), KFramework);
+ }
+ }
+
+EXPORT_C HBufC8* CSenXmlServiceDescription::AsXmlL()
+ {
+ return AsElement().AsXmlL();
+ }
+
+EXPORT_C HBufC* CSenXmlServiceDescription::AsXmlUnicodeL()
+ {
+ return AsElement().AsXmlUnicodeL();
+ }
+
+EXPORT_C void CSenXmlServiceDescription::WriteAsXMLToL(RWriteStream& aWriteStream)
+ {
+ AsElement().WriteAsXMLToL(aWriteStream);
+ }
+
+
+EXPORT_C void CSenXmlServiceDescription::StartElementL(const TDesC8& aNsUri,
+ const TDesC8& aLocalName,
+ const TDesC8& aQName,
+ const RAttributeArray& aAttributes)
+ {
+
+ switch (iState)
+ {
+ case KStateSave: // IOP(!)
+ {
+ if(aLocalName.Compare(KCredentialsName) == 0)
+ {
+ iState = KStateParsingCredentials;
+
+ TPtrC8 attValue = SenXmlUtils::AttrValue(aAttributes,
+ KNotOnOrAfter);
+ if(attValue.Length()>0)
+ {
+ iNotOnOrAfter = SenDateUtils::FromXmlDateTimeL(attValue);
+ }
+ }
+ else if(aLocalName.Compare(KProviderPolicyLocalName) == 0)
+ {
+ iState = KStateParsingProviderPolicy;
+
+ TPtrC8 prefix(KNullDesC8);
+ if(aQName.Length()>0)
+ {
+ TInt colon = aQName.Locate(':');
+ if(colon>0) // Note: 0 also treated as no prefix
+ {
+ prefix.Set(aQName.Ptr(), colon);
+ }
+ }
+ iProviderPolicy->AsElement().SetNamespaceL(prefix, aNsUri);
+
+ DelegateParsingL(*iProviderPolicy);
+ }
+ else if(aLocalName.Compare(KServicePolicyLocalName) == 0)
+ {
+ iState = KStateParsingServicePolicy;
+
+ TPtrC8 prefix(KNullDesC8);
+ if(aQName.Length()>0)
+ {
+ TInt colon = aQName.Locate(':');
+ if(colon>0) // Note: 0 also treated as no prefix
+ {
+ prefix.Set(aQName.Ptr(), colon);
+ }
+ }
+ iServicePolicy->AsElement().SetNamespaceL(prefix, aNsUri);
+ DelegateParsingL(*iServicePolicy);
+ }
+ else
+ {
+ CSenDomFragment::StartElementL( aNsUri,
+ aLocalName,
+ aQName,
+ aAttributes );
+
+ // For each endpoint, preserve the "cue" attribute
+ if( aLocalName == KEndpointLocalname )
+ {
+ const TDesC8& cue = SenXmlUtils::AttrValue(aAttributes, KCue);
+ CSenElement* pEndpointElement = AsElement().Element( aLocalName );
+ if( cue.Length() > 0 && pEndpointElement)
+ {
+ SenXmlUtils::AddAttributeL(*pEndpointElement, KCue, cue );
+ }
+ }
+ }
+ break;
+ }
+ case KStateParsingCredentials:
+ {
+ iState = KStateParsingSingleCredential;
+
+ // see destructor: iCredentialList.ResetAndDestroy(); // owns
+ iCredential = CSenCredential::NewL( aNsUri,
+ aLocalName,
+ aQName,
+ aAttributes,
+ AsElement());
+ iCredential->SetValidUntil(iNotOnOrAfter);
+
+ DelegateParsingL(*iCredential);
+ break;
+ }
+ default: // iState is KStateIgnore or some other..
+ {
+ // 2005-11: changed
+ if(aLocalName == KServiceDescriptionLocalName())
+ {
+ SetAttributesL(aAttributes);
+ }
+
+ CSenDomFragment::StartElementL( aNsUri,
+ aLocalName,
+ aQName,
+ aAttributes);
+ }
+ }
+ }
+
+EXPORT_C void CSenXmlServiceDescription::EndElementL(const TDesC8& aNsUri,
+ const TDesC8& aLocalName,
+ const TDesC8& aQName )
+ {
+
+ switch (iState)
+ {
+ case KStateParsingCredentials:
+ {
+ if(aLocalName == KCredentialsName)
+ {
+ iState = KStateSave;
+ }
+ } break;
+ case KStateParsingSingleCredential:
+ {
+ iCredential->DetachL();
+ iCredentialList.Append(iCredential);
+ if(aLocalName == KCredentialsName)
+ {
+ iState = KStateIgnore;
+ }
+ else
+ {
+ iState = KStateParsingCredentials;
+ }
+ break;
+ }
+ case KStateParsingServicePolicy:
+ {
+// if(aLocalName == KServicePolicyLocalName)
+ {
+ iState = KStateSave;
+ }
+ } break;
+ case KStateParsingProviderPolicy:
+ {
+ iState = KStateSave;
+ } break;
+ default:
+ {
+ CSenDomFragment::EndElementL(aNsUri, aLocalName, aQName);
+ }
+ }
+ }
+
+// From Provider Policy:
+// Setter for Internet Access Point (IAP) ID
+EXPORT_C void CSenXmlServiceDescription::SetIapIdL(TUint32 aIapId)
+ {
+ iProviderPolicy->SetIapIdL(aIapId);
+ }
+
+// Getter for IAP ID
+EXPORT_C TInt CSenXmlServiceDescription::IapId(TUint32& aCurrentIapId)
+ {
+ return iProviderPolicy->IapId(aCurrentIapId);
+ }
+
+// Setter for SNAP
+EXPORT_C void CSenXmlServiceDescription::SetSnapIdL(TUint32 aSnapId)
+ {
+ iProviderPolicy->SetSnapIdL(aSnapId);
+ }
+
+// Getter for SNAP
+EXPORT_C TInt CSenXmlServiceDescription::SnapId(TUint32& aCurrentSnapId)
+ {
+ return iProviderPolicy->SnapId(aCurrentSnapId);
+ }
+
+// From Provider Policy:
+EXPORT_C TInt CSenXmlServiceDescription::SetTransportPropertiesL(const TDesC8& aProperties)
+ {
+ return iProviderPolicy->SetTransportPropertiesL(aProperties);
+ }
+
+// Getter for IAP ID
+EXPORT_C TInt CSenXmlServiceDescription::TransportPropertiesL(HBufC8*& aProperties)
+ {
+ return iProviderPolicy->TransportPropertiesL(aProperties);
+ }
+
+// Setter: overrides current values with the given values from the array
+EXPORT_C void CSenXmlServiceDescription::SetIdentityProviderIdsL( CSenIdentityProviderIdArray8& aList )
+ {
+ iProviderPolicy->SetIdentityProviderIdsL(aList);
+ }
+
+
+// Adder: adds a new IDP ID value at the end of the current list value(s)
+// Checks for duplicates (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)
+
+EXPORT_C TInt CSenXmlServiceDescription::AddIdentityProviderIdL(
+ TDesC8& aProviderId)
+ {
+ return iProviderPolicy->AddIdentityProviderIdL(aProviderId);
+ }
+
+// 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 CSenXmlServiceDescription::RebuildFrom(
+ MSenProviderPolicy& aTemplate)
+ {
+ return iProviderPolicy->RebuildFrom(aTemplate);
+ }
+
+// 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.
+EXPORT_C const CSenIdentityProviderIdArray8&
+ CSenXmlServiceDescription::IdentityProviderIds8L()
+ {
+ return iProviderPolicy->IdentityProviderIds8L();
+ }
+
+EXPORT_C TBool CSenXmlServiceDescription::Accepts( MSenProviderPolicy& aPolicyPattern )
+ {
+ return iProviderPolicy->Accepts(aPolicyPattern);
+ }
+
+// Overridden from CSenDomFragment
+EXPORT_C void CSenXmlServiceDescription::ResumeParsingFromL( const TDesC8& aNsUri,
+ const TDesC8& aLocalName,
+ const TDesC8& aQName )
+ {
+ iXmlReader->SetContentHandler(*this);
+
+ switch (iState)
+ {
+ // no other states may be resumed(!)
+ case KStateParsingCredentials:
+ case KStateParsingSingleCredential:
+ case KStateParsingProviderPolicy:
+ case KStateParsingServicePolicy:
+ {
+ EndElementL(aNsUri, aLocalName, aQName);
+ }
+ break;
+ }
+ }
+
+
+EXPORT_C TInt CSenXmlServiceDescription::HasFacetL( const TDesC8& aURI, TBool& aHasFacet )
+ {
+ aHasFacet = EFalse;
+ RPointerArray<CSenElement> elements;
+ CleanupClosePushL(elements);
+ AsElement().ElementsL(elements,KSenFacet);
+
+ const TDesC8* pValue = NULL;
+
+ TInt count(elements.Count());
+ for (TInt i=0; i<count && !aHasFacet; i++)
+ {
+ pValue = elements[i]->AttrValue(KFacetAttrName);
+ if (pValue)
+ {
+ if (*pValue == aURI) aHasFacet = ETrue;
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // elements
+ return KErrNone;
+ }
+
+/*
+EXPORT_C TInt CSenXmlServiceDescription::FacetValue(TDesC8& aURI,
+ HBufC8*& aValueTo)
+ {
+ delete aValueTo;
+ aValueTo = NULL;
+
+ TInt retVal = KErrNotFound;
+ RPointerArray<CSenElement> elements;
+ TRAPD(err, CleanupClosePushL(elements);)
+ if (err != KErrNone)
+ {
+ // cleanupstack was emptied when one of the above caused a Leave
+ return err;
+ }
+
+ TRAP(err, AsElement().ElementsL(elements,KSenFacet);)
+ if (err != KErrNone)
+ {
+ CleanupStack::PopAndDestroy(); // elements
+ return err;
+ }
+
+ const TDesC8* pValue = NULL;
+
+ TInt count(elements.Count());
+ for (TInt i=0; i<count && !aValueTo; i++)
+ {
+ pValue = elements[i]->AttrValue(KFacetAttrName);
+ if (pValue)
+ {
+ if (*pValue == aURI)
+ {
+ if (elements[i]->Content().Length() < 1)
+ {
+ aValueTo = KSenFacetValTrue().Alloc();
+ }
+ else
+ {
+ aValueTo = elements[i]->Content().Alloc();
+ }
+ if (aValueTo == NULL) retVal = KErrNoMemory;
+ else retVal = KErrNone;
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // elements
+ return retVal;
+ }
+*/
+
+// public, TRAPping version of FacetValue -getter:
+EXPORT_C TInt CSenXmlServiceDescription::FacetValue(TDesC8& aURI,
+ HBufC8*& aValueTo)
+ {
+ TInt retVal(KErrNone);
+ TInt leaveCode(KErrNone);
+ TRAP(leaveCode, retVal = FacetValueL(aURI, aValueTo);)
+ if (leaveCode != KErrNone)
+ {
+ retVal = leaveCode;
+ }
+ return retVal;
+ }
+
+// private, leaving version of FacetValue -getter:
+TInt CSenXmlServiceDescription::FacetValueL(TDesC8& aURI,
+ HBufC8*& aValueTo)
+ {
+ delete aValueTo;
+ aValueTo = NULL;
+
+ TInt retVal = KErrNotFound;
+ RPointerArray<CSenElement> elements;
+ CleanupClosePushL(elements);
+
+ AsElement().ElementsL(elements, KSenFacet);
+
+ const TDesC8* pValue = NULL;
+
+ TInt count(elements.Count());
+ for (TInt i=0; i<count && !aValueTo; i++)
+ {
+ pValue = elements[i]->AttrValue(KFacetAttrName);
+ if (pValue)
+ {
+ if (*pValue == aURI)
+ {
+ if(elements[i]->Content().Length() < 1)
+ {
+ aValueTo = KSenFacetValTrue().Alloc();
+ }
+ else
+ {
+ aValueTo = elements[i]->Content().Alloc();
+ }
+ if(!aValueTo) // OOM
+ {
+ retVal = KErrNoMemory;
+ }
+ else
+ {
+ retVal = KErrNone;
+ }
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // elements
+ return retVal;
+ }
+
+/*
+EXPORT_C TInt CSenXmlServiceDescription::RemoveFacet(const TDesC8& aURI)
+ {
+ RPointerArray<CSenElement> elements;
+ TRAPD(err,
+ CleanupClosePushL(elements);
+ AsElement().ElementsL(elements,KSenFacet);
+ )
+
+ if (err != KErrNone)
+ {
+ return err; // nothing needs to be popped from the cleanup stack
+ }
+
+ const TDesC8* pValue = NULL;
+ CSenElement* pFacet = NULL;
+
+ TInt count(elements.Count());
+ for (TInt i=0; i<count; i++)
+ {
+ pFacet = elements[i];
+ pValue = pFacet->AttrValue(KFacetAttrName);
+ if (pValue)
+ {
+ if (*pValue == aURI)
+ {
+ delete AsElement().RemoveElement(*pFacet);
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // elements.Close()
+
+ return KErrNone;
+ }
+*/
+// public, TRAPping version of FacetValue -getter:
+EXPORT_C TInt CSenXmlServiceDescription::RemoveFacet(const TDesC8& aURI)
+ {
+ TInt retVal(KErrNone);
+ TInt leaveCode(KErrNone);
+ TRAP(leaveCode, retVal = RemoveFacetL(aURI);)
+ if (leaveCode != KErrNone)
+ {
+ retVal = leaveCode;
+ }
+ return retVal;
+ }
+
+// private, leaving version of FacetValue -getter:
+TInt CSenXmlServiceDescription::RemoveFacetL(const TDesC8& aURI)
+ {
+ RPointerArray<CSenElement> elements;
+ CleanupClosePushL(elements);
+ AsElement().ElementsL(elements,KSenFacet);
+ const TDesC8* pValue = NULL;
+ CSenElement* pFacet = NULL;
+ TInt retVal(KErrNotFound); // returned, if no match
+ TInt count(elements.Count());
+ for(TInt i=0; i<count; i++)
+ {
+ pFacet = elements[i];
+ pValue = pFacet->AttrValue(KFacetAttrName);
+ if(pValue)
+ {
+ if(*pValue == aURI)
+ {
+ delete AsElement().RemoveElement(*pFacet);
+ retVal = KErrNone; // ok: facet removed
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy(); // elements.Close()
+ return retVal;
+ }
+
+
+EXPORT_C TInt CSenXmlServiceDescription::AddFacetL(const CSenFacet& aFacet)
+ {
+ TInt retVal(KErrNone);
+ RPointerArray<CSenElement> elements;
+ CleanupClosePushL(elements);
+ AsElement().ElementsL(elements,KSenFacet);
+
+ const TDesC8* pValue = NULL;
+ CSenElement* pFacet = NULL;
+
+ TInt count(elements.Count());
+ for(TInt i=0; i<count && !pFacet; i++)
+ {
+ pFacet = elements[i];
+ pValue = pFacet->AttrValue(KFacetAttrName);
+ if(pValue)
+ {
+ if(*pValue != ((CSenFacet&)aFacet).Name())
+ {
+ pFacet = NULL;
+ }
+ else // facet with equal name already exists!
+ {
+ retVal = KErrAlreadyExists;
+ }
+ }
+ else
+ {
+ pFacet = NULL;
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // elements.Close()
+
+ if(pFacet && (retVal == KErrAlreadyExists))
+ {
+ return retVal;
+ }
+ else // facet did not already exist
+ {
+ pFacet = &AsElement().AddElementL(KSenFacet);
+ pFacet->AddAttrL(KFacetAttrName,((CSenFacet&)aFacet).Name());
+ if(((CSenFacet&)aFacet).Type() != KNullDesC8)
+ {
+ pFacet->AddAttrL(KFacetAttrType,((CSenFacet&)aFacet).Type());
+ }
+ pFacet->SetContentL(((CSenFacet&)aFacet).Value());
+ retVal = KErrNone;
+ return retVal;
+ }
+ }
+
+EXPORT_C TInt CSenXmlServiceDescription::SetFacetL(const CSenFacet& aFacet)
+ {
+ RPointerArray<CSenElement> elements;
+ CleanupClosePushL(elements);
+ AsElement().ElementsL(elements,KSenFacet);
+
+ const TDesC8* pValue = NULL;
+ CSenElement* pFacet = NULL;
+
+ TInt count(elements.Count());
+ for(TInt i=0; i<count && !pFacet; i++)
+ {
+ pFacet = elements[i];
+ pValue = pFacet->AttrValue(KFacetAttrName);
+ if (pValue)
+ {
+ if(*pValue != ((CSenFacet&)aFacet).Name()) pFacet = NULL;
+ }
+ else
+ {
+ pFacet = NULL;
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // elements.Close()
+
+ if(!pFacet)
+ {
+ // add new facet element
+ pFacet = &AsElement().AddElementL(KSenFacet);
+ }
+
+ pFacet->AddAttrL(KFacetAttrName,((CSenFacet&)aFacet).Name());
+ if (((CSenFacet&)aFacet).Type() != KNullDesC8)
+ {
+ pFacet->AddAttrL(KFacetAttrType,((CSenFacet&)aFacet).Type());
+ }
+ pFacet->SetContentL(((CSenFacet&)aFacet).Value());
+
+ return KErrNone;
+ }
+
+EXPORT_C TInt CSenXmlServiceDescription::FacetsL(RFacetArray& aFacetArray)
+ {
+ RPointerArray<CSenElement> elements;
+ CleanupClosePushL(elements);
+ AsElement().ElementsL(elements,KSenFacet);
+
+ CSenFacet* pNewFacet = NULL;
+
+ TInt count(elements.Count());
+ for(TInt i=0; i<count; i++)
+ {
+ pNewFacet = CSenFacet::NewL(*elements[i]);
+ aFacetArray.Append(pNewFacet);
+ }
+
+ CleanupStack::PopAndDestroy(); // elements.Close()
+ return KErrNone;
+ }
+
+
+EXPORT_C TInt CSenXmlServiceDescription::ScoreMatchL( MSenServiceDescription& aPattern )
+ {
+ TInt score(0);
+
+ if ((aPattern.Endpoint().Length() > 0) && (aPattern.Endpoint() == Endpoint()))
+ {
+ score++;
+ }
+ if ((aPattern.Contract().Length() > 0) && (aPattern.Contract() == Contract()))
+ {
+ score++;
+ }
+
+ RFacetArray otherFacets;
+ CleanupClosePushL(otherFacets);
+ aPattern.FacetsL(otherFacets);
+
+ HBufC8* pFacetValue = NULL;
+ TPtrC8 facetName;
+ TPtrC8 otherFacetValue;
+
+ TInt count(otherFacets.Count());
+ for (TInt i=0; i<count; i++)
+ {
+ facetName.Set(otherFacets[i]->Name());
+ FacetValue(facetName,pFacetValue);
+ if (pFacetValue)
+ {
+ if (otherFacets[i]->Value().Length() < 1)
+ {
+ otherFacetValue.Set(KSenFacetValTrue());
+ }
+ else
+ {
+ otherFacetValue.Set(otherFacets[i]->Value());
+ }
+ if (*pFacetValue == otherFacetValue)
+ {
+ score++;
+ }
+ }
+ delete pFacetValue;
+ pFacetValue = NULL;
+ }
+
+ otherFacets.ResetAndDestroy();
+ CleanupStack::Pop(); // otherFacets
+
+ return score;
+ }
+
+EXPORT_C TBool CSenXmlServiceDescription::HasEqualPrimaryKeysL(MSenServiceDescription& aCandidate)
+ {
+ TBool retVal(EFalse);
+ if(aCandidate.Endpoint() == Endpoint() &&
+ aCandidate.Contract() == Contract() &&
+ aCandidate.FrameworkId() == FrameworkId())
+ {
+ retVal = ETrue;
+ }
+ return retVal;
+ }
+
+EXPORT_C TBool CSenXmlServiceDescription::IsLocalL()
+ {
+ TBool local(EFalse);
+
+ // Check transport cue; if such XML attribute
+ // has been set to <Endpoint element, it is
+ // "stronger" than actual endpoint scheme
+ if(ipElement)
+ {
+ CSenElement* child = AsElement().Element(KEndpointLocalname());
+ if(child)
+ {
+ const TDesC8* cue = child->AttrValue(KCue);
+ TInt length(KSenTransportSchemeLocal().Length());
+ if(cue && cue->Length()>=length && cue->Left(length) == KSenTransportSchemeLocal)
+ {
+ local = ETrue; // match!
+ }
+ }
+ }
+
+ if(!local) // no match yet
+ {
+ // Resolve the endpoint scheme
+ TPtrC8 uri = Endpoint();
+ if(uri.Length()>0)
+ {
+ TInt index = uri.Locate(':');
+ if(index!=KErrNotFound)
+ {
+ TPtrC8 uriScheme = uri.Left(index);
+ if(uriScheme == KSenTransportSchemeLocal)
+ {
+ local = ETrue;
+ }
+ }
+ }
+ }
+ return local;
+ }
+
+EXPORT_C TInt CSenXmlServiceDescription::SetTransportCueL(const TDesC8& aTransportCue)
+ {
+ TInt retVal(KErrSenNoEndpoint);
+ if(ipElement)
+ {
+ CSenElement* child = AsElement().Element(KEndpointLocalname());
+ if(child)
+ {
+ // Method either adds new attribute or updates existing one:
+ SenXmlUtils::AddAttributeL(*child, KCue, aTransportCue);
+ retVal = KErrNone;
+ }
+ }
+ return retVal;
+ }
+
+EXPORT_C TPtrC8 CSenXmlServiceDescription::TransportCue()
+ {
+ if(ipElement)
+ {
+ CSenElement* child = AsElement().Element(KEndpointLocalname());
+ if(child)
+ {
+ const TDesC8* value = child->AttrValue(KCue);
+ if(value)
+ {
+ return *value;
+ }
+ }
+ }
+ return KNullDesC8();
+ }
+
+EXPORT_C MSenServicePolicy* CSenXmlServiceDescription::ServicePolicy()
+ {
+ if(iServicePolicy)
+ {
+ return (MSenServicePolicy*)iServicePolicy;
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+
+EXPORT_C TInt CSenXmlServiceDescription::SetPolicyL(const TDesC8& aName)
+ {
+ if(aName==KNullDesC8())
+ return KErrArgument;
+
+ CSenElement* servicePolicy = AsElement().Element(KServicePolicyLocalName);
+ CSenElement* clientPolicy = servicePolicy->Element(KClientServicePolicyLocalName);
+ if( clientPolicy == NULL )
+ {
+ clientPolicy = &(servicePolicy->AddElementL( KClientServicePolicyLocalName ));
+ }
+ clientPolicy->AddElementL(aName);
+ return KErrNone;
+ }
+
+EXPORT_C TInt CSenXmlServiceDescription::SetPolicyL(const TDesC8& aName, const TDesC8& aValue)
+ {
+ if(aName==KNullDesC8() || aValue == KNullDesC8())
+ return KErrArgument;
+
+ CSenElement* servicePolicy = AsElement().Element(KServicePolicyLocalName);
+ CSenElement* clientPolicy = servicePolicy->Element(KClientServicePolicyLocalName);
+ if( clientPolicy == NULL )
+ {
+ clientPolicy = & (servicePolicy->AddElementL( KClientServicePolicyLocalName ));
+ }
+ clientPolicy->AddElementL(aName).SetContentL(aValue);
+ return KErrNone;
+ }
+
+EXPORT_C TInt CSenXmlServiceDescription::SetPolicyL(const TDesC8& aName, const TDesC8& aValue, const TDesC8& aAttribName, const TDesC8& aAttribValue)
+ {
+
+ if(aName==KNullDesC8() || aValue == KNullDesC8() || aAttribName == KNullDesC8() || aAttribValue == KNullDesC8())
+ return KErrArgument;
+
+ CSenElement* servicePolicy = AsElement().Element(KServicePolicyLocalName);
+ CSenElement* clientPolicy = servicePolicy->Element(KClientServicePolicyLocalName);
+ if( clientPolicy == NULL )
+ {
+ clientPolicy = & (servicePolicy->AddElementL( KClientServicePolicyLocalName ));
+ }
+ CSenElement& ele = clientPolicy->AddElementL(aName);
+ ele.SetContentL(aValue);
+ SenXmlUtils::AddAttributeL(ele, aAttribName, aAttribValue);
+ return KErrNone;
+ }
+
+EXPORT_C TInt CSenXmlServiceDescription::SetProviderIdL( const TDesC8& aProviderID )
+ {
+ if ( aProviderID.Length() == 0 )
+ {
+ return KErrArgument; // zero-length provider ID
+ }
+ else
+ {
+ SetContentOfL(KSenIdpProviderIdLocalname, aProviderID);
+ return KErrNone;
+ }
+ }
+
+EXPORT_C TPtrC8 CSenXmlServiceDescription::ProviderId()
+ {
+ return ContentOf( KSenIdpProviderIdLocalname );
+ }
+
+EXPORT_C void CSenXmlServiceDescription::SetPromptUserInfoL( TBool aPromptUserInfoMode )
+ {
+ if( aPromptUserInfoMode )
+ {
+#ifndef _RD_SEN_WS_STAR_DO_NOT_PROMPT_AUTHINFO_BY_DEFAULT
+
+ // macro is disabled
+
+ // When attribute does not exist, by default, the userinfo prompt is displayed:
+ // (when authentication service tells that authentication fails)
+ delete SenXmlUtils::RemoveAttributeL(AsElement(), KSenAttrPromptUserInfo);
+
+#else
+ // macro is not in effect
+ _LIT8(KTrue,"true");
+ // Attribute with "true" value must *explicitely* exist, since default is "do not prompt":
+ SenXmlUtils::AddAttributeL(AsElement(), KSenAttrPromptUserInfo, KTrue ); //CodeScannerWarnings
+#endif
+ }
+ else
+ {
+ _LIT8(KFalse,"false");
+ // Attribute is needed only (with value "false"), when API caller wants to disable
+ // end-user prompt from being displayed
+ SenXmlUtils::AddAttributeL(AsElement(), KSenAttrPromptUserInfo, KFalse ); //CodeScannerWarnings
+ }
+ }
+
+EXPORT_C TBool CSenXmlServiceDescription::PromptUserInfo()
+ {
+ _LIT8(KFalse,"false");
+ TBool retVal(ETrue); // by default, prompting is enabled
+ const TDesC8* value = AsElement().AttrValue( KSenAttrPromptUserInfo );
+ if( value && *value == KFalse ) //CodeScannerWarnings
+ {
+ // Only, and only if attribute EXISTS AND it HAS value "false",
+ // the user info should NOT be prompted from end-user(!)
+ retVal = EFalse;
+ }
+ // else retVal = ETrue;
+ return retVal;
+ }
+
+// End of File