/*

* Copyright (c) 2006-2006 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 "wsstarvalidatehandler.h"

#include "wsstartrustclient.h"

#include "sendebug.h"

#include "senlogger.h"

class CWSStarHandlerContext;

//---------------------------------------------------------------------------

// Create instance of concrete ECOM interface implementation

//---------------------------------------------------------------------------

//

CWSStarValidateHandler* CWSStarValidateHandler::NewL(TAny* aHandlerCtx)

    {

    MSenHandlerContext* handlerCtx =

        reinterpret_cast<MSenHandlerContext*>(aHandlerCtx);

    CWSStarValidateHandler* self   = new (ELeave) CWSStarValidateHandler(*handlerCtx);

    CleanupStack::PushL (self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

//---------------------------------------------------------------------------

// Constructor

//---------------------------------------------------------------------------

//

CWSStarValidateHandler::CWSStarValidateHandler(MSenHandlerContext& aCtx):CSenSessionHandler(aCtx)

    {

    }

//---------------------------------------------------------------------------

// Destructor

//---------------------------------------------------------------------------

//

CWSStarValidateHandler::~CWSStarValidateHandler()

    {

    }

//---------------------------------------------------------------------------

// Second phase construction.

//---------------------------------------------------------------------------

//

void CWSStarValidateHandler::ConstructL()

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,(_L("CWSStarValidateHandler::ConstructL()")));

    const TDesC8* version = iHandlerContext.GetDesC8L(HandlerContextKey::KVersion);

    if (version && 

        (*version == WSTrust::KTrustNamespace200502 || *version == WSTrust::KTrustNamespace200404))

        {

        iVersion = version;

        }

    else

        {

        iVersion = &WSTrust::KTrustNamespace200502; //passport interface 2

        //&WSTrust::KTrustNamespace200404;

        }

    }

//---------------------------------------------------------------------------

// the most emergent method in message handler interface.

// Each sub-class must implement this method thus providing message processing routine.

//---------------------------------------------------------------------------

//

TInt CWSStarValidateHandler::InvokeL(MSenSessionContext& 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;

        }

    //in session context we have info

    const TBool* renewingPtr = ((MSenContext&)aCtx).GetIntL(WSStarContextKeys::KReAuthNeeded);

    TBool renewing;

    if (renewingPtr)

        {

        renewing = *renewingPtr;

        }

    else

        {

        renewing = EFalse;

        }

    const TBool* onlySharingPtr = ((MSenContext&)aCtx).GetIntL(WSStarContextKeys::KOnlySharing);

    TBool onlySharing;

    if (onlySharingPtr)

        {

        onlySharing = *onlySharingPtr;

        }

    else

        {

        onlySharing = ETrue;

        }

    CWSStarTrustClient* pSTSClient = STSClientL(pIdentityProvider);

    if (pSTSClient)

            {

            TInt error(KErrNone);

            pSTSClient->SetHandlerCtx(&iHandlerContext);

            pSTSClient->SetVersion(iVersion);

            //validate session of concrete WebService

            HBufC8* errorMessage = NULL;

             // fix for compiler warning #550-D reverted back

            TRAPD(lerror,error = pSTSClient->ValidateL(*pNewSession, renewing, errorMessage, onlySharing);)    

            lerror = 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

            return error;

            }

       else

            {

            return KErrNotFound;

            }

    }

SenHandler::THandlerDirection CWSStarValidateHandler::Direction() const

    {

        return SenHandler::EBoth;

    };

SenHandler::THandlerPhase CWSStarValidateHandler::Phase()

    {

        return SenHandler::EValidate;

    };

//---------------------------------------------------------------------------

// Obtain or construct STS client

//---------------------------------------------------------------------------

//

CWSStarTrustClient* CWSStarValidateHandler::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 

    // architects says:- Yes... You must have AS registered into DAO (DB) sessions db

    /*if (!pSTSClient)

        {

        CSIF* sif = (CSIF*)iHandlerContext.GetAny(HandlerContextKey::KSIF());

        pSTSClient = CWSStarTrustClient::NewL(*sif,*Log());

        }*/

    return pSTSClient;

}

//---------------------------------------------------------------------------

// Create IdentityProvider from CoreManager

//---------------------------------------------------------------------------

//

CSenIdentityProvider* CWSStarValidateHandler::IdentityProviderFromCoreL(

                                            const TDesC8& aProviderID)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,"CWSStarValidateHandler::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 CWSStarValidateHandler::InitL(MSenHandlerContext& aCtx)

    {

    iHandlerContext = aCtx;

    return KErrNone;

    }

RFileLogger* CWSStarValidateHandler::Log() const

    {

    RFileLogger* pLog = NULL;

    TRAP_IGNORE( pLog = (RFileLogger*)iHandlerContext.GetAnyL(HandlerContextKey::KLogger); )

    return pLog;

    }

// END OF FILE