/*
* Copyright (c) 2009 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:
*
*/
//co-branding CR
#include <e32std.h>
#include "wsstarcobrandinghandler.h"
#include "wsstarcobrandingclient.h"
#include "senpointermap.h"
#include "wspolicy.h"
#include "sendebug.h"
#include "wsstardictionary.h"
#include "MSenServicePolicy.h"
#include "wsstarpolicymanager.h"
#include "senlogger.h"
//---------------------------------------------------------------------------
// Create instance of concrete ECOM interface implementation
//---------------------------------------------------------------------------
//
CWSStarCoBrandingHandler* CWSStarCoBrandingHandler::NewL(TAny* aHandlerCtx)
{
MSenHandlerContext* handlerCtx = reinterpret_cast<MSenHandlerContext*>(aHandlerCtx);
CWSStarCoBrandingHandler* self = new (ELeave) CWSStarCoBrandingHandler(*handlerCtx);
CleanupStack::PushL (self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
//---------------------------------------------------------------------------
// Constructor
//---------------------------------------------------------------------------
//
CWSStarCoBrandingHandler::CWSStarCoBrandingHandler(MSenHandlerContext& aCtx):CSenSessionHandler(aCtx)
{
}
//---------------------------------------------------------------------------
// Destructor
//---------------------------------------------------------------------------
//
CWSStarCoBrandingHandler::~CWSStarCoBrandingHandler()
{
TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("~CWSStarCoBrandingHandler::~CWSStarCoBrandingHandler()")));
}
//---------------------------------------------------------------------------
// Second phase construction.
//---------------------------------------------------------------------------
//
void CWSStarCoBrandingHandler::ConstructL()
{
TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarCoBrandingHandler::ConstructL()")));
}
//---------------------------------------------------------------------------
// the most emergent method in message handler interface.
// Each sub-class must implement this method thus providing message processing routine.
//---------------------------------------------------------------------------
//
TInt CWSStarCoBrandingHandler::InvokeL(MSenSessionContext& aCtx)
{
TLSLOG_L( KSenCoreServiceManagerLogChannelBase, KMinLogLevel, "CWSStarCoBrandingHandler::InvokeL(MSenMessageContext& aCtx)" );
//getting data from input
CWSStarServiceSession* pNewSession =
(CWSStarServiceSession*)aCtx.GetSenRemoteServiceSessionL(
WSStarContextKeys::KServiceSession());
if (pNewSession->ProviderID() == KNullDesC8)
{
return KErrNone;
}
//try to find identity provider for curennt webService using its ProviderId
CSenIdentityProvider* pIdentityProvider = IdentityProviderFromCoreL(
pNewSession->ProviderID());
if (!pIdentityProvider)
{
return KErrNotFound;
}
CWSStarTrustClient* pSTSClient = STSClientL(pIdentityProvider);
if (pSTSClient)
{
CSIF* sif = (CSIF*)iHandlerContext.GetAnyL(HandlerContextKey::KSIF());
CWSStarServiceSession* wsSTSSession =
pSTSClient->GetSTSSessionL();
CWSStarCoBrandingClient* wsStarCoBrandingClient =
CWSStarCoBrandingClient::NewL(*sif,*Log());
if (wsStarCoBrandingClient)
{
CleanupStack:: PushL(wsStarCoBrandingClient);
TInt error(KErrNone);
wsStarCoBrandingClient->SetHandlerCtx(&iHandlerContext);
//wsStarCoBrandingClient->SetVersion(iVersion);
wsStarCoBrandingClient->SetCoBrandingSessionL(wsSTSSession);
//validate session of concrete WebService
HBufC8* errorMessage = NULL;
TInt leaveCode( KErrNone );
TRAP( leaveCode, error = wsStarCoBrandingClient->FetchSCTL( *pNewSession, errorMessage ); )
#ifdef _SENDEBUG
if( leaveCode )
{
TLSLOG_L( KSenCoreServiceManagerLogChannelBase, KMinLogLevel, "CWSStarCoBrandingHandler::InvokeL(MSenMessageContext& aCtx):" );
TLSLOG_L( KSenCoreServiceManagerLogChannelBase, KMinLogLevel, "- wsStarCoBrandingClient->FetchSCTL() leaved!" );
}
#endif // _SENDEBUG
leaveCode = 0; // not used in release builds
//((MSenContext&)aCtx).Update(WSStarContextKeys::KReAuthNeeded, EFalse);
if (errorMessage)
{
((MSenContext&)aCtx).Update(WSStarContextKeys:: KErrMessage, *errorMessage);
}
delete errorMessage;
errorMessage = NULL;
//if credential expired session will use validator to obtain new
// Core / XML DAO takes ownership of new session (will keep in array of SD):
// - new session HAS
// - credential
// - context which keep for example key for signing message
// - if duplicate (equal primary keys) exists, it is deleted
CleanupStack:: PopAndDestroy(wsStarCoBrandingClient);
return error;
}
else
{
return KErrNotFound;
}
}
else
{
return KErrNotFound;
}
}
//---------------------------------------------------------------------------
// Obtain or construct STS client
//---------------------------------------------------------------------------
//
CWSStarTrustClient* CWSStarCoBrandingHandler::STSClientL(CSenIdentityProvider*& aIdentityProvider)
{
TLSLOG(KSenCoreServiceManagerLogChannelBase , KNormalLogLevel,(_L("CWSStarPlugin::STSClientL")));
CWSStarTrustClient* pSTSClient = NULL;
//providerId from Identities.xml
TPtrC8 providerId(KNullDesC8);
if(aIdentityProvider)
{
providerId.Set(aIdentityProvider->ProviderID());
}
RPointerArray<CSenWSDescription> serviceDescriptions;
CleanupClosePushL(serviceDescriptions);
//try to find STS session in cache,some STS can be registered
TInt retVal(KErrNone);
TRAPD(error, retVal = iHandlerContext.GetSenCoreServiceManager()->ServiceDescriptionsL(serviceDescriptions, KWSStarSTSContract()));
if(!retVal&&!error)
{
RPointerArray<CSenWSDescription> matches;
CleanupClosePushL(matches);
for(TInt i = 0; i < serviceDescriptions.Count(); i++)
{
//select XMLDescription from DAO where contract = STS, so we can cast
pSTSClient = (CWSStarTrustClient*)serviceDescriptions[i];
if(providerId.Length()>0)
{
TPtrC8 providerIDFromDescription = pSTSClient->ProviderID();
if(providerIDFromDescription == providerId)
{
matches.AppendL(pSTSClient);
}
}
else
{
matches.AppendL(pSTSClient);
}
}
if(matches.Count())
{
pSTSClient =
reinterpret_cast<CWSStarTrustClient*>(matches[0]);
pSTSClient->SetAccount(aIdentityProvider);
}
else
{
TLSLOG(KSenCoreServiceManagerLogChannelBase , KNormalLogLevel,(_L("CWSStarValidateHandler::STSClient - No matching STS description available!")));
pSTSClient = NULL;
}
//if we find multi sts client (different only with lifetime, probably Secure Context Token lifetime)
if(matches.Count() > 1)
{
// search for a instance with longest validity
for(TInt i = matches.Count()-1; i > 0 ; i--)
{
CWSStarTrustClient* pNewerSTSClient =
reinterpret_cast<CWSStarTrustClient*>(matches[i]);
CWSStarServiceSession* newerSession = (CWSStarServiceSession*)pNewerSTSClient->ServiceSession();
CWSStarServiceSession* session = (CWSStarServiceSession*)pSTSClient->ServiceSession();
if(newerSession && session) // STSClient Session was not set, if not validated
{
if(newerSession->ValidUntilL() > session->ValidUntilL())
{
pSTSClient = pNewerSTSClient;
pSTSClient->SetAccount(aIdentityProvider);
}
}
}
}
CleanupStack::PopAndDestroy(2, &serviceDescriptions);
}
else
{
CleanupStack::PopAndDestroy(&serviceDescriptions);
}
//no session, so we have create new STS client, temporary code
//- if (!pSTSClient)
//- {
//- CSIF* sif = (CSIF*)iHandlerContext.GetAnyL(HandlerContextKey::KSIF());
//- pSTSClient = CWSStarTrustClient::NewL(*sif,*Log());
//- }
return pSTSClient;
}
//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
//
SenHandler::THandlerDirection CWSStarCoBrandingHandler::Direction() const
{
return SenHandler::EBoth;
}
//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
//
SenHandler::THandlerPhase CWSStarCoBrandingHandler::Phase()
{
return SenHandler::EValidate;
}
//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
//
CSenIdentityProvider* CWSStarCoBrandingHandler::IdentityProviderFromCoreL(
const TDesC8& aProviderID)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KNormalLogLevel,"CWSStarCoBrandingHandler::IdentityProviderLFromCore");
CSenIdentityProvider* pIdentityProvider = NULL;
if(aProviderID.Length() > 0)
{
CDesC8ArrayFlat* array = new (ELeave) CDesC8ArrayFlat(1);
CleanupStack::PushL(array);
array->AppendL(aProviderID);
pIdentityProvider = iHandlerContext.GetSenCoreServiceManager()->
IdentityProviderL(*array, ETrue);
CleanupStack::PopAndDestroy(array);
}
return pIdentityProvider;
}
//---------------------------------------------------------------------------
// Init implementation
//---------------------------------------------------------------------------
//
TInt CWSStarCoBrandingHandler::InitL(MSenHandlerContext& aCtx)
{
iHandlerContext = aCtx;
return KErrNone;
}
//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
//
RFileLogger* CWSStarCoBrandingHandler::Log() const
{
RFileLogger* pLog = NULL;
TRAP_IGNORE( pLog = (RFileLogger*)iHandlerContext.GetAnyL(HandlerContextKey::KLogger); )
return pLog;
}
// END OF FILE