diff -r 000000000000 -r 62f9d29f7211 webservices/wsoviplugin/src/wsovioauthclient.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/webservices/wsoviplugin/src/wsovioauthclient.cpp Thu Jan 07 16:19:19 2010 +0200 @@ -0,0 +1,753 @@ +/* +* Copyright (c) 2008 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 "wsovioauthclient.h" + +#include +#include +#include +#include +#include "sencryptoutils.h" + +#include "wsoviservicesession.h" +#include "SenXmlUtils.h" +#include "msencoreservicemanager.h" +#include "sendebug.h" +#include "senlogger.h" +#include "MSenServiceDescription.h" +#include "SenServiceConnection.h" +#include "seninternalserviceconsumer.h" +#include +#include "wsoviplugin.h" +#include "SenHttpTransportProperties.h" +#include "senwspattern.h" +#include "wsovicons.h" +#include "wsovitokencreationresponse.h" +#include "sencryptoutils.h" +#include "wsoviutils.h" + +namespace + { + _LIT8(KRemoteConsumer, "RemoteConsumer"); + } + + +using namespace OAuth; +//--------------------------------------------------------------------------- +// Creates and returns a new instace of this class. +//--------------------------------------------------------------------------- +// +CWSOviOAuthClient* CWSOviOAuthClient::NewL( + CSIF& aSIF) + { + CWSOviOAuthClient* pNew = NewLC(aSIF); + CleanupStack::Pop(pNew); + return pNew; + } + +//--------------------------------------------------------------------------- +// Creates and returns a new instace of this class and leaves the object on the cleanup stack +//--------------------------------------------------------------------------- +// +CWSOviOAuthClient* CWSOviOAuthClient::NewLC( + CSIF& aSIF) + { + CWSOviOAuthClient* pNew = + new (ELeave) CWSOviOAuthClient( + aSIF, + MSenServiceDescription::EOviOAuthClient); + + CleanupStack::PushL(pNew); + pNew->BaseConstructL(); + return pNew; + } + +//--------------------------------------------------------------------------- +// Constructor +//--------------------------------------------------------------------------- +// +CWSOviOAuthClient::CWSOviOAuthClient( + CSIF& aSIF, + TDescriptionClassType aType) + : CSenInternalServiceConsumer(aType, aSIF) + { + } + +void CWSOviOAuthClient::BaseConstructL() + { + CSenInternalServiceConsumer::ConstructL(); + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSOviOAuthClient::ConstructL()"))); + } + +//--------------------------------------------------------------------------- +// Destructor +//--------------------------------------------------------------------------- +// +CWSOviOAuthClient::~CWSOviOAuthClient() + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviOAuthClient::~CWSOviTrustClient"); + delete iAuthSession; + delete iBody; + } + + +//--------------------------------------------------------------------------- +// The most siginificant method of this class. Make validation of session, +// credentails obtained if needed. +// Sequential logic, synchronized, +//--------------------------------------------------------------------------- +// +TInt CWSOviOAuthClient::ValidateL( CWSOviServiceSession& aSession, + HBufC8*& aErrorMessage, + TBool aOnlySharing ) + + { +// iAuthSession->CompleteServerMessagesOnOffL(ETrue); + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviOAuthClient::ValidateL(..)"); + TInt retVal(KErrNone); // for returning error codes + iWSOviServiceSession = &aSession; // save session + +//---------------------- +//0 token sharing, only if scope of token is not applied +//---------------------- + TBool sharingSucceed = EFalse; + RPointerArray oviSDs; + CleanupClosePushL(oviSDs); + CSenWSPattern* pattern = CSenWSPattern::NewLC(); + + //select * from session_of_SD where session is (ovi framework, and has same provideId && No scope of token) + + pattern->SetFrameworkIdL(KDefaultOviFrameworkID); + pattern->AsElement().AddElementL(KSenIdpProviderIdLocalname).SetContentL(iIdentityProvider->ProviderID()); + //if (iWSOviServiceSession->ScopeToken() == EFalse) then pattern->SetScopeToken(EFalse) + CWSOviServiceSession* oviSession = NULL; + TRAP(retVal, retVal = Framework().Manager().ServiceDescriptionsL(oviSDs, *pattern)); + + if(!retVal) + { + TInt count = oviSDs.Count(); + for(TInt i = 0; i < oviSDs.Count(); i++) + { + //all sessions, to eliminate client, just for case we check type + TDescriptionClassType dt = oviSDs[i]->DescriptionClassType(); + if (dt == MSenServiceDescription::EOviServiceSession) + { + oviSession = (CWSOviServiceSession*)oviSDs[i]; + //dont share to itself + if (oviSession != iWSOviServiceSession) + { + TRAPD(err, retVal = oviSession->ShareTokenWithL( + iWSOviServiceSession)); + if ((retVal == KErrNone) && (err == KErrNone)) + { + sharingSucceed = ETrue; + break; + } + } + } + } + if ( !sharingSucceed ) + { + // Did not find valid token (<=> sharingSucceed == EFalse) + // + // Try to search valid toeken directly from CredentialManager + // (This is needed especially in case when token is imported + // through Public API + // => There is not yet Session which holds imported token) + if ( iWSOviServiceSession->TryToSearchValidCredentialL() == KErrNone ) //codescannerwarnings + { + iWSOviServiceSession->SetStatusL(); + iWSOviServiceSession->AddSecurityTokenToContextL(); + sharingSucceed = ETrue; + } + } + } + CleanupStack::PopAndDestroy(2, &oviSDs); + + + if (sharingSucceed) + { + iWSOviServiceSession->SetTrustAnchorL(iIdentityProvider->ProviderID()); + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviOAuthClient::ValidateL(..) - sharing succed, we don't need more validation"); + return KErrNone; + } + if (aOnlySharing) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSStarTrustClient::ValidateL(..) - only sharing was allowed so NO continuation"); + return KErrNone; + } + +//----------------- +//1 Init session +//----------------- + + if (!iAuthSession)// if AuthenticationClient has NOT been registered earlier + { + iAuthSession = CWSOviServiceSession::NewL(Framework()); + iAuthSession->InitializeFromL(*this); + iAuthSession->SetEndPointL(iIdentityProvider->Endpoint()); + iAuthSession->SetContractL(KWSOviAuthenticationServiceContract); + iAuthSession->AddConsumerL(*this); + } + CSenXmlReader* reader = Framework().Manager().XMLReader(); + CWSOviSessionContext* NAUTHSsnContext = iAuthSession->SessionContext(); + + + +//----------------- +//2.preparing context +//----------------------- + TInt retryCounter(0); + TBool retry(ETrue); + TBool authenticationInfoPromptedFromUser(EFalse); + TPckgBuf authInfo; + HBufC8* response = NULL; + MSenRemoteServiceConsumer* pConsumer = NULL; + + while ( retry ) // Authentication loop starts + { + retry = EFalse; + //building body + CWSOviPlugin& frmWSOvi = (CWSOviPlugin&)Framework(); + const TDesC8* version = iHndCtx->GetDesC8L(HandlerContextKey::KVersion); + TTime time; + time.UniversalTime(); + + TPtrC8 userName(KNullDesC8); + TPtrC8 password(KNullDesC8); + if ( authenticationInfoPromptedFromUser ) + { + userName.Set(authInfo().iUsername); + password.Set(authInfo().iPassword); + } + else + { + userName.Set(iIdentityProvider->UserName()); + password.Set(iIdentityProvider->Password()); + } + HBufC8* created(NULL); + CWSOviSessionContext* sessioncontext = iWSOviServiceSession->SessionContext(); + const TInt* diffHandlerContext = iHndCtx->GetIntL(HandlerContextKey::KDiff); + if( diffHandlerContext && *diffHandlerContext > 0 ) + { + TTimeIntervalMinutes minutes(*diffHandlerContext); + TTime diff = time - minutes; + time -= TTimeIntervalMicroSeconds(diff.Int64()); + created = SenCryptoUtils::GetTimestampL(time); + } + else + { + created = SenCryptoUtils::GetTimestampL(); + } + CleanupStack::PushL(created); + CreateBodyL(*version, + userName, + password, + *created); + CleanupStack::PopAndDestroy(created); + + + //----------------- + //_____________________________________SYNC Sending____________________________________________ + + CSenHttpTransportProperties* transProp = CSenHttpTransportProperties::NewLC(); + + // IAP dialog used to appear though IAP id is provided as a part of Service Description + // Get the IAP setting and accordingly set the transport properties + TUint32 id = 0; + TInt getIapRetCode = IapId(id); + + // Check whether IAP ID is pre-defined, and copy it only if such property value is found + //if ( getIapRetCode == KErrNone && id < 4294967295) // unsigned 4294967295 == -1 signed + if ( getIapRetCode == KErrNone && id < (TUint32)KErrNotFound) // unsigned 4294967295 == -1 signed + { + transProp->SetIapIdL(id); + } + // ETMI-6WAGDB end + + //limit http timeout, + // if NAUTH hangs and can not send any response, then we block every async client method. + // Possibel revalidation during sendL can take too long time therefore we create new limit + transProp->SetMaxTimeToLiveL(WSOviSession::KMaxHttpTimeOut); + transProp->SetBoolPropertyL(OAuth::KNeedSecurity(), EFalse); + transProp->SetEndpointResourceL(WSOviSession::KTokenEndpointSuffix()); +// transProp->SetContentTypeL(KFormUrlEncoded()); + +//set consumer keys for proper DB + HBufC8* providerTP(NULL); + iIdentityProvider->TransportPropertiesL(providerTP); + if (providerTP) + { + CleanupStack::PushL(providerTP); + CSenHttpTransportProperties* httpProviderTP = CSenHttpTransportProperties::NewLC(*providerTP, *reader); + if (httpProviderTP) + { + TPtrC8 content(KNullDesC8); + httpProviderTP->PropertyL(KNCIMConsumerKeyId , content); + if (content.Length()) + { + transProp->SetPropertyL(KNCIMConsumerKeyId, content); + } + httpProviderTP->PropertyL(KNCIMConsumerSecret , content); + if (content.Length()) + { + transProp->SetPropertyL(KNCIMConsumerSecret, content); + } + httpProviderTP->PropertyL(KNCIMConsumerServiceId , content); + if (content.Length()) + { + transProp->SetPropertyL(KNCIMConsumerServiceId, content); + } + /*TUint32 id = 0; + if (! httpProviderTP->SnapIdL(id)) + { + transProp->SetSnapIdL(id); + }*/ + CleanupStack::PopAndDestroy(httpProviderTP); + } + CleanupStack::PopAndDestroy(providerTP); + } + + // setting SNAP/IAP + if(!iAuthSession->IapId(id) ) + { + transProp->SetIapIdL(id); + transProp->SetSnapIdL(0); + } + else if(!iAuthSession->SnapId(id) ) + { + transProp->SetSnapIdL(id); + transProp->SetIapIdL(0); + } + + + HBufC8* transPropAsXml = transProp->AsUtf8LC(); +// HBufC8* bodyEncodedUrl = CWSOviUtils::FormEncodeCharsLC(*pBody); +// _LIT8(KXmlContent, "XMLContent="); +// HBufC8* allBody = HBufC8::NewL(KXmlContent().Length()+bodyEncodedUrl->Length()); +// allBody->Des().Append(KXmlContent()); +// allBody->Des().Append(*bodyEncodedUrl); +// CleanupStack::PushL(allBody); +//----------------- +//3.submitting +//------------------- + retVal = iAuthSession->SubmitL(*iBody, *transPropAsXml, *this, response); + + aSession.SetTransportL(ipTransport);//ownership moved + ipTransport = NULL; + + if (!response) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviOAuthClient::ValidateL - Response is empty - 1"); + CleanupStack::PopAndDestroy(transPropAsXml); + CleanupStack::PopAndDestroy(transProp); + return retVal; + } + + const TInt* diffContext = iHndCtx->GetIntL(HandlerContextKey::KDiff); + if (diffContext && *diffContext > 0) + { + delete response; + response = NULL; + TTime time; + time.UniversalTime(); + TTimeIntervalMinutes minutes(*diffContext); + TTime diff = time-minutes; + time -= TTimeIntervalMicroSeconds(diff.Int64()); + HBufC8* created = SenCryptoUtils::GetTimestampL(time); + CleanupStack::PushL(created); + CreateBodyL(*version, + userName, + password, + *created); + CleanupStack::PopAndDestroy(created); + retVal = iAuthSession->SubmitL(*iBody, *transPropAsXml, *this, response); + aSession.SetTransportL(ipTransport);//ownership moved + ipTransport = NULL; + } + + CleanupStack::PopAndDestroy(transPropAsXml); + CleanupStack::PopAndDestroy(transProp); + CleanupStack::PushL(response); + + if ( retVal ) + { + CWSOviSessionContext* pSessionContext = iWSOviServiceSession->SessionContext(); + TAny* ptr = pSessionContext->GetAnyL(KRemoteConsumer()); //codescannerwarnings + if ( ptr ) + { + pConsumer = REINTERPRET_CAST(MSenRemoteServiceConsumer*, ptr); + } + else + { + pConsumer = iWSOviServiceSession->Consumer(); + } + + if ( pConsumer && !pConsumer->HasAuthenticationCallback() && + retryCounter < 3 ) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviOAuthClient::ValidateL - Consumer does not have AuthenticationCallback"); + + const TDesC8* pValue = iIdentityProvider->AsElement().AttrValue( KSenAttrPromptUserInfo ); + +#ifdef _RD_SEN_WS_STAR_DO_NOT_PROMPT_AUTHINFO_BY_DEFAULT + if ( pValue && *pValue != _L8("false") ) + // attribute has to exist, otherwise logic defaults to: DO NOT PROMPT +#else + if ( !pValue || *pValue != _L8("false") ) + // even when attribute does NOT exist, or when it does and has any other value but "false", default to: PROMPT +#endif + { + const TBool* renewingPtr = NAUTHSsnContext->GetIntL(WSOviContextKeys::KReAuthNeeded); + if ( renewingPtr && *renewingPtr ) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KNormalLogLevel,"- Prompt is used to get AuthenticationInfo"); + TInt ret = (Framework().Manager()).AuthenticationForL(*iIdentityProvider, + authInfo); + if ( ret == KErrNone ) + { + retryCounter++; + retry = ETrue; + authenticationInfoPromptedFromUser = ETrue; + } + } + } + else + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KNormalLogLevel,"CWSOviOAuthClient::ValidateL - promptUserInfo = false"); + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KNormalLogLevel," => prompt is not used."); + } + } + if ( pConsumer && pConsumer->HasAuthenticationCallback() && + retryCounter < 3 ) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KNormalLogLevel,"CWSOviOAuthClient::ValidateL - Consumer has AuthenticationCallback"); + + const TDesC8* pValue = iIdentityProvider->AsElement().AttrValue( KSenAttrPromptUserInfo ); + + if ( !pValue || *pValue != _L8("false") ) + { + const TBool* renewingPtr = NAUTHSsnContext->GetIntL(WSOviContextKeys::KReAuthNeeded); + if ( renewingPtr && *renewingPtr ) + { + retVal = KErrSenFailedAuthentication; + } + } + else + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KNormalLogLevel,"CWSOviOAuthClient::ValidateL - UserInfoPrompt = false"); + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KNormalLogLevel," => AuthenticationCallback is not used."); + } + + } + } + + if ( retry ) + { + CleanupStack::PopAndDestroy(response); + } + } // Authentication loop ends + + HBufC8* ttlCreated = SenCryptoUtils::GetTimestampL(); + CleanupStack::PushL(ttlCreated); + User::LeaveIfError(iWSOviServiceSession->SessionContext()->Update(WSOviContextKeys::KTokenCreationTime,*ttlCreated)); + CleanupStack::PopAndDestroy(ttlCreated); + + + if (retVal != KErrNone) + { + TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KNormalLogLevel, _L8("CWSOviOAuthClient::ValidateL - error when submit to NAUTH %d"), retVal)); + iWSOviServiceSession->SessionContext()->Remove(WSOviContextKeys::KTokenCreationTime); + + if (response) + { + aErrorMessage = response; + } + + CleanupStack::Pop(response); + return retVal; + } + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviOAuthClient::ValidateL - response from NAUTH is a valid SOAP"); +//----------------- +//4 building response +//----------------- + CWSOviTokenCreationResponse* responseFragment = CWSOviTokenCreationResponse::NewLC(); + responseFragment->SetReader(*Framework().Manager().XMLReader()); + responseFragment->BuildFrom(*response); + + TPtrC8 ttl = responseFragment->TTL(); + TBool ttlInfinitive = EFalse; +// _LIT8(KTempTTL,"1000"); + if (ttl.Length()) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,ttl); + User::LeaveIfError(iWSOviServiceSession->SessionContext()->Update(WSOviContextKeys::KTTL,ttl)); + } + else + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviOAuthClient::ValidateL - ttl is missing"); + const TInt KMaxTTLLength = 20; + TBuf8 ttlMaxInt; + ttlMaxInt.AppendNum(KMaxTInt); + User::LeaveIfError(iWSOviServiceSession->SessionContext()->Update(WSOviContextKeys::KTTL,ttlMaxInt)); + ttlInfinitive = ETrue; + } + TPtrC8 tokenSecret = responseFragment->TokenSecret(); + if (tokenSecret.Length()) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,tokenSecret); + User::LeaveIfError(iWSOviServiceSession->SessionContext()->Update(WSOviContextKeys::KTokenSecret,tokenSecret)); + } + TPtrC8 token = responseFragment->Token(); + if (!token.Length()) + { + iWSOviServiceSession->SessionContext()->Remove(WSOviContextKeys::KTokenCreationTime); + retVal = KErrNotFound; + } + else + { + TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,token); + if (!iWSOviServiceSession->ExistConsumerL()) + { + iWSOviServiceSession->SessionContext()->Remove(WSOviContextKeys::KTokenCreationTime); + retVal = KErrNotFound; + } + else + { + iWSOviServiceSession->SetTrustAnchorL(iIdentityProvider->ProviderID()); + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviOAuthClient::ValidateL - set ctx basing on response"); + retVal = iWSOviServiceSession->SessionContext()->SetTokenKeysL(token); + if (retVal) + { + aErrorMessage = response; + } + } + } + CleanupStack::PopAndDestroy(responseFragment); + + if (!aErrorMessage) + { + if (!ttlInfinitive) + { + iWSOviServiceSession->ActiveTicketObserverL(); + } + CleanupStack::PopAndDestroy(response); + } + else + { + CleanupStack::Pop(response); + } + return retVal; + } + + + +//--------------------------------------------------------------------------- +// SetStatus +//--------------------------------------------------------------------------- +// + +void CWSOviOAuthClient::SetStatus(TInt /*aStatus */) + { + // No implementation in Java + } + +//--------------------------------------------------------------------------- +// SetAccount +//--------------------------------------------------------------------------- +// +void CWSOviOAuthClient::SetAccount( + CSenIdentityProvider* aIdentityProvicer) + { + iIdentityProvider = aIdentityProvicer; + } + + +//--------------------------------------------------------------------------- +// ServiceSession +//--------------------------------------------------------------------------- +// +CSenServiceSession* CWSOviOAuthClient::ServiceSession() + { + return iWSOviServiceSession; + } + +//--------------------------------------------------------------------------- +// Obtain Transport using a factory from Core Manager +//--------------------------------------------------------------------------- +// +MSenTransport& CWSOviOAuthClient::TransportL() + { + if(!ipTransport) + { + // Core is capable of working as transport factory, too. + // The returned transport instancies may or may not be + // ECOM plugins: + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviOAuthClient::Instantiating new transport"); + ipTransport = Framework().Manager().CreateL(*iAuthSession, iAuthSession); + } + return *ipTransport; + } +//--------------------------------------------------------------------------- +// SetNAUTHSessionL +//--------------------------------------------------------------------------- +// +void CWSOviOAuthClient::SetAuthSessionL( + CWSOviServiceSession* aSession) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviOAuthClient::SetServiceSessionL"); + _LIT8(KTouch, "touch"); + // free memory + //delete iAuthSession; + const TDesC8* attrValue = aSession->AsElement().AttrValue(KTouch); + if(attrValue != NULL) + { + AsElement().AddAttrL(KTouch, *attrValue); + } + iAuthSession = aSession; + if(iAuthSession) + { + iAuthSession->AddConsumerL(*this); + } + } + + +//--------------------------------------------------------------------------- +// Getter for endpoint +//--------------------------------------------------------------------------- +// +TPtrC8 CWSOviOAuthClient::Endpoint() + { + return iAuthSession->Endpoint(); + } +//--------------------------------------------------------------------------- +// Getter for contract +//--------------------------------------------------------------------------- +// +TPtrC8 CWSOviOAuthClient::Contract() + { + return iAuthSession->Contract(); + } +//--------------------------------------------------------------------------- +// Getter for providerId +//--------------------------------------------------------------------------- +// +TPtrC8 CWSOviOAuthClient::ProviderID() + { + return iAuthSession->ProviderID(); + } + +//--------------------------------------------------------------------------- +// Getter for framework +//--------------------------------------------------------------------------- +// +TPtrC8 CWSOviOAuthClient::FrameworkId() + { + return iAuthSession->FrameworkId(); + } +//--------------------------------------------------------------------------- +// serialie to xml +//--------------------------------------------------------------------------- +// +void CWSOviOAuthClient::WriteAsXMLToL(RWriteStream& aWriteStream) + { + iAuthSession->WriteAsXMLToL(aWriteStream); + } + +MSenServicePolicy* CWSOviOAuthClient::ServicePolicy() + { + return iAuthSession->ServicePolicy(); + } +TInt CWSOviOAuthClient::IapId(TUint32& aCurrentIapId) + { + return iAuthSession->IapId(aCurrentIapId); + } + + + +TBool CWSOviOAuthClient::HasSuperClass( TDescriptionClassType aType ) + { + if( aType == MSenServiceDescription::ESenInternalServiceConsumer ) // direct superclass! + { + // If asked type is the know *direct* father/mother, return true: + return ETrue; + } + else + { + // Otherwise, ask from superclass (chain, recursively) + return CSenInternalServiceConsumer::HasSuperClass( aType ); + } + } + +void CWSOviOAuthClient::SetHandlerCtx(MSenHandlerContext* aHndCtx) + { + iHndCtx = aHndCtx; + } +TBool CWSOviOAuthClient::HasEqualPrimaryKeysL(MSenServiceDescription& aCandidate) + { + TBool retVal(EFalse); + if ( CSenWSDescription::HasEqualPrimaryKeysL(aCandidate) ) + { + // Endpoint, Contract and FrameworkID match, all of them. + // Now, in WS-Ovi, also check ProviderID + if (aCandidate.DescriptionClassType() == DescriptionClassType()) + { + CWSOviOAuthClient& AuthenticationCandidate = (CWSOviOAuthClient&)aCandidate; + if (AuthenticationCandidate.ProviderID() == ProviderID()) + { + retVal = ETrue; + } + } + } + return retVal; + } + +void CWSOviOAuthClient::CreateBodyL(const TDesC8& aXmlNs, const TDesC8& aUsername, const TDesC8& aPassword, const TDesC8& aCreated) + { + delete iBody; + iBody = NULL; + HBufC8* nonce = SenCryptoUtils::GetRandomNonceL(); + CleanupStack::PushL(nonce); + HBufC8* passDec = SenXmlUtils::DecodeHttpCharactersLC( aPassword ); + HBufC8* digest = CWSOviUtils::DigestAuthStringL(*nonce, aCreated, aUsername, *passDec); + CleanupStack::PopAndDestroy(passDec); + CleanupStack::PushL(digest); + + iBody = HBufC8::NewL(KCreationRequestFormat8().Length() + + aXmlNs.Length() + + aUsername.Length() + + nonce->Length() + + aCreated.Length() + + digest->Length()); + TPtr8 ptr = iBody->Des(); + ptr.Format(KCreationRequestFormat8, + &aXmlNs, + &aUsername, + &(nonce->Des()), + &aCreated, + &(digest->Des())); + CleanupStack::PopAndDestroy(digest); + CleanupStack::PopAndDestroy(nonce); + } + +TBool CWSOviOAuthClient::Matches(MSenServiceDescription& aOtherServiceDescription) + { + return iAuthSession->Matches(aOtherServiceDescription); + } +// End of file +