diff -r 000000000000 -r 62f9d29f7211 webservices/wsdescription/src/senidentityprovider.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/webservices/wsdescription/src/senidentityprovider.cpp Thu Jan 07 16:19:19 2010 +0200 @@ -0,0 +1,425 @@ +/* +* 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 // framework IDs +#include // check if this include is needed(?) +#include + +// #include "SenDebug.h" + +//#include "MSenIdentityManager.h" +#include "SenIdentityProvider.h" + +// CONSTANTS + + + + +namespace + { + _LIT8(KDefaultIdentityAttributeName, "default"); + _LIT8(KNewElementName, "IdentityProvider"); + _LIT8(KServiceID, "ServiceID"); +// _LIT8(KFakeIMEI8, "012345678901234"); + } + +EXPORT_C CSenIdentityProvider::CSenIdentityProvider( + TDescriptionClassType aType) +: CSenXmlServiceDescription(aType) + { + } + +EXPORT_C const TDesC8& CSenIdentityProvider::NewElementName() + { + return KNewElementName(); + } + +EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewL( + const TDesC8& aEndpoint) + { + CSenIdentityProvider* pNew = NewLC(aEndpoint); + CleanupStack::Pop(); + return(pNew); + } +EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewLC( + const TDesC8& aEndpoint) + { + CSenIdentityProvider* pNew = + new (ELeave) CSenIdentityProvider(EIdentityProvider); + + CleanupStack::PushL(pNew); + pNew->ConstructL(aEndpoint); + return pNew; + } + +EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewL( + const TDesC8& aEndpoint, + const TDesC8& aContract ) + { + CSenIdentityProvider* pNew = NewLC(aEndpoint, aContract); + CleanupStack::Pop(); + return(pNew) ; + } + +EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewLC( + const TDesC8& aEndpoint, + const TDesC8& aContract ) + { + CSenIdentityProvider* pNew = + new (ELeave) CSenIdentityProvider(EIdentityProvider); + + CleanupStack::PushL(pNew); + pNew->ConstructL(aEndpoint, aContract); + return pNew; + } + +EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewL( + const TDesC8& aEndpoint, + const TDesC8& aContract, + const TDesC8& aProviderID) + { + CSenIdentityProvider* pNew = NewLC(aEndpoint, aContract, aProviderID); + CleanupStack::Pop(); + return(pNew) ; + } + +EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewLC( + const TDesC8& aEndpoint, + const TDesC8& aContract, + const TDesC8& aProviderID) + { + CSenIdentityProvider* pNew = + new (ELeave) CSenIdentityProvider(EIdentityProvider); + + CleanupStack::PushL(pNew); + pNew->ConstructL(aEndpoint, aContract, aProviderID); + return pNew; + } + +EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewL( + const TDesC8& aEndpoint, + const TDesC8& aContract, + const TDesC8& aProviderID, + const TDesC8& aServiceID) + { + CSenIdentityProvider* pNew = NewLC(aEndpoint, aContract, + aProviderID, aServiceID); + CleanupStack::Pop(); + return(pNew) ; + } + +EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewLC( + const TDesC8& aEndpoint, + const TDesC8& aContract, + const TDesC8& aProviderID, + const TDesC8& aServiceID) + { + CSenIdentityProvider* pNew = + new (ELeave) CSenIdentityProvider(EIdentityProvider); + + CleanupStack::PushL(pNew); + pNew->ConstructL(aEndpoint, aContract, aProviderID, aServiceID); + return pNew; + } + + + +EXPORT_C void CSenIdentityProvider::ConstructL(const TDesC8& aEndpoint) + { + if(aEndpoint.Length()>0) + { + CSenXmlServiceDescription::ConstructL(aEndpoint, KSenIdpLibertyIdWsfAsContract); + SetFrameworkIdL( KDefaultIdWsfFrameworkID ); + } + else + { + CSenXmlServiceDescription::ConstructL(); + } + } + +EXPORT_C void CSenIdentityProvider::ConstructL( const TDesC8& aEndpoint, + const TDesC8& aContract) + { + if(aContract.Length()>0) + { + CSenXmlServiceDescription::ConstructL(aEndpoint, aContract); + } + else + { + // Defaults to ID-WSF framework authentication service contract: + // - "urn:liberty:as:2004-04". + ConstructL(aEndpoint); + } + } + +EXPORT_C void CSenIdentityProvider::ConstructL( const TDesC8& aEndpoint, + const TDesC8& aContract, + const TDesC8& aProviderID) + { + ConstructL(aEndpoint, aContract); + if(aProviderID.Length()>0) + { + SetProviderID(aProviderID); + } + // else: no child element will be added + } + +EXPORT_C void CSenIdentityProvider::ConstructL( const TDesC8& aEndpoint, + const TDesC8& aContract, + const TDesC8& aProviderID, + const TDesC8& aServiceID) + { + ConstructL(aEndpoint, aContract, aProviderID); + if(aServiceID.Length()>0) + { + SetServiceID(aServiceID); + } + // else: no child element will be added + } + +////////////////////////////////////////////////////////////////////////// + + +EXPORT_C CSenIdentityProvider::~CSenIdentityProvider() + { + } + +EXPORT_C TPtrC8 CSenIdentityProvider::UserName() + { + TPtrC8 username = AuthzID(); + if (username.Length()==0) + { + return AdvisoryAuthnID(); + } + return username; + } + +EXPORT_C TPtrC8 CSenIdentityProvider::AuthzID() + { + return ContentOf( KSenIdpAuthzIDLocalname() ); + } + +EXPORT_C TPtrC8 CSenIdentityProvider::AdvisoryAuthnID() + { + return ContentOf( KSenIdpAdvisoryAuthnIdLocalname() ); + } + +EXPORT_C TPtrC8 CSenIdentityProvider::ProviderID() + { + return ContentOf( KSenIdpProviderIdLocalname() ); + } + +EXPORT_C TPtrC8 CSenIdentityProvider::Password() + { + return ContentOf( KSenIdpPasswordLocalname() ); + } + +EXPORT_C const TDesC8& CSenIdentityProvider::IMEI() + { + return KFakeIMEI8(); + } + +EXPORT_C TBool CSenIdentityProvider::IsDefault() + { + TBool ret = EFalse; + if ( AsElement().AttrValue( KDefaultIdentityAttributeName ) ) + { + ret = ETrue; + } + + return ret; + } +//EXPORT_C TInt CSenIdentityProvider::SetUserInfo(const TDesC8& aAuthzID, +// const TDesC8& aAdvisoryAuthnID, +// const TDesC8& aPassword ) +// { +// TInt leaveCode(KErrNone); +// TRAP(leaveCode, SetUserInfoL(aAuthzID, aAdvisoryAuthnID, aPassword)); +// return leaveCode; +// } + +EXPORT_C TInt CSenIdentityProvider::SetUserInfoL(const TDesC8& aAuthzID, + const TDesC8& aAdvisoryAuthnID, + const TDesC8& aPassword ) + { + // For MS this function sud be commented as WLM already send xml encoded password + //HBufC8* encPassword = SenXmlUtils::EncodeHttpCharactersLC(aPassword); + if(aAuthzID.Length()>0) + { + SetContentOfL(KSenIdpAuthzIDLocalname, aAuthzID); + } + if(aAdvisoryAuthnID.Length()>0) + { + SetContentOfL(KSenIdpAdvisoryAuthnIdLocalname, aAdvisoryAuthnID); + } + //if(aPassword.Length()>0) // in order to clean password, when listing accounts + { + SetContentOfL(KSenIdpPasswordLocalname, aPassword ); + } + //CleanupStack::PopAndDestroy(encPassword); + return KErrNone; + } + +EXPORT_C TInt CSenIdentityProvider::SetAccountExtensionsL(const TDesC8& aDetail) + { + SetContentOfL(KSenAccountExtensions, aDetail); + //CSenElement* elem = NULL; + //AddElementL(elem); + return KErrNone; + } + +EXPORT_C TPtrC8 CSenIdentityProvider::AccountExtensions(CSenElement*& aAccExt) + { + aAccExt = this->AsElement().Element(KSenAccountExtensions()); + return ContentOf( KSenAccountExtensions() ); + } + +EXPORT_C TBool CSenIdentityProvider::IsTrustedByL( + MSenServiceDescription& aServiceDescription ) + { + TBool retVal(EFalse); + TPtrC8 endpoint = aServiceDescription.Endpoint(); + TPtrC8 contract = aServiceDescription.Contract(); + + TPtrC8 providerID = ProviderID(); + if(providerID.Length()>0) + { + if((endpoint.Length() > 0) && (providerID.Length() > 0) + && endpoint == providerID) + { + retVal = ETrue; + } + } + + if(!retVal) // no need to allocate new array etc if we already have a trust + { + // owned elsewhere: + RPointerArray services = AsElement().ElementsL(); + TInt serviceCount = services.Count(); + TInt i(0); + while (!retVal && i < serviceCount) + { + if(services[i]->LocalName() == KServiceID) + { + TPtrC8 serviceID = services[i]->Content(); + + if(serviceID.Length()>0 && + ( (endpoint.Length() > 0 && serviceID == endpoint) + || + (contract.Length() > 0 && serviceID == contract)) + ) + { + retVal = ETrue; + } + } + i++; + } + } + + return retVal; + } + +EXPORT_C TBool CSenIdentityProvider::IsTrustedByL( const TDesC8& aProviderIdOrServiceId ) + { + //SENDEBUG_L("CSenIdentityProvider::IsTrustedByL"); + TBool trusted(EFalse); + TPtrC8 providerID = ProviderID(); + if(providerID.Length()>0) + { + if(aProviderIdOrServiceId == providerID) + { + //SENDEBUG_L(" The ProviderID's are equal."); + trusted = ETrue; + } + } + + if(!trusted) // no need for new array etc if we already have a trust + { + RPointerArray services = AsElement().ElementsL(); + TInt serviceCount = services.Count(); + TInt i(0); + while (!trusted && i < serviceCount) + { + if (services[i]->LocalName() == KServiceID ) + { + TPtrC8 serviceID = services[i]->Content(); + if (serviceID.Length()>0 && serviceID == aProviderIdOrServiceId) + { + trusted = ETrue; + } + } + i++; + } + } + return trusted; + } + +EXPORT_C TInt CSenIdentityProvider::SetProviderID( const TDesC8& aProviderID ) + { + TInt retVal(KErrNone); + TInt leaveCode(KErrNone); + TRAP( leaveCode, retVal = SetProviderIdL( aProviderID ); ) + if ( leaveCode ) + { + retVal = leaveCode; + } + return retVal; + } + +EXPORT_C TInt CSenIdentityProvider::SetProviderIdL( const TDesC8& aProviderID ) + { + if ( aProviderID.Length() == 0 ) + { + return KErrArgument; // zero-length provider ID + } + else + { + SetContentOfL( KSenIdpProviderIdLocalname, aProviderID ); + return KErrNone; + } + } + +EXPORT_C TInt CSenIdentityProvider::SetServiceID( const TDesC8& aServiceID ) + { + TInt retVal(KErrNone); + if(aServiceID.Length()>0) + { + TRAP(retVal, SetContentOfL(KServiceID, aServiceID);) + } + return retVal; + } + +// @deprecated. This method is no longer in use. Kept only to keep BC with 3.0 +EXPORT_C HBufC8* CSenIdentityProvider::HttpCredentialsL( MSenIdentityManager& /* aMgr */ ) + { + return NULL; + } + +// End of File +