/*

* Copyright (c) 2005-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:  For parsing PAOS XML documents

*

*/

#include <e32std.h>

#include <xml/parser.h> // for compact XML parser

#include <xml/documentparameters.h> // for RDocumentParameters

#include <sysutil.h>

#include <PnpToPaosInterface.h>

#include "HdcToPaosInterface.h"

#include "PnpPaosXml.h"

#include "PnpPaosLogger.h"

#include <PnpProvUtil.h>

const TInt KMessageIdLength(12);

const TInt KInitialResponseLength(512);

const TInt KInitialReferenceMessageIdLength(32);

const TInt KInitialUrlLength(128);

_LIT8( KParserDataType, "text/xml" );

_LIT8( KUriPaosLiberty, "urn:liberty:paos:2003-08" );

_LIT8( KLocalNameRequest, "Request" );

_LIT8( KUriSbLiberty, "urn:liberty:sb:2003-08" );

_LIT8( KLocalNameCorrelation, "Correlation" );

_LIT8( KAttributeResponseConsumerUrl, "responseConsumerURL" );

_LIT8( KPnpMsNokiaUri, "http://pnpms.nokia.com/signkey" );

_LIT8( KAttributeMessageId, "messageID" );

_LIT8( KElementGetKey, "getkey" );

_LIT8( KKeyRequest, "Keyrequest" );

_LIT8( KContentSetOfKeys, "SetOfKeys" );

_LIT8( KContentHdcSetOfKeys, "HdcSetOfKeys" );

_LIT8( KContentHdcSetOfKeys2, "HDCSetOfKeys" );

enum TElementIds

    {

    EElementUnrecognized = 0,

    EElementKeyRequest,

    EElementGetKey

    };

// Panic texts

_LIT( KResponseEmpty, "PnPMS PAOS Response" );

// PAOS data sent to the PnP MS server

_LIT8(

    KPnpPaosResponse,

    "<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">"

      "<soap:Header>"

      "%S" /* Add a KPaosResponseMessageIds here if the request has messageid field */

      "</soap:Header>"

      "<soap:Body>"

        "<pp:Signkey xmlns:pp=\"http://pnpms.nokia.com/signkey\">"

            "<Keyinfo>%S</Keyinfo>"

            "<nonce>%S</nonce>"

            "<mcc>%S</mcc>"

            "<mnc>%S</mnc>"

            "<cmcc>%S</cmcc>"

            "<cmnc>%S</cmnc>"

            "<cVersion>%S</cVersion>"

            "<deviceinfo>%S</deviceinfo>"

        "</pp:Signkey>"

      "</soap:Body>"

    "</soap:Envelope>"

    );

// PAOS data sent to the HelpDeskConnect server

_LIT8(

    KHdcPaosResponse,

    "<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">"

      "<soap:Header>"

      "%S" /* Add a KPaosResponseMessageIds here if the request has messageid field */

      "</soap:Header>"

      "<soap:Body>"

        "<pp:Signkey xmlns:pp=\"http://pnpms.nokia.com/signkey\">"

            "%S" /* Add a list of KHdcKeyInfoElement's here */

            "<nonce>%S</nonce>"

            "<hdcVersion>%S</hdcVersion>"

        "</pp:Signkey>"

      "</soap:Body>"

    "</soap:Envelope>"

    );

_LIT8(

    KHdcKeyInfoElement,

    "<Keyinfo>%S</Keyinfo>"

    );

const TInt KHdcKeyInfoElementLength( 21 );

_LIT8(

    KPaosResponseMessageIds,

    "<sb:Correlation xmlns:sb=\"urn:liberty:paos:2003-08\" "

    "messageID=\"%S\" "

    "refToMessageID=\"%S\"/>"

    );

CPnpPaosXml* CPnpPaosXml::NewL()

    {

    LOGSTRING("CPnpPaosXml::NewL()");

    CPnpPaosXml* self = new (ELeave) CPnpPaosXml();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOGSTRING("CPnpPaosXml::NewL() - done");

    return self;

    }

CPnpPaosXml::CPnpPaosXml() :

    iPaosStatus( EPaosStatusUnknown ),

    iResponseConsumerUrlFound( EFalse ),

    iErrorFound( EFalse ),

    iCurrentElement( EElementUnrecognized )

    {

    LOGSTRING("constructor CPnpPaosXml()");

    }

void CPnpPaosXml::ConstructL()

    {

    LOGSTRING("CPnpPaosXml::ConstructL()");

    iParser = Xml::CParser::NewL( KParserDataType, *this );

    LOGSTRING("CPnpPaosXml::ConstructL() - 2");

    iPaosPostUrlPath = HBufC8::NewL( KInitialUrlLength );

    iMessageId = HBufC8::NewL( KMessageIdLength );

    // We do not know the length of refToMessageID until we get it

    // from the service

    iReferenceMessageId = HBufC8::NewL( KInitialReferenceMessageIdLength );

    iPaosResponse = HBufC8::NewL( KInitialResponseLength );

    LOGSTRING("CPnpPaosXml::ConstructL() - done");

    }

CPnpPaosXml::~CPnpPaosXml()

    {

    LOGSTRING("CPnpPaosXml::~CPnpPaosXml()");

    delete iParser;

    delete iPaosRequest;

    delete iPaosResponse;

    delete iMessageId;

    delete iReferenceMessageId;

    delete iPaosPostUrlPath;

    LOGSTRING("CPnpPaosXml::~CPnpPaosXml() - done");

    }

void CPnpPaosXml::OnOutOfData() 

    {

    }

void CPnpPaosXml::ParseL( TPaosStates& aPaosStatus )

    {

    LOGSTRING("CPnpPaosXml::ParseL()");

    // Reset possible previous paos response

    ReleaseData();

    // Reset state variables

    iPaosStatus = EPaosStatusUnknown;

    iErrorFound = EFalse;

    iCurrentElement = EElementUnrecognized;

    iResponseConsumerUrlFound = EFalse;

    LOGSTRING("ParseBeginL()");

    iParser->ParseBeginL();

    Xml::ParseL( *iParser, *iPaosRequest );

    aPaosStatus = iPaosStatus; // Store status

    LOGSTRING("ParseL() - done");

    // There has to be a consumer URL in the document

    if( !iResponseConsumerUrlFound )

        {

        LOGSTRING( "responseCosumerURL not found!" );

        User::Leave( KErrArgument );

        }

    // No errors allowed in the XML

    if( iErrorFound )

        {

        LOGSTRING( "Error in the XML!" );

        User::Leave( KErrArgument );

        }

    // Only key requests for PnP-MS or HelpDeskConnect

    // keys (parameters) allowed with this PAOS parser

    switch( aPaosStatus )

        {

    case EPaosStatusRequestingPnPKeys:

        ConstructPnPPaosResponseL();

        break;

    case EPaosStatusRequestingHdcKeys:

        ConstructHdcPaosResponseL();

        break;

    default:

        LOGSTRING( "Invalid PAOS request!" );

        User::Leave( KErrArgument );

        break;

        }

#ifdef LOGGING_ENABLED

    for( TInt i(0); i < iPaosResponse->Length(); i += 128 )

        {

        TPtrC8 logText = iPaosResponse->Right( iPaosResponse->Length() - i );

        LOGTEXT( logText );

        }

#endif

    // Reset state variables

    iPaosStatus = EPaosStatusUnknown;

    iErrorFound = EFalse;

    iCurrentElement = EElementUnrecognized;

    LOGSTRING("CPnpPaosXml::ParseL - done()");

    }

TBool CPnpPaosXml::CollectResponseBodyL( MHTTPDataSupplier& aBody )

    {

    LOGSTRING( "CPnpPaosXml::CollectResponseBodyL" );

    // Store incoming body part

    TPtrC8 dataChunk;

    TBool returnValue = aBody.GetNextDataPart( dataChunk );

#ifdef LOGGING_ENABLED

    for( TInt i(0); i < dataChunk.Length(); i += 128 )

        {

        LOGSTRING( "CPnpPaosXml: MHTTPDataSupplier:" );

        TPtrC8 logText = dataChunk.Right( dataChunk.Length() - i );

        LOGTEXT( logText );

        }

#endif

    if( !iPaosRequest )

        {

        iPaosRequest = HBufC8::NewL( dataChunk.Length() );

        }

    TPtr8 paosRequestPtr = iPaosRequest->Des();

    if( paosRequestPtr.MaxLength() < ( iPaosRequest->Length() + dataChunk.Length() ) )

        {

        LOGSTRING( "Re-allocate response buffer" );

        iPaosRequest = iPaosRequest->ReAllocL( iPaosRequest->Length() + dataChunk.Length() );

        paosRequestPtr.Set( iPaosRequest->Des() );

        }

    paosRequestPtr.Append( dataChunk );

    LOGSTRING( "CPnpPaosXml::CollectResponseBodyL - done" );

    return returnValue;

    }

/*

#ifndef __SERIES60_ 

TPtrC8 CPnpPaosXml::ResponseBodyL()

    {

    LOGSTRING( "CPnpPaosXml::ResponseBodyL" );

    if( !iPaosRequest ) 

        {

        User::Leave( KErrNotFound );

        }

    return *iPaosRequest;

    }

#endif

*/

void CPnpPaosXml::ConstructHdcPaosResponseL()

    {

    LOGSTRING( "CPnpPaosXml::ConstructHdcPaosResponseL" );

    // give empty parameter values in case there is no DLL for HelpDeskConnect

    // -> The service may then make the following assumptions:

    // 1. If there is no PAOS header in the first HTTP GET request -> link: "install HDC"

    // 2. If there is PAOS headers but PAOS response contains empty parameter values -> link: "install HDC"

    // 3. PAOS header and a valid PAOS response -> HDC installed OK, proceed to a HDC trigger file

    RLibrary library;

    const TUidType uid( KNullUid, KNullUid, KHdcUtilDllUid );

    TInt result = library.Load( KHdcDllFileName, uid );

    if( result != KErrNone )

        {

        // if the dll is not found the response should be empty

        LOGSTRING2( "err in loading HDC dll: %i", result );

        ConstructPaosResponseL( KHdcPaosResponse );

        return;

        }

    CleanupClosePushL( library );

    // Function at ordinal 1 is NewLC

    TLibraryFunction entry = library.Lookup(1);

    // Call the function to create new hdc dll object

    CHdcToPaosInterface* hdcUtil = ( CHdcToPaosInterface* ) entry();

    // HDC-nonce

    // create new nonce

    TBuf8<KHdcNonceLength> nonce;

    hdcUtil->CreateNewNonceL( nonce );

    // HDC-version

    TBuf8<KMaxHdcVersionStringLength> version;

    hdcUtil->Version( version );

    // List of key-infos

    HdcKeyInfoList keyInfoList;

    hdcUtil->HdcKeyInfos( keyInfoList );

    TInt keyInfoCount = keyInfoList.Count();

    HBufC8* keyInfos = HBufC8::NewLC(

        keyInfoCount * KMaxHdcKeyInfoLength +            /* space for keyinfos */

        keyInfoCount * KHdcKeyInfoElement().Length() );    /* space for XML elements */

    TPtr8 keyInfosPtr = keyInfos->Des();

    for( TInt i(0); i < keyInfoCount; i++ )

        {

        TBuf8<KMaxHdcKeyInfoLength + KHdcKeyInfoElementLength> keyInfoXmlElement;

        keyInfoXmlElement.Format( KHdcKeyInfoElement, &( keyInfoList[i] ) );

        keyInfosPtr.Append( keyInfoXmlElement );

        }

    LOGSTRING( "CPnpPaosXml::ConstructHdcPaosResponseL format response" );

    // 1. KPaosResponseMessageIds

    // 2. List of KHdcKeyInfoElement's

    // 3. HDC nonce

    // 4. HDC version

    ConstructPaosResponseL( KHdcPaosResponse, *keyInfos, nonce, version );

    LOGSTRING( "CPnpPaosXml::ConstructHdcPaosResponseL response formatted" );

    // RArray must be closed before destructing

    keyInfoList.Close();

    CleanupStack::PopAndDestroy( keyInfos );

    CleanupStack::PopAndDestroy( hdcUtil );

    CleanupStack::PopAndDestroy(); // library.Close()

    }

void CPnpPaosXml::ConstructPnPPaosResponseL()

    {

    LOGSTRING( "CPnpPaosXml::ConstructPnPPaosResponseL" );

    // Dynamically load the pnp util DLL,

    const TUidType uid( KNullUid, KNullUid, KPnpUtilDllUid );

    RLibrary pnpLibrary;

    TInt result = pnpLibrary.Load( KPnpUtilDllFileName, uid );

    if( result != KErrNone )

        {

        // if the dll is not found the response should be empty

        LOGSTRING2( "err in loading pnp util dll: %i", result );

        ConstructPaosResponseL( KPnpPaosResponse );

        return;

        }

    CleanupClosePushL( pnpLibrary );

    // Function at ordinal 1 is NewPnpUtilLC

    //TLibraryFunction entry = pnpLibrary.Lookup(1);

    // Call the function to create new Pnp util object

    //MPnpToPaosInterface* pnpUtil = ( MPnpToPaosInterface* ) entry();

    CPnpUtilImpl *pnpUtil = CPnpUtilImpl::NewLC();

    // check version

    TBuf8<KMaxVersionStringLength> version;

    TBuf<KMaxVersionStringLength> version16;

    pnpUtil->Version( version16 );

    version.Copy( version16 );

    LOGTEXT( version );

    // BC break between versions NPnPS60-0.10 and newer ones; Version function 

    // should be binary compatible, though.

    // (older versions of pnputil should not be a problem as updating PAOS filter

    // without updating PnP-MS components should be possible only by installing

    // HelpDeskConnect With PAOS filter)

    if( version.Compare( _L8("NPnPS60-0.10") ) == 0 )

        {

        // if the dll is not compatible give an empty response

        LOGSTRING( "Too old version of PnpUtil installed" );

        ConstructPaosResponseL( KPnpPaosResponse );

        CleanupStack::PopAndDestroy( pnpUtil );

        CleanupStack::PopAndDestroy(); // pnpLibrary.Close();

        return;

        }

    LOGSTRING( "CPnpPaosXml::ConstructPnPPaosResponseL 2" );

    // MNCs and MCCs

    LOGSTRING( "CPnpPaosXml::ConstructPnPPaosResponseL 2.01" );

    pnpUtil->FetchHomeNetworkInfoL();

    LOGSTRING( "CPnpPaosXml::ConstructPnPPaosResponseL 2.1" );

    TRAPD( err, pnpUtil->FetchNetworkInfoL() );

    if( err != KErrNone )

        {

        LOGSTRING2( "CPnpPaosXml::Could not fetch network info %i", err );

        pnpUtil->SetNetworkMccL( _L("") );

        pnpUtil->SetNetworkMncL( _L("") );

        }

    LOGSTRING( "CPnpPaosXml::ConstructPnPPaosResponseL 2.2" );

    RMobilePhone::TMobilePhoneNetworkCountryCode homeMcc = pnpUtil->HomeMccL();

    LOGSTRING( "CPnpPaosXml::ConstructPnPPaosResponseL 2.3" );

    RMobilePhone::TMobilePhoneNetworkIdentity homeMnc = pnpUtil->HomeMncL();

    LOGSTRING( "CPnpPaosXml::ConstructPnPPaosResponseL 2.4" );

    RMobilePhone::TMobilePhoneNetworkCountryCode networkMcc = pnpUtil->NetworkMccL();

    LOGSTRING( "CPnpPaosXml::ConstructPnPPaosResponseL 2.5" );

    RMobilePhone::TMobilePhoneNetworkIdentity networkMnc = pnpUtil->NetworkMncL();

    LOGSTRING( "CPnpPaosXml::ConstructPnPPaosResponseL 2.6" );

    TBuf8<4> hmcc;

    TBuf8<8> hmnc;

    TBuf8<4> nmcc;

    TBuf8<8> nmnc;

    hmcc.Copy( homeMcc );

    hmnc.Copy( homeMnc );

    nmcc.Copy( networkMcc );

    nmnc.Copy( networkMnc );

    LOGSTRING( "CPnpPaosXml::ConstructPnPPaosResponseL 3" );

    // keyinfo, nonce

    TBuf8<KMaxKeyInfoLength> keyInfo;

    pnpUtil->GetKeyInfoL( keyInfo );

    TBuf8<KNonceLength> nonce;

    TInt timeout(0);

    pnpUtil->CreateNewNonceL( timeout, nonce );

    LOGSTRING( "CPnpPaosXml::ConstructPnPPaosResponseL 4" );

    // product model

    TBuf8<KSysUtilVersionTextLength> deviceinfo;

    FetchProductModelL( deviceinfo );

	// Clear all service activation data in case if service 

	// activation fails

	// This will avoid displaying service specific notes for

	// example email service activation when help-portal service required

	// As of now only Help-portal server sends PAOS request 

	// and NSA server(which provides email service activation) is not 

	// supporting PAOS.

	// If NSA server provides PAOS then these resetting of

	// service activation data to be commented

    CPnpProvUtil* prov = CPnpProvUtil::NewLC();

    const TUint32 uidval = 0;

    prov->SetApplicationUidL(uidval);

    TBuf<2> buf(_L(""));

    prov->SetProvAdapterAppIdL(buf);

    CleanupStack::PopAndDestroy();

    LOGSTRING( "CPnpPaosXml::ConstructPnPPaosResponseL format response" );

    // 1. Keyinfo

    // 2. Nonce

    // 3. Home MCC

    // 4. Home MNC

    // 5. Network (current) MCC

    // 6. Network MNC

    // 7. Version

    // 8. deviceinfo

    ConstructPaosResponseL( KPnpPaosResponse, keyInfo, nonce, hmcc, hmnc, nmcc, nmnc, version, deviceinfo );

    LOGSTRING( "CPnpPaosXml::ConstructPnPPaosResponseL response formatted" );

    LOGSTRING( "CleanupStack::PopAndDestroy( pnpUtil )" );

    CleanupStack::PopAndDestroy( pnpUtil );

    LOGSTRING( "pnpLibrary.Close()" );

    CleanupStack::PopAndDestroy(); // pnpLibrary.Close()

    LOGSTRING( "CPnpPaosXml::ConstructPnPPaosResponseL - done" );

    }

void CPnpPaosXml::ConstructPaosResponseL(

    const TDesC8& aResponse,

    const TDesC8& aParameter1,

    const TDesC8& aParameter2,

    const TDesC8& aParameter3,

    const TDesC8& aParameter4,

    const TDesC8& aParameter5,

    const TDesC8& aParameter6,

    const TDesC8& aParameter7,

    const TDesC8& aParameter8

    )

    {

    // Construct PAOS message id element if reference message id is available

    HBufC8* messageIds(0);

    if( iReferenceMessageId->Length() )

        {

        LOGSTRING( "iMessageId:" );

        LOGTEXT( *iMessageId );

        LOGSTRING( "iReferenceMessageId:" );

        LOGTEXT( *iReferenceMessageId );

        messageIds = HBufC8::NewLC(

            KPaosResponseMessageIds().Length() +

            iMessageId->Length() +

            iReferenceMessageId->Length() );

        messageIds->Des().Format( KPaosResponseMessageIds, iMessageId, iReferenceMessageId );

        }

    LOGSTRING( "CPnpPaosXml::ConstructPaosResponseL" );

    // Construct a new PAOS response

    TInt responseLength(

        aResponse.Length() +

        aParameter1.Length() +

        aParameter2.Length() +

        aParameter3.Length() +

        aParameter4.Length() +

        aParameter5.Length() +

        aParameter6.Length() +

        aParameter7.Length() +

        aParameter8.Length()

        );

    // Add the length of messageIds buffer to responseLength

    if( messageIds )

        responseLength += messageIds->Length();

    // Expand buffer if needed

    if( iPaosResponse->Des().MaxSize() < responseLength )

        iPaosResponse = iPaosResponse->ReAllocL( responseLength );

    LOGSTRING( "CPnpPaosXml::ConstructPaosResponseL - format" );