/*

* 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 FILES

#include "wsstartrustclient.h"

#include <s32mem.h>

#include <f32file.h>

#include <s32file.h>

#include <SenXmlUtils.h>

#include "sencryptoutils.h"

#include "wsstarservicesession.h"

#include "SenXmlUtils.h"

#include "msencoreservicemanager.h"

#include "sendebug.h"

#include "senlogger.h"

#include "MSenServiceDescription.h"

#include "senlogger.h"

#include "SenServiceConnection.h"

#include "seninternalserviceconsumer.h"

#include "wsstarrstresponse.h"

#include <SenCredential.h>

#include "wsstarpolicy.h"

#include "wsstarplugin.h"

#include <SenTransportProperties.h>

#include "senwspattern.h"

using namespace WSTrust;

using namespace WSPolicy;

_LIT8(KRemoteConsumer,       "RemoteConsumer");

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

// Creates and returns a new instace of this class.

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

//

CWSStarTrustClient* CWSStarTrustClient::NewL(

                                                        CSIF& aSIF,

                                                        RFileLogger& aLogger)

    {

    CWSStarTrustClient* pNew = NewLC(aSIF, aLogger);

    CleanupStack::Pop(pNew);

    return pNew;

    }

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

// Creates and returns a new instace of this class and leaves the object on the cleanup stack

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

//

CWSStarTrustClient* CWSStarTrustClient::NewLC(

                                                        CSIF& aSIF,

                                                        RFileLogger& aLogger)

    {

    CWSStarTrustClient* pNew =

        new (ELeave) CWSStarTrustClient(

                    aSIF,

                    MSenServiceDescription::EWSStarSTSClient,

                    aLogger);

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL();

    return pNew;

    }

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

// Constructor

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

//

CWSStarTrustClient::CWSStarTrustClient(

                                                CSIF& aSIF,

                                                TDescriptionClassType aType,

                                                RFileLogger& aLogger)

    : CSenInternalServiceConsumer(aType, aSIF),

    iLog(aLogger)

    {

    }

void CWSStarTrustClient::BaseConstructL()

    {

    CSenInternalServiceConsumer::ConstructL();

    iTpCounter = 0;

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

    }

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

// Destructor

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

//

CWSStarTrustClient::~CWSStarTrustClient()

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarTrustClient::~CWSStarTrustClient");

    delete iSTSSession;

    delete iEntropyClient;

    delete iAppliesTo;

    delete ipTransport;

    delete iTokenType;

    delete iSTSOrginalEndpoint;

    }

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

// The most siginificant method of this class. Make validation of session, 

//    credentails obtained if needed.

//    Sequential logic, synchronized, step bye SOAP exchange scenrio.

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

//

TInt CWSStarTrustClient::ValidateL( CWSStarServiceSession& aSession,

                                    TBool aRenewing,

                                    HBufC8*& aErrorMessage,

                                    TBool aOnlySharing )

    {

    iSTSSession->CompleteServerMessagesOnOffL(ETrue);

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarTrustClient::ValidateL(..)");

    TInt retVal(KErrNone);            // for returning error codes

    iWSStarServiceSession = &aSession;            // save session

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

//0  token sharing

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

    TBool sharingSucceed = EFalse;

    HBufC8* clusterUsed = CWSStarPolicy::GetPolicyValueL(KIssuedToken, KRPSCluster, *iHndCtx, iSTSSession);

    CleanupStack::PushL(clusterUsed);

    //its mean - if our provider uses cluster template, 

    //so we can try copy MT and SCT form other msn services which use same provider ID

    if (clusterUsed)

        {

        RPointerArray<CSenWSDescription> msnSDs;

        CleanupClosePushL(msnSDs);

        CSenWSPattern* pattern = CSenWSPattern::NewLC();

        //select * from session_of_SD where session is (ws* framework, and has same provideId)

        //here we assume that provider use cluster template

        pattern->SetFrameworkIdL(KDefaultWSStarFrameworkID);

        pattern->AsElement().AddElementL(KSenIdpProviderIdLocalname).SetContentL(iIdentityProvider->ProviderID());

        //pattern->AsElement().AddElementL(WSStarSession::KProviderIdElementLocalName).SetContentL(iIdentityProvider->ProviderID());

        //seeking

        CWSStarServiceSession* msnSession = NULL;

        TRAPD(leaveError, retVal = Framework().Manager().ServiceDescriptionsL(msnSDs, *pattern));

        if(!retVal && !leaveError)

            {

            TInt count = msnSDs.Count();

            TBool pMTwasReplaceBySCT = EFalse;

            TBool seekSCT = EFalse;

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

                {

                //all sessions (so in practice we have also access to SCT, not only MT),

                // to eliminate client, just for case we check type

                TDescriptionClassType dt = msnSDs[i]->DescriptionClassType();

                if (dt == MSenServiceDescription::EWSStarServiceSession)

                    {

                    msnSession = (CWSStarServiceSession*)msnSDs[i];

                    //dont share to itself

                    if (msnSession != iWSStarServiceSession)

                        {

                        TRAPD(err, retVal = msnSession->ShareTokenWithL(

                                iWSStarServiceSession, pMTwasReplaceBySCT,

                                seekSCT));

                        if ((retVal == KErrNone) && (err == KErrNone))

                            {

                            sharingSucceed = ETrue;

                            if (pMTwasReplaceBySCT)

                                {

                                break;    

                                }

                            else

                                {

                                seekSCT = ETrue;//in order to find other session which can have additioanly SCT

                                }

                            }    

                        }

                    }

                }

            if ( !pMTwasReplaceBySCT && !sharingSucceed )

                {

                // Did not find valid MT      (<=> sharingSucceed     == EFalse)

                // AND did not find valid SCT (<=> pMTwasReplaceBySCT == EFalse) 

                // 

                // Try to search valid MT directly from CredentialManager

                // (This is needed especially in case when MT is imported

                //  through Public API

                //  => There is not yet Session which holds imported MT)

                if ( iWSStarServiceSession->TryToSearchValidCredentialL() == KErrNone )	//codescannerwarnings

                    {

                    iWSStarServiceSession->SetStatusL();

                    iWSStarServiceSession->AddSecurityTokenToContextL();

                    sharingSucceed = ETrue;

                    }

                }

            }

        CleanupStack::PopAndDestroy(2, &msnSDs);

        }

    CleanupStack::PopAndDestroy(clusterUsed);

    if (sharingSucceed)

        {

        iWSStarServiceSession->SetTrustAnchorL(iIdentityProvider->ProviderID());

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarTrustClient::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 (!iSTSSession)// if trustClient has NOT been registered earlier

        {

        iSTSSession = CWSStarServiceSession::NewL(Framework());

        iSTSSession->InitializeFromL(*this);

        iSTSSession->SetEndPointL(iIdentityProvider->Endpoint());

        iSTSSession->SetContractL(KWSStarSTSContract);

        iSTSSession->AddConsumerL(*this);

        }

    CSenXmlReader* reader = Framework().Manager().XMLReader();

    CWSStarSessionContext* stsSsnContext = iSTSSession->SessionContext();

    iPassportMode = CWSStarPolicy::CheckPolicyValueL(KPassportExtensions, iSTSSession);

    if (iPassportMode)

        {

        stsSsnContext->Update(WSStarContextKeys::KPassportEnabled, ETrue);

        aRenewing = FALSE; //MS passport doesn't support renewing binding. So we force here issue binding

        }

    iRenewingMode = aRenewing;

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

//2.preparing context    

//-----------------------WS-TRUST 2005-02 chapter 6 -  RST issue-------------------------    

    stsSsnContext->Update(WSStarContextKeys::KAction, GetAction());

    TInt retryCounter(0);

    TBool retry(ETrue);

    TBool authenticationInfoPromptedFromUser(EFalse);

    TPckgBuf<TSenAuthentication> authInfo;

    HBufC8* responseXML = NULL;

    HBufC8* pBodyXML = NULL;

    MSenRemoteServiceConsumer* pConsumer = NULL;

    while ( retry ) // Authentication loop starts

        {

        retry = EFalse;

        //setting secure profile of authentication with sts, can X509, so in future some factory calling

    if (CWSStarPolicy::CheckPolicyValueL(KUsernameTokenOverTLS, iSTSSession))

            {

            HBufC8* token = NULL;

            if ( authenticationInfoPromptedFromUser )

                {

                CSenWsSecurityHeader::UsernameTokenL(authInfo().iUsername,

                                                     authInfo().iPassword,

                                                     token);

                }

            else

                {

                CSenWsSecurityHeader::UsernameTokenL(iIdentityProvider->UserName(),

                                                     iIdentityProvider->Password(),

                                                     token);

                }

            stsSsnContext->Update(WSStarContextKeys::KSecurityToken, *token);    

        delete token;    

        token = NULL;

        }

    //building body

    CWSStarPlugin& frmWSStar = (CWSStarPlugin&)Framework();

    CSenElement* pBody = CreateBodyL();

    stsSsnContext->Update(WSStarContextKeys::KBodyElement, pBody);

        pBodyXML = pBody->AsXmlL();

        CleanupStack::PushL(pBodyXML);

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

    //_____________________________________SYNC Sending____________________________________________

        CSenTransportProperties* transProp = CSenTransportProperties::NewLC();

		const TDesC8* value =stsSsnContext->GetDesC8L(WSStarContextKeys::KAction);

		if(value)

        transProp->SetSoapActionL(*value);

        // 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 sts 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(WSStarSession::KMaxHttpTimeOut);

        HBufC8* transPropAsXml = transProp->AsUtf8LC();

    /*

        if( iWSStarServiceSession )

            {

            iWSStarServiceSession->SendStatusToConsumerL( KSenStatusAuthentication );

            }

    */        

        //overwrite passport endpoint (provided by GUI)  by endpoint provided by policy

        AdaptStsEndpointL();	//codescannerwarnings

        iTpCounter++;

        retVal = iSTSSession->SubmitL(*pBodyXML, *transPropAsXml, *this, responseXML);

        iTpCounter--;

        CWSStarSessionContext* pSessionCtxt = iWSStarServiceSession->SessionContext();// redundant code 

        TAny* ptr = pSessionCtxt->GetAnyL(KRemoteConsumer());	//codescannerwarnings

        if ( ptr )

            {

            pConsumer = REINTERPRET_CAST(MSenRemoteServiceConsumer*, ptr);

            }

        else

            {

            pConsumer = iWSStarServiceSession->Consumer();

            }

        pConsumer->SetDataTrafficDetails(iTrustDetails);

        AdaptStsEndpointL(ETrue);

        CleanupStack::PopAndDestroy(transPropAsXml);

        CleanupStack::PopAndDestroy(transProp);

        CleanupStack::PopAndDestroy(pBodyXML);

        CleanupStack::PushL(responseXML);

        if ( retVal == KErrSenSoapFault )

            {

            //CREDLOG_L(KSenCredsLogLevelNormal,".......failed (SOAP Fault)");

            CWSStarSessionContext* pSessionContext = iWSStarServiceSession->SessionContext();

            TAny* ptr = pSessionContext->GetAnyL(KRemoteConsumer());	//codescannerwarnings

            if ( ptr )

                {

                pConsumer = REINTERPRET_CAST(MSenRemoteServiceConsumer*, ptr);

                }

            else

                {

                pConsumer = iWSStarServiceSession->Consumer();

                }

            if ( pConsumer && !pConsumer->HasAuthenticationCallback() &&

                 retryCounter < 3 )

                {

                TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarTrustClient::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 = stsSsnContext->GetIntL(WSStarContextKeys::KReAuthNeeded);

					if ( renewingPtr )

                     	{

                    if ( *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,"CWSStarTrustClient::ValidateL - promptUserInfo = false");

                    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel," => prompt is not used.");

                    }

                }

            if ( pConsumer && pConsumer->HasAuthenticationCallback() &&

                             retryCounter < 3 )

            	{

                TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,"CWSStarTrustClient::ValidateL - Consumer has AuthenticationCallback");

                const TDesC8* pValue = iIdentityProvider->AsElement().AttrValue( KSenAttrPromptUserInfo );

                if ( !pValue || *pValue != _L8("false") )

                    {

                    const TBool* renewingPtr = stsSsnContext->GetIntL(WSStarContextKeys::KReAuthNeeded);

                    if ( renewingPtr && *renewingPtr )

                        {

                        const TBool* renewingByCredObserv = iWSStarServiceSession->SessionContext()->GetIntL(WSStarContextKeys::KReAuthNeededFromCredObserv);

                        if( renewingByCredObserv != NULL && *renewingByCredObserv )

                        	{

                        	// Credential Observer -> call reauthenticatino through connection agent

                        	CSenIdentityProvider* newIdP = iIdentityProvider;

                        	TRAPD(error, retVal = pConsumer->ReauthenticationNeededL(newIdP));

    	                    if(error == KErrNone && retVal == KErrNone)

    	                    	{

    	                    	// Update identity provider in case old one got corrupted

    	                    	iIdentityProvider = newIdP;

    	                    	retryCounter++;

    	                    	retry = ETrue;

    	                    	}

    	                    else

    	                    	{

    	                    	retVal = KErrSenFailedAuthentication;

    	                    	}

                        	}

                        else

                        	{

                        	retVal = KErrSenFailedAuthentication;

                        	}

                        }

                    }

                else

                    {

                    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,"CWSStarTrustClient::ValidateL - UserInfoPrompt = false");

                    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel," => AuthenticationCallback is not used.");

                    }

            	}

            }

        if ( retry )

            {

            CleanupStack::PopAndDestroy(responseXML);

            }

        }  // Authentication loop ends

    if (!retVal)

        {

        const TDesC8* responseAction = stsSsnContext->GetDesC8L(WSStarContextKeys::KResponseAction);

        if  (responseAction &&

                responseAction->Length())

            {

            if (*responseAction != GetActionResponse())

                {

                TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,"CWSStarTrustClient::ValidateL - wrong action in response");

                retVal = KErrNotFound;

                //no ws-trust specifiv fault defined for invalid RESPONSE. I can only answer iwth addressign fault

                //but no access to addressing handler directly

                }

            }

        }

    if (retVal != KErrNone)

        {

        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("CWSStarTrustClient::ValidateL - error when submit to STS %d"), retVal));

        if (responseXML)

            {

            aErrorMessage = responseXML;

            }

        CleanupStack::Pop(responseXML);

        if (! iTpCounter)

            {

            //we don't have to keep transport. Important expecially during night test, 

            //  when transport and its RConnection exceed idle timeout

            delete ipTransport;

            ipTransport = NULL;

            }

        return retVal;

        }

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarTrustClient::ValidateL - response from STS is a valid SOAP");

	#ifdef RD_SEN_VTCP_SUPPORT

	//#ifdef RD_SEN_CO_BRAND_SUPPORT

	//stsSsnContext->Update(WSStarContextKeys::KBrandIDEnabled, EFalse);

    const TDesC8* mainBrandID = stsSsnContext->GetDesC8L(WSStarContextKeys::KMainBrandID);

    if  (mainBrandID && mainBrandID->Length())

        {

        if(iPassportMode)

            {

            //Call Back Consumer

            CWSStarSessionContext* pSessionContext = iWSStarServiceSession->SessionContext();

            TAny* ptr = pSessionContext->GetAnyL(KRemoteConsumer());	//codescannerwarnings

            if ( ptr )

                {

                pConsumer = REINTERPRET_CAST(MSenRemoteServiceConsumer*, ptr);

                }

            else

                {

                pConsumer = iWSStarServiceSession->Consumer();

                }

            if ( pConsumer && pConsumer->HasCoBrandingCallback() )

                {

                	TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,"CWSStarTrustClient::HasCoBrandingCallback");

                    const TDesC8* brandIDList = stsSsnContext->GetDesC8L(WSStarContextKeys::KBrandIDList);

                    RBuf8 selectedBrandId;

                    //User will reply with go/no go optoin

                    if(pConsumer->OnGetBrandIdL(*brandIDList,selectedBrandId))

                    {

                		TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,"CWSStarTrustClient::Brand ID Is Enabled");

                        // co-branding - Add co branding details in context

                        stsSsnContext->Update(WSStarContextKeys::KBrandIDEnabled, ETrue);