/*

* 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 "wsoviplugin.h"

#include "SenServiceConnection.h" // framework IDs, error codes

#include "sendebug.h"

#include "senlogger.h"

#include "MSenServiceDescription.h"

#include "wsoviservicesession.h"

#include "SenXmlUtils.h"

#include "senguidgen.h"

#include "wsovitokencreationresponse.h"

#include <SenHttpTransportProperties.h>

#include "sencryptoutils.h"

#include "wsoviserviceupdatehandler.h"

#include "wsovivalidatehandler.h"

using namespace WSOviConfig;

using namespace OAuth;

// Local CONSTANTS

const TInt KMaxLengthXml  = 1280; 

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

// Create instance of concrete ECOM interface implementation

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

//

CWSOviPlugin* CWSOviPlugin::NewL(TAny* aManager)

    {

    MSenCoreServiceManager* manager =

        reinterpret_cast<MSenCoreServiceManager*>(aManager);

    CWSOviPlugin* self = new (ELeave) CWSOviPlugin(*manager);

    CleanupStack::PushL (self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Constructor

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

//

CWSOviPlugin::CWSOviPlugin(MSenCoreServiceManager& aManager)

    : iManager(aManager),

      iVersions(ETrue, ETrue)

    {

    }

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

// Destructor

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

//

CWSOviPlugin::~CWSOviPlugin()

    {

    iMsgHandlers.ResetAndDestroy();

    iSessionHandlers.ResetAndDestroy();

    iHandlerContexts.ResetAndDestroy();

    iVersions.Reset();

    iIMSI.Close();

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSOviPlugin::~CWSOviPlugin()")));

    }

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

// Second phase construction.

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

//

void CWSOviPlugin::ConstructL()

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSOviPlugin::ConstructL")));

    BaseConstructL(KFrameworkXMLNS, KFrameworkLocalName);

    //load default setup of handlers

    AddHandlerL(KValidateValue, KValidateHandlerVersion, SenHandler::ESessionHandler);

    AddHandlerL(KRegisterValue, KNullDesC8, SenHandler::ESessionHandler);

    AddHandlerL(KCredentialCollectorValue, KNullDesC8, SenHandler::EMessageHandler);

    AddHandlerL(KDeviceValue, KNullDesC8, SenHandler::EMessageHandler);

    AddHandlerL(KSecurityValue, KNullDesC8, SenHandler::EMessageHandler);

    AddHandlerL(KEncoderValue, KNullDesC8, SenHandler::EMessageHandler);

    AddHandlerL(KServiceUpdateValue, KNullDesC8, SenHandler::ESessionHandler);

    }

//========================================================

//                MSIF SPecific

//========================================================

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

// Attempt to register the ServiceDescription to the ServiceManager 

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

//

TInt CWSOviPlugin::RegisterServiceDescriptionL(

    MSenServiceDescription& aServiceDescription )

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSOviPlugin::RegisterServiceDescriptionL(.)")));

    TInt error(KErrNone);

    CWSOviSessionContext* pSessionRegisterCtx = CWSOviSessionContext::NewLC();

    pSessionRegisterCtx->Add(WSOviContextKeys::KServiceDescription(),

            (CSenWSDescription*)&aServiceDescription);

    pSessionRegisterCtx->Add(WSOviContextKeys::KRegisterAction(),

            WSOviContextValues::KActionRegister());

//SOA for S60 Composable Handler Framework v0.1 - 7.5.3.1 point 1)            

    CSenSessionHandler* pregisterHandler = 

                (CSenSessionHandler*)Handler(KRegisterValue());

    TRAPD(errorL,error= pregisterHandler->InvokeL(*pSessionRegisterCtx));

    if (errorL!=KErrNone)

        {

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSOviPlugin::RegisterServiceDescriptionL() !!!!leave from RegisterHandler")));

        error = errorL;

        }

    CleanupStack::PopAndDestroy(pSessionRegisterCtx);

    return error;

    }

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

// Attempt to unregister the ServiceDescription from the ServiceManager 

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

//

TInt CWSOviPlugin::UnregisterServiceDescriptionL(

    MSenServiceDescription& aServiceDescription)

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSOviPlugin::UnRegisterServiceDescriptionL(.)")));

//SOA for S60 Composable Handler Framework v0.1  - 7.5.3.1 point 1)            

    TInt error(KErrNone);

    CSenSessionHandler* pregisterHandler = 

                (CSenSessionHandler*)Handler(KRegisterValue());

    CWSOviSessionContext* pSessionRegisterCtx = CWSOviSessionContext::NewLC();

    pSessionRegisterCtx->Add(WSOviContextKeys::KServiceDescription(),

            (CSenWSDescription*)&aServiceDescription);

    pSessionRegisterCtx->Add(WSOviContextKeys::KRegisterAction(),

            WSOviContextValues::KActionUnregister());

    TRAPD(errorL,error = pregisterHandler->InvokeL(*pSessionRegisterCtx));

    if (errorL!=KErrNone)

        {

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSOviPlugin::UnregisterServiceDescriptionL() !!!!leave from RegisterHandler")));

        error = errorL;

        }

    CleanupStack::PopAndDestroy(pSessionRegisterCtx);

    return error;

    }

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

// Getter of framework ("WS-Ovi")

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

//

const TDesC8& CWSOviPlugin::Id()

    {

    return KDefaultOviFrameworkID();

    }

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

// Try to find one or more services that match the given ServiceDescription.

//    Adding is only invoked if NO! session in cache. 

//    Its mean that we have create new one.

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

//

TInt CWSOviPlugin::AddServiceDescriptionL( MSenServiceDescription& aPattern,

                                            MSenRemoteServiceConsumer& aRemoteConsumer,

                                            HBufC8*& aErrorMessage )

    {

    TInt addedSD(0);

    //-----1.no disco phase

    //-----2.establish credential and put to session

    //-----3.set validator. Enables re-auth for cases when credential is expired between init and send

    if(aPattern.FrameworkId() != KDefaultOviFrameworkID)

        {

        TLSLOG_L(KSenClientSessionLogChannelBase+aRemoteConsumer.ConnectionId(),KNormalLogLevel ,"CWSOviPlugin::AddServiceDescriptionL - this is not KDefaultWSOviFrameworkID");

        addedSD = 0; // zero added

        }

    else if( aPattern.Endpoint().Length() > 0 && aPattern.Contract().Length() > 0 )

        {

        CWSOviServiceSession* pNewSession = CWSOviServiceSession::NewL(*this);

        CleanupStack::PushL(pNewSession);

        // InitializeFromL copies the contract and endpoint of concrete service

        //  also context will be set

        pNewSession->InitializeFromL(aPattern);

        pNewSession->AddConsumerL(aRemoteConsumer);

        pNewSession->SessionContext()->Update(WSOviContextKeys::KOnlySharing, EFalse);

//SOA for S60 Composable Handler Framework v0.1  - 7.5.3.1 point 3)        

        TInt error = ProcessOutboundValidationL( aPattern, 

                                                (MSenRemoteServiceSession*)pNewSession,

                                                aErrorMessage );

        TLSLOG_FORMAT((KSenClientSessionLogChannelBase+aRemoteConsumer.ConnectionId(), KMinLogLevel , _L8("CWSOviPlugin::AddServiceDescriptionL - ProcessOutboundValidation returned: %d"), error));

        if ( error )

            {

            if (error>KErrNone)

                {

                addedSD = KErrSenAuthenticationFault;

                }

            else

                {

                addedSD = error;

                }

            CleanupStack::PopAndDestroy(pNewSession);

            }

        else // BOTH outbound validation and policy handler invokation OK(!):

            {

            Manager().AddServiceDescriptionL((CSenWSDescription*)pNewSession);

            addedSD = 1;

            CleanupStack::Pop(pNewSession); //now session is owned by Core / XML DAO

            }

        }

    else

        {

        TLSLOG_L(KSenClientSessionLogChannelBase+aRemoteConsumer.ConnectionId(),KMinLogLevel ,"CWSOviPlugin::AddServiceDescriptionL - No endpoint AND no contract; new session could not be added.");

        addedSD = 0; // zero added

        }

    return addedSD;

    }

TBool CWSOviPlugin::IsTrustedClient(MSenRemoteServiceConsumer& aRemoteConsumer)

    {

    TSecureId sid = aRemoteConsumer.SecureId();    

    //_LIT_SECURE_ID(nokia_chateventmonitorserver, 0x2001B2C5 );

    TVendorId vendor = aRemoteConsumer.VendorId();

	_LIT_VENDOR_ID(trustedVendor,VID_DEFAULT);

    if (vendor.iId == trustedVendor.iId )

        return ETrue;

    else

        return EFalse;

    }

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

// Create a ServiceSession based upon the given ServiceDescription.

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

//

TInt CWSOviPlugin::CreateServiceSessionL( MSenServiceDescription& aServiceDescription,

                                           MSenServiceDescription& aPattern,

                                           CSenServiceSession*& aNewSession,

                                           MSenRemoteServiceConsumer& aRemoteConsumer,

                                           HBufC8*& aErrorMessage )

    {

    if (!IsTrustedClient(aRemoteConsumer)) return KErrPermissionDenied;

    TInt error(KErrNone);

    if( aServiceDescription.DescriptionClassType() == MSenServiceDescription::EOviServiceSession )

        {

        //usecase:  when init connection with not registered description, nothing in db

        //usecase:  when bootup and description was already in db (registered during parsing db.file)

        aNewSession = (CWSOviServiceSession*) &aServiceDescription;

        aNewSession->SetStatusL();

        TLSLOG_L(KSenClientSessionLogChannelBase+aRemoteConsumer.ConnectionId(),KMinLogLevel ,"CWSOviPlugin::ServiceDescription is already a ServiceSession");

        }

    else

        {

        aNewSession = (CWSOviServiceSession*) NewServiceDescriptionL();

        error = ((CWSOviServiceSession*)aNewSession)->InitializeFromL( aServiceDescription );

        }

    if(aNewSession && !error)//if session was just created, its possible that its not validate

        {

        if(!aNewSession->IsReadyL())

            {

            TLSLOG_L(KSenClientSessionLogChannelBase+aRemoteConsumer.ConnectionId(),KMinLogLevel ,"CWSOviPlugin::ServiceSession is not ready");

            //usecase: when credential was parsed(exiNAUTH) and additionally expired.

            //         We don't need revalidate if credentials doesnt exist at all

            CWSOviSessionContext* pSessionValidateCtx = ((CWSOviServiceSession*)aNewSession)->SessionContext();

            if (!pSessionValidateCtx) //sessionCts exist if revalidation is processing

                {

                pSessionValidateCtx = CWSOviSessionContext::NewLC();

                pSessionValidateCtx->Add(WSOviContextKeys::KServiceSession(), *(MSenRemoteServiceSession*)aNewSession);

                ((CWSOviServiceSession*)aNewSession)->SetSessionContext(pSessionValidateCtx);

                CleanupStack::Pop(pSessionValidateCtx);

                }

            pSessionValidateCtx->Update(WSOviContextKeys::KRemoteConsumer(),

                                        &aRemoteConsumer);

            aNewSession->AddConsumerL(aRemoteConsumer);

            pSessionValidateCtx->Update(WSOviContextKeys::KOnlySharing, EFalse);   

            error = ProcessOutboundValidationL( aPattern, 

                                               (MSenRemoteServiceSession*)aNewSession,

                                               aErrorMessage );

            if (error) aNewSession->RemoveConsumerL(aRemoteConsumer);

            if (error>KErrNone)

                {

                error = KErrSenAuthenticationFault;

                }

            }

        else

            {

            //usecase: when credential was parsed(exiNAUTH) and credential is valid.

            // We start credential monitor and revalidation is start when credential expired. 

            TLSLOG_L(KSenClientSessionLogChannelBase+aRemoteConsumer.ConnectionId(),KMinLogLevel ,"CWSOviPlugin::Call ActiveTicketObserverL()");

            ((CWSOviServiceSession*)aNewSession)->ActiveTicketObserverL();

            }

        }

    return error;

    }

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

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

//

TInt CWSOviPlugin::OnEvent( const TInt aEvent, TAny* /*apArgument*/ )

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSOviPlugin::OnEvent");

    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("  -event code: %d"), aEvent));

    TInt retCode( KErrNone );

    switch( aEvent)

        {

        case KSenEventWsfReady:

            {

            TPtrC8 imsi = iManager.IMSI();

            if (iIMSI.Compare(imsi))

            	{

            	const RPointerArray<CSenIdentityProvider> list = iManager.IdentityProvidersL();

        	    for (TInt i = 0; i<list.Count(); i++)

    	            {

    	            CSenElement* el(NULL);

    	            list[i]->AccountExtensions(el);

    	            if (el)

    	            	{

    	            	delete (el->RemoveElement(KSenAccAutoSignIn));

    	            	((MSenCredentialManager&)iManager).RemoveCredentialsL(list[i]->ProviderID());

    	            	}

    	            //((MSenCredentialManager&)iManager).RemoveCredentialsL(list[i]->ProviderID());

    	            }

        	    iIMSI.Close();

        	    iIMSI.Create(imsi);

        	    }

            }

            break;

        case KSenEventRegisterIdentityProvider:

        case KSenEventUnregisterIdentityProvider:

            {

            TInt policyLeave(KErrNone);

            TRAP(policyLeave, VerifyPermissionOnEachSessionL(); )

            if ( policyLeave & !retCode )

                {

                retCode = policyLeave;

                }

            }

            break;

        default:

            {

            // do nothing

            }

        }

    return retCode;

    }

void CWSOviPlugin::VerifyPermissionOnEachSessionL()

    {

    CSenWSDescription* pOpenMask = CSenWSDescription::NewLC( KNullDesC8, KNullDesC8 );

    pOpenMask->SetFrameworkIdL(KDefaultOviFrameworkID); // now it matches with any WS-Ovi session

    RWSDescriptionArray all;

    iManager.ServiceDescriptionsL(all, *pOpenMask);

    CleanupStack::PopAndDestroy(pOpenMask);

    CleanupClosePushL(all);

    TInt count(all.Count());

    for(TInt i=0; i<count; i++)

        {   

        CSenWSDescription* pSD = (CSenWSDescription*)all[i];

        if(pSD->DescriptionClassType() == MSenServiceDescription::EOviServiceSession)

            {

            CWSOviServiceSession* pSession = (CWSOviServiceSession*)pSD;

            pSession->VerifyPermissionL(); // accessible through friendship

            }

        }

    CleanupStack::PopAndDestroy(&all);

    }

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

// There is no extended interface in WSOvi framework at the moment.

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

//

TAny* CWSOviPlugin::ExtendedInterface()

    {

    return NULL;

    }

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

// Return a new instance of a framework specific class that

//     implements the ServiceDesccription interface.

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

//

CSenWSDescription* CWSOviPlugin::NewServiceDescriptionL()

    {

    CWSOviServiceSession* pSD =

        CWSOviServiceSession::NewL(*this);

    CleanupStack::PushL(pSD);    

    pSD->SetFrameworkIdL(KDefaultOviFrameworkID);

    CleanupStack::Pop(pSD);

    return pSD;

    }

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

// Getter for manager

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

//

MSenCoreServiceManager& CWSOviPlugin::Manager()

    {

    return iManager;

    }

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

// Setter for manager

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

//

void CWSOviPlugin::SetManager(MSenCoreServiceManager& aServiceManager)

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSOviPlugin::SetManager(.)")));

    iManager = aServiceManager;

    }

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

// Getter for configParser

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

//

CSenBaseFragment& CWSOviPlugin::ConfigParser()

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSOviPlugin::ConfigParser()")));

    return *this;

    //return callbacks which will be invoked during parsing rest of config

    //this callbacks will be responsible for loading features

    }

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

// UCS2 serializer

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

HBufC* CWSOviPlugin::AsXmlUnicodeL()

    {

    HBufC8* pUtf8 = AsXmlL();

    CleanupStack::PushL(pUtf8);

    HBufC* pAsAxlInUnicode = SenXmlUtils::ToUnicodeLC(*pUtf8);

    CleanupStack::Pop(pAsAxlInUnicode);

    CleanupStack::PopAndDestroy(pUtf8); 

    return pAsAxlInUnicode;

    }

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

// UTF8 serializer

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

HBufC8* CWSOviPlugin::AsXmlL()

    {

    HBufC8* retVal = HBufC8::NewLC(KMaxLengthXml);

    TPtr8 ptr = retVal->Des();

    ptr.Append(KSenLessThan);

    ptr.Append(KFrameworkLocalName);

    ptr.Append(KSenSpace);

    ptr.Append(KSenSpaceXmlns);

    ptr.Append(KSenEqualsDblQuot);

    ptr.Append(KFrameworkXMLNS);

    ptr.Append(KSenDblQuot);

    ptr.Append(KSenSpace);

    ptr.Append(KClassAttr);

    ptr.Append(KSenEqualsDblQuot);

    ptr.Append(KFrameworkCue);

    ptr.Append(KSenDblQuot);

    ptr.Append(KSenGreaterThan);

//--message handlers    

    for (TInt i=0; i < iMsgHandlers.Count(); i++)

        {

        AddHandlerTag(ptr, iMsgHandlers[i]->Name());

        }

//--session handlers    

   for (TInt i=0; i < iSessionHandlers.Count(); i++)

        {

        AddHandlerTag(ptr, iSessionHandlers[i]->Name());

        }  

//add IMIS digest

   	ptr.Append(KSenLessThan);

   	ptr.Append(KIMSILocalName);

   	ptr.Append(KSenSpace);

      //class attr

   	ptr.Append(KIMSIDigestAttr);

   	ptr.Append(KSenEqualsDblQuot);

   	ptr.Append(iIMSI);

   	ptr.Append(KSenDblQuot);

   	ptr.Append(KSenSlashGreaterThan);

    ptr.Append(KSenLessThanSlash);

    ptr.Append(KFrameworkLocalName);

    ptr.Append(KSenGreaterThan);

    CleanupStack::Pop(retVal);

    return retVal;

    }

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

//  used during reading configuration of WSOvi framework in order to load 

//  proper handlers.

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

//

void CWSOviPlugin::StartElementL(const TDesC8& /*aNsUri*/,