/*

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

*

*/

// INCLUDE FILES

#include "wsstarcobrandingclient.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;

//namespace

//    {

//    _LIT8(KRemoteConsumer,       "RemoteConsumer");

//    }

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

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

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

//

CWSStarCoBrandingClient* CWSStarCoBrandingClient::NewL(

                                                        CSIF& aSIF,

                                                        RFileLogger& aLogger)

    {

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

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

//

CWSStarCoBrandingClient* CWSStarCoBrandingClient::NewLC(

                                                        CSIF& aSIF,

                                                        RFileLogger& aLogger)

    {

    CWSStarCoBrandingClient* pNew =

        new (ELeave) CWSStarCoBrandingClient(

                    aSIF,

                    MSenServiceDescription::EWSStarSTSClient,

                    aLogger);

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL();

    return pNew;

    }

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

// Constructor

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

//

CWSStarCoBrandingClient::CWSStarCoBrandingClient(

                                                CSIF& aSIF,

                                                TDescriptionClassType aType,

                                                RFileLogger& aLogger)

    : CSenInternalServiceConsumer(aType, aSIF),

    iLog(aLogger)

    {

    }

void CWSStarCoBrandingClient::BaseConstructL()

    {

    CSenInternalServiceConsumer::ConstructL();

    iTpCounter = 0;

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

    }

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

// Destructor

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

//

CWSStarCoBrandingClient::~CWSStarCoBrandingClient()

    {

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

    delete ipTransport;

    delete iCoBrandingOrginalEndpoint;

    }

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

// SetStatus

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

//

void CWSStarCoBrandingClient::SetStatus(TInt /*aStatus */)

    {

    // No implementation in Java

     }

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

// SetSTSSessionL

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

//

void CWSStarCoBrandingClient::SetCoBrandingSessionL(

                                                CWSStarServiceSession* aSession)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarCoBrandingClient::SetCoBrandingSessionL");

    _LIT8(KTouch, "touch");

    const TDesC8* attrValue = aSession->AsElement().AttrValue(KTouch);

    if(attrValue != NULL)

    	{

    	AsElement().AddAttrL(KTouch, *attrValue);

    	}

    iCoBrandingSession = aSession;

    }

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

// Fetch SCT request

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

//Co-Branding CR

TInt CWSStarCoBrandingClient::FetchSCTL(

                                    CWSStarServiceSession& aSession,

                                    HBufC8*& aErrorMessage)

{

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarCoBrandingClient::FetchSCTL(..)");

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

    iWSStarServiceSession = &aSession;            // save session

    iWSStarServiceSession->AddConsumerL(*this);

    CWSStarSessionContext* coBrandingSsnContext = iCoBrandingSession->SessionContext();

    CWSStarSessionContext* valSsnContext = iWSStarServiceSession->SessionContext();

    //PART 2 ::

    HBufC8* pBodyXML = NULL;

    HBufC8* coBrandResponseXML = NULL;

    const TBool* brandID = coBrandingSsnContext->GetIntL(WSStarContextKeys::KBrandIDEnabled);

    if(brandID && *brandID)

        {

        //Create a Fetch SCt body and update

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

        CSenElement* pBody = CreateFSTL();

        if(pBody)

	    {

	        //Update application info attribute

	        if (CWSStarPolicy::CheckPolicyValueL(WSStarContextKeys::KMwsNamespace, iCoBrandingSession))

	            {

	                HBufC8* mwsNameSapce = CWSStarPolicy::GetPolicyValueL(WSStarContextKeys::KMwsNamespace,iCoBrandingSession);

	                CleanupStack::PushL(mwsNameSapce);

	                valSsnContext->Update(WSStarContextKeys::KMwsNamespace, mwsNameSapce->Des());    

	                CleanupStack::PopAndDestroy(mwsNameSapce);

	             }

	        AddAppInfoHeaderL();

	        //Update action

	        valSsnContext->Update(WSStarContextKeys::KAction, KActionIssueFST200610);

	        HBufC8* address = NULL;

	        address = CWSStarPolicy::GetPolicyValueL(WSStarContextKeys::KWAPGW,iCoBrandingSession);    

	        if (address)

	            {

	            valSsnContext->Update(WSStarContextKeys::KTo, *address);

	            delete address;

	            address = NULL;        

	            }

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

	        pBodyXML = pBody->AsXmlL();

	        CleanupStack::PushL(pBodyXML);

	        //Set transport properties    

	        CSenTransportProperties* transProp = CSenTransportProperties::NewLC();

	        TPtrC8 value;

	        value.Set(*valSsnContext->GetDesC8L(WSStarContextKeys::KAction));

	        transProp->SetSoapActionL(value);

	        // 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);

	    	const TDesC8* pMwsNamespace = valSsnContext->GetDesC8L(WSStarContextKeys::KMwsNamespace);

	    	if(pMwsNamespace)

	    	    transProp->SetMwsNamespaceL(*pMwsNamespace);

	        HBufC8* transPropAsXml = transProp->AsUtf8LC();

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

	        AdaptCoBrandEndpointL();

	        iTpCounter++;

	        retVal = iWSStarServiceSession->SubmitL(*pBodyXML, *transPropAsXml, *this, coBrandResponseXML);

	        iTpCounter--;

	        CleanupStack::PushL(coBrandResponseXML);

	        AdaptCoBrandEndpointL(ETrue);

	        valSsnContext->Remove(WSStarContextKeys::KTo);    

	        valSsnContext->Remove(WSStarContextKeys::KAppInfoPresent);    

	        if(coBrandResponseXML)

	            {

	            //Parse the response

	            CSenParser* pParser = CSenParser::NewLC();

	            CSenSoapEnvelope2* pResponseFragment = CSenSoapEnvelope2::NewL();

	            CleanupStack::PushL(pResponseFragment);

		        TRAPD(errorL,pParser->ParseL(*coBrandResponseXML, *pResponseFragment));

	            if ( retVal!= KErrNone || errorL!= KErrNone)

	                {

	                    aErrorMessage = coBrandResponseXML;

	                }

	            CleanupStack::PopAndDestroy(2);  // pParser, pResponseFragment            

	            }

	        if (!aErrorMessage)

	            {

	            CleanupStack::PopAndDestroy(coBrandResponseXML);               

	            }

	        else

	            {

	            CleanupStack::Pop(coBrandResponseXML);

	            }

	        CleanupStack::PopAndDestroy(transPropAsXml);

	        CleanupStack::PopAndDestroy(transProp);

	        CleanupStack::PopAndDestroy(pBodyXML); 

	    }

    }

    if (! iTpCounter)

        {

        delete ipTransport;

        ipTransport = NULL;

        }

    iWSStarServiceSession->RemoveConsumerL(*this);

    return retVal;

}

//End Of Co-Branding

void CWSStarCoBrandingClient::AddAppInfoHeaderL()

{

    CWSStarSessionContext* valSsnContext = iWSStarServiceSession->SessionContext();

    //Update application info attribute

    if (CWSStarPolicy::CheckPolicyValueL(WSStarContextKeys::KAppInfo, iCoBrandingSession))

        {

            valSsnContext->Update(WSStarContextKeys::KAppInfoPresent, ETrue);

            RPointerArray<CSenElement> aAppElements;

            CWSStarPolicy::GetPolicyValueL(WSStarContextKeys::KAppInfo,WSStarContextKeys::KApplication,iCoBrandingSession,aAppElements);

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

                {

                  CSenElement* element = aAppElements[i];

                  if(element->LocalName() == KName)

                  {

                    valSsnContext->Update(WSStarContextKeys::KApplicationName, element->Content());    

                  }

                  if(element->LocalName() == WSStarContextKeys::KVendor)

                  {

                    valSsnContext->Update(WSStarContextKeys::KApplicationVendor, element->Content());    

                  }

                  if(element->LocalName() == WSStarContextKeys::KVersion)

                  {

                    valSsnContext->Update(WSStarContextKeys::KApplicationVersion, element->Content());    

                  }

                }

            RPointerArray<CSenElement> aDeOpElements;

            CWSStarPolicy::GetPolicyValueL(WSStarContextKeys::KAppInfo,WSStarContextKeys::KDeviceOptions,iCoBrandingSession,aDeOpElements);

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

                {

                  CSenElement* element = aDeOpElements[i];

                  if(element->LocalName() == WSStarContextKeys::KLocale)

                  {

                    valSsnContext->Update(WSStarContextKeys::KLocale, element->Content());    

                  }

                  if(element->LocalName() == WSStarContextKeys::KUserAgent)

                  {

                    RPointerArray<CSenElement> childElements1 = element->ElementsL();

                    for(TInt j=0;j<childElements1.Count();j++)

                    {

                      CSenElement* childElement1 = childElements1[j];

                      if(childElement1->LocalName() == WSStarContextKeys::KManufacturer)

                          {

                            valSsnContext->Update(WSStarContextKeys::KManufacturer, childElement1->Content());    

                          }

                      if(childElement1->LocalName() == WSStarContextKeys::KModel)

                          {

                            valSsnContext->Update(WSStarContextKeys::KModel, childElement1->Content());    

                          }

                      if(childElement1->LocalName() == WSStarContextKeys::KIMSI)

                          {

                            valSsnContext->Update(WSStarContextKeys::KIMSI, childElement1->Content());    

                          }

                      if(childElement1->LocalName() == WSStarContextKeys::KOS)

                          {

                                RPointerArray<CSenElement> childElements2 = childElement1->ElementsL();

                                for(TInt k=0;k<childElements2.Count();k++)

                                {

                                  CSenElement* childElement2 = childElements2[k];

                                  if(childElement2->LocalName() == WSStarContextKeys::KName)

                                      {

                                        valSsnContext->Update(WSStarContextKeys::KDeviceName, childElement2->Content());    

                                      }

                                  if(childElement2->LocalName() == WSStarContextKeys::KVersion)

                                      {

                                        valSsnContext->Update(WSStarContextKeys::KDeviceVersion, childElement2->Content());    

                                      }

                                }

                          }

                      }

                  }

               }

        }

}

CSenServiceSession* CWSStarCoBrandingClient::ServiceSession()

    {

    return iWSStarServiceSession;

    }

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

// Create body for Fetch SCT request

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

//Co-Branding CR

CSenElement* CWSStarCoBrandingClient::CreateFSTL()

{

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

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

//1 Proxy

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

    if (CWSStarPolicy::CheckPolicyValueL(WSStarContextKeys::KWAPGW, iCoBrandingSession))

        {

        HBufC8* wapGW = CWSStarPolicy::GetPolicyValueL(WSStarContextKeys::KWAPGW, iCoBrandingSession);

        if (wapGW)

            {

             CleanupStack::PushL(wapGW);

            }  

        else

            {

                //Hard Coded Value    

            }

        CSenDomFragment* domFrg = CSenDomFragment::NewL(KFSTTag);

        CSenElement* elementRst = domFrg->ExtractElement();

        CleanupStack::PushL(elementRst);

        delete domFrg;

        domFrg = NULL;

        elementRst->AddNamespaceL(KNullDesC8,*wapGW);

        CleanupStack::Pop(elementRst);

        if (wapGW)

            {

             CleanupStack::PopAndDestroy(wapGW);

            }  

        return elementRst;

        }

    return NULL;        

}

//End Of Co-Branding

MSenTransport& CWSStarCoBrandingClient::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,"CWSStarTrustClient::Instantiating new transport");

        ipTransport = Framework().Manager().CreateL(*iWSStarServiceSession, iWSStarServiceSession); 

        }

    return *ipTransport;

    }    

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

// Getter for endpoint

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

//

TPtrC8 CWSStarCoBrandingClient::Endpoint()

    {

    return iWSStarServiceSession->Endpoint();

    }

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

// Getter for contract

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

//

TPtrC8 CWSStarCoBrandingClient::Contract()

    {

    return iWSStarServiceSession->Contract();

    }

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

// Getter for providerId

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

//

TPtrC8 CWSStarCoBrandingClient::ProviderID()

    {

    return iWSStarServiceSession->ProviderID();

    }

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

// Getter for framework

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

//

TPtrC8 CWSStarCoBrandingClient::FrameworkId()

    {

    return iWSStarServiceSession->FrameworkId();

    }

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

// serialie to xml

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

//

void CWSStarCoBrandingClient::WriteAsXMLToL(RWriteStream& aWriteStream)

    {

    iWSStarServiceSession->WriteAsXMLToL(aWriteStream);

    }

MSenServicePolicy* CWSStarCoBrandingClient::ServicePolicy()

    {

    return iWSStarServiceSession->ServicePolicy();

    }

TInt CWSStarCoBrandingClient::IapId(TUint32& aCurrentIapId)

    {

    return iWSStarServiceSession->IapId(aCurrentIapId);

    }

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

// setter for ws-trust version

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

//

void CWSStarCoBrandingClient::SetHandlerCtx(MSenHandlerContext* aHndCtx)

    {

    iHndCtx = aHndCtx;

    }

//Co-branding CR    

TInt CWSStarCoBrandingClient::AdaptCoBrandEndpointL(TBool aToOrginal)	//codescannerwarnings

    {

    TInt returnValue( KErrNone );

    if (aToOrginal)

        {

        iWSStarServiceSession->SetEndPointL(*iCoBrandingOrginalEndpoint);

        return returnValue;

        }

    delete iCoBrandingOrginalEndpoint;

    iCoBrandingOrginalEndpoint = NULL;

    iCoBrandingOrginalEndpoint = iWSStarServiceSession->Endpoint().AllocL();        

    HBufC8* address = NULL;

    address = CWSStarPolicy::GetPolicyValueL(WSStarContextKeys::KWAPGW,iCoBrandingSession);    

    if (address)

        {

        iWSStarServiceSession->SetEndPointL(*address);

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarTrustClient::AdaptCoBrandEndpointL() - endpoint replaced by value from policy");

        delete address;

        address = NULL;