/*

* Copyright (c) 2005 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:  Implementation of the User Data Transfer module

*

*/

// INCLUDE FILES

#include "DrmUdtHandler.h"

#include "DrmUdtConn.h"

#include "RoapStorageClient.h"

#include "DrmRightsClient.h"

#include "DrmUdtObserver.h"

#include <hash.h>

#include <stringpool.h>

#include <http/thttphdrval.h>

#include <etelmm.h> 

#include <mmtsy_names.h>

#ifdef _DEBUG

#define LOGGING

#endif

#define LOGGING

#ifdef LOGGING

_LIT(KLogDir, "DRM");

_LIT(KLogName, "UDT.log");

#include "flogger.h"

#define LOG(string) \

	RFileLogger::Write(KLogDir, KLogName, \

		EFileLoggingModeAppend, string);

#define LOGINT(string, val) \

	RFileLogger::WriteFormat(KLogDir, KLogName, \

		EFileLoggingModeAppend, string, val);

#define LOGHEX(buffer) \

	RFileLogger::HexDump(KLogDir, KLogName, \

		EFileLoggingModeAppend, _S(""), _S(""), \

		buffer.Ptr(), buffer.Length());

#else

#define LOG

#define LOGHEX        

#endif

using namespace Roap;

// ================= CONSTANTS ======================

// The time out value in HTTP, 30 sec

LOCAL_D const TInt KUdtTimeoutValue = 30000000;

LOCAL_D const TInt KMaxSerNumLength = 64;

LOCAL_D const TInt KRdbKeyLength = 256;

LOCAL_D const TInt KVersionSize = 1;

LOCAL_D const TInt KMessageIdSize = 1;

LOCAL_D const TInt KLengthSize = 4;

LOCAL_D const TInt KSignatureLength = 128;

LOCAL_D const TInt KVersion = 0;

LOCAL_D const TInt KPadding255 = 1;

_LIT8( KUdtContentType, "application/binary" );

// UDT message identifiers

LOCAL_D const TUint8 KUdtRequestId = 0;

LOCAL_D const TUint8 KUdtResponseId = 1;

LOCAL_D const TUint8 KStatusResponseId = 3;

LOCAL_D const TUint8 KErrorResponseId = 4;

LOCAL_D const TUint8 KServerErrorValue = 0;

LOCAL_D const TUint8 KClientErrorValue = 1;

LOCAL_D const TInt KUdtResponseSize = 129;

NONSHARABLE_STRUCT( TUnloadModule )

    {

    RTelServer* iServer;

    const TDesC* iName;

    };

// ================= LOCAL FUNCTIONS =========================

LOCAL_C void WriteIntToBlock( TInt aValue, TDes8& aBlock, TInt aOffset )

    {

    aBlock.SetLength(4);

    aBlock[aOffset] =     (aValue & 0xff000000) >> 24;

    aBlock[aOffset + 1] = (aValue & 0x00ff0000) >> 16;

    aBlock[aOffset + 2] = (aValue & 0x0000ff00) >> 8;

    aBlock[aOffset + 3] = (aValue & 0x000000ff);

    }

template<class S>

void PointerArrayResetDestroyAndClose(TAny* aPtr)

    {

    (reinterpret_cast<RPointerArray<S>*>(aPtr))->ResetAndDestroy();

    (reinterpret_cast<RPointerArray<S>*>(aPtr))->Close();

    }

LOCAL_C void DoUnloadPhoneModule( TAny* aAny )

    {

    __ASSERT_DEBUG( aAny, User::Invariant() );

    TUnloadModule* module = ( TUnloadModule* ) aAny;

    module->iServer->UnloadPhoneModule( *( module->iName ) );

    } 

// ================= MEMBER FUNCTIONS =======================

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

// CDrmUdtHandler::NewL()

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

//

EXPORT_C CDrmUdtHandler* CDrmUdtHandler::NewL( )

    {

    LOG( _L("CDrmUdtHandler:NewL:") );

    CDrmUdtHandler* handler = new( ELeave ) CDrmUdtHandler();

    CleanupStack::PushL( handler );

    handler->ConstructL();

    CleanupStack::Pop( handler );

    return handler;

    }

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

// CDrmUdtHandler::~CDrmUdtModule()

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

//

CDrmUdtHandler::~CDrmUdtHandler()

    {

    LOG( _L("CDrmUdtHandler::~CDrmUdtHandler") );

    Cancel();

	iSession.Close();

	delete iConnection;

	delete iUri;

	delete iTimeout;

    delete iOneTimePassword;

    delete iUdtRequest;

    delete iUdtResponse;

    }

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

// CDrmUdtHandler::ConstructL()

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

//

void CDrmUdtHandler::ConstructL() 

    {

    LOG( _L("CDrmUdtHandler::ConstructL") );

    iConnection = CDrmUdtConn::NewL();

    iTimeout = CPeriodic::NewL( CActive::EPriorityUserInput );

    iRequestType = EUdtRequest;

    iUdtError = EUdtOk;

    iStateInfo.iState = TUdtStateInfo::EUdtNotStarted;

    iStateInfo.iProgress = 0;

    iStateInfo.iError = EUdtOk;

    }

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

// CDrmUdtHandler::DoUserDataTransferL()

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

//

EXPORT_C void CDrmUdtHandler::DoUserDataTransferL( const TDesC8& aOneTimePassword,

                                                   const TDesC8& aServiceUrl,

                                                   MDrmUdtObserver* aObserver,

                                                   TRequestStatus& aStatus )

    {

    LOG( _L("CDrmUdtHandler::DoUserDataTransferL") );

    __ASSERT_ALWAYS( iState == EInit, User::Invariant() );

    /*

    1. fetch original RDB data from the rights client (serial number and key)

    2. create UDT package with the original RDB data, the one time password,

       our serial number and our certificate

    3. open a connection to the service URL

    4. do a POST to the service URL, sending our UDT package

    5. receive the anwser with the re-encrypted RDB key

    6. tell the rights client to do a restore, using the re-encrypted RDB key

    7. do a POST to the service URL, sendind a success or error notification

    */

    iOneTimePassword = aOneTimePassword.AllocLC();

    iUri = aServiceUrl.AllocL();

    iObserver = aObserver;

    LOG( _L8("Password: ") );

    LOG( aOneTimePassword );

    LOG( _L8("URL: ") );

    LOG( aServiceUrl );

    iParentStatus = &aStatus;    

    *iParentStatus = KRequestPending;

    iState = EStart;

    TRequestStatus* ownStatus = &iStatus;    

    *ownStatus = KRequestPending;

    iRequestType = EUdtRequest;

    SetActive();

    User::RequestComplete( ownStatus, KErrNone );      

    CleanupStack::Pop(); // iOneTimePassword    

    }

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

// CDrmUdtHandler::SetPreferredIap()

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

EXPORT_C void CDrmUdtHandler::SetPreferredIap( TUint32 aPreferredIap )

    {

    LOG( _L("CDrmUdtHandler::SetPreferredIap") );

    iPreferredIap = aPreferredIap;

    }    

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

// CDrmUdtHandler::DoCancel()

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

//

void CDrmUdtHandler::DoCancel()

    {

    LOG( _L("CDrmUdtHandler::DoCancel") );

    switch ( iState )

        {

        case EStart:

        case EConnect:

            {

            iConnection->Cancel();

            break;

            }

        case EResponseReceived:

            {

            iTransaction.Close();

            SelfComplete( iError );

            break;

            }

        default:

            {

            break;

            }

        }

	iError = KErrCancel;

	Complete();

    }

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

// CDrmUdtHandler::RunL()

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

//

void CDrmUdtHandler::RunL()

    {

    LOG( _L("CDrmUdtHandler::RunL") );

    User::LeaveIfError( iStatus.Int() );

    switch ( iState )

        {

        case EStart:

            {

            ConnectL();

            break;

            }        

        case EConnect:

            {

            CreateSessionL();

            break;

            }

        case ESendMessage:

            {

            SendUdtMessageL();

            break;

            }

        case EResponseReceived:

            {

            ResponseReceivedL();

            break;

            }

        case EComplete:

            {

            iState = EInit;

    		Complete();

            break;

            }

        case EInit:

        default:

            {

            break;

            }

        }

    }

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

// CDrmUdtHandler::RunError()

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

//

TInt CDrmUdtHandler::RunError( TInt aError )

    {

    LOG( _L("CDrmUdtHandler::RunError") );

    iError = aError;

    iState = EInit;

    Complete();

    return KErrNone;

    }

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

// CDrmUdtHandler::ConnectL()

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

//

void CDrmUdtHandler::ConnectL()

    {

    LOG( _L("CDrmUdtHandler::ConnectL") );

    __ASSERT_ALWAYS( iState == EStart, User::Invariant() );

    iConnection->ConnectL( iPreferredIap, iObserver, &iStatus );

    iState = EConnect;

    iError = EUdtOk;

    SetActive();

    }

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

// CDrmUdtHandler::CreateSessionL()

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

//

void CDrmUdtHandler::CreateSessionL()

    {

    LOG( _L("CDrmUdtHandler::CreateSessionL") );

    __ASSERT_ALWAYS( iState == EConnect, User::Invariant() );

    TUint32 ap;

    if( !iConnection->IsConnected( ap ) )

        {

        User::Leave( KErrGeneral );

        }

    iSession.Close();

    iSession.OpenL();

    RStringPool strPool = iSession.StringPool();

    // Remove first session properties just in case.

    RHTTPConnectionInfo connInfo = iSession.ConnectionInfo();

    // Clear RConnection and Socket Server instances

    connInfo.RemoveProperty(strPool.StringF(HTTP::EHttpSocketServ,RHTTPSession::GetTable()));

    connInfo.RemoveProperty(strPool.StringF(HTTP::EHttpSocketConnection,RHTTPSession::GetTable()));

#ifdef __WINS__    

    // Clear the proxy settings

    RStringF proxy;

    proxy = strPool.OpenFStringL(_L8("172.22.168.15"));

    connInfo.SetPropertyL

        ( 

        strPool.StringF( HTTP::EProxyAddress, RHTTPSession::GetTable() ), 

        THTTPHdrVal( proxy ) 

        );

    proxy.Close();

    connInfo.SetPropertyL

        ( 

        strPool.StringF( HTTP::EProxyUsage, RHTTPSession::GetTable() ), 

        THTTPHdrVal( strPool.StringF(HTTP::EUseProxy, RHTTPSession::GetTable() ) )

        );

#else

    THTTPHdrVal proxyUsage(strPool.StringF(HTTP::EUseProxy,RHTTPSession::GetTable()));

    connInfo.RemoveProperty(strPool.StringF(HTTP::EProxyUsage,RHTTPSession::GetTable()));

    connInfo.RemoveProperty(strPool.StringF(HTTP::EProxyAddress,RHTTPSession::GetTable()));

#endif

    connInfo.SetPropertyL

        (

        strPool.StringF( HTTP::EHttpSocketServ, RHTTPSession::GetTable() ),

        THTTPHdrVal( iConnection->SocketServ().Handle() )

        );

    connInfo.SetPropertyL

        ( 

        strPool.StringF( HTTP::EHttpSocketConnection, RHTTPSession::GetTable() ), 

        THTTPHdrVal( REINTERPRET_CAST( TInt, &iConnection->Conn() ) )

        );

    InstallHttpFiltersL();

    // Complete requests

    TRequestStatus* ownStatus = &iStatus;    

    *ownStatus = KRequestPending;

    iState = ESendMessage;

    SetActive();

    User::RequestComplete( ownStatus, KErrNone );

    }

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

// CDrmUdtModule::InstallHttpFilters()

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

//

void CDrmUdtHandler::InstallHttpFiltersL()

    {

    LOG( _L("CDrmUdtHandler::InstallHttpFiltersL") );

 // CHttpUAProfFilterInterface::InstallFilterL( iSession );

 // CHttpCookieFilter::InstallFilterL( iSession );

 // InstallAuthenticationL( iSession );

 // CHttpFilterProxyInterface::InstallFilterL( iSession );

    }

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

// CDrmUdtHandler::SendUdtMessageL()

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

//

void CDrmUdtHandler::SendUdtMessageL()

    {

    LOG( _L("CDrmUdtHandler::SendUdtMessageL") );

    __ASSERT_ALWAYS( iState == ESendMessage, User::Invariant() );

    TUriParser8 uri;

    if ( iRequestType == EUdtRequest )

        {

        CreateUdtRequestL();

        }

    else if( iRequestType == EStatusNotification )

        {

        CreateStatusNotificationL();

        }

    User::LeaveIfError( uri.Parse( *iUri ) );

    RStringF POST;

    POST = iSession.StringPool().StringF( HTTP::EPOST, RHTTPSession::GetTable() );

    iTransaction = iSession.OpenTransactionL( uri, *this, POST );

    // Set required headers

    RHTTPHeaders hdrs = iTransaction.Request().GetHeaderCollection();

    SetHeaderL(hdrs, HTTP::EAccept, KUdtContentType() );

    SetHeaderL(hdrs, HTTP::EContentType, KUdtContentType() );

    // Add request body

    MHTTPDataSupplier* ds = this;

    iTransaction.Request().SetBody(*ds);

    iTransaction.SubmitL();

    iState = EResponseReceived;

    iStatus = KRequestPending;

    SetActive();

    iTimeout->Cancel();

    iTimeout->Start( KUdtTimeoutValue,

    				 KUdtTimeoutValue,

    				 TCallBack( StaticTimeOut,this ) );

    }

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

// CDrmUdtHandler::CreateUdtRequestL()

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

//    

void CDrmUdtHandler::CreateUdtRequestL()

    {

    RRoapStorageClient client;

    RPointerArray< HBufC8 > certChain;

    TCleanupItem listCleanup( PointerArrayResetDestroyAndClose< HBufC8 >,

        &certChain );

    HBufC8* certBlock;

    TInt i;

    TInt n;

    TPtr8 ptr( NULL, 0 );

    TBuf8< sizeof ( TUint32 ) > intBuf;

    TBuf8< KMaxSerNumLength > targetSer;

    TBuf8< KRdbKeyLength > rdb_data;

    TBuf8< KSignatureLength > hash;

    HBufC8* signature = NULL;

    TInt udtVersion;

    CSHA1* hasher = NULL;

    LOG( _L("CDrmUdtHandler::CreateUdtRequestL") );

    delete iUdtRequest;

    if ( iObserver )

        {

        iStateInfo.iState = TUdtStateInfo::EUdtReguest;

        iStateInfo.iProgress = 0;

        iObserver->UdtProgressInfoL( iStateInfo );

        }

    hasher = CSHA1::NewL();

    CleanupStack::PushL( hasher );

    User::LeaveIfError( client.Connect() );

    CleanupClosePushL( client );

    client.SelectTrustedRootL( KNullDesC8 );

    LOG( _L("  Getting cert chain") );

    User::LeaveIfError( client.GetDeviceCertificateChainL( certChain ) );

    CleanupStack::PushL( listCleanup );

    LOG( _L("  Getting UDT data") );

    ReadUdtDataL( targetSer, udtVersion, rdb_data );

    LOG(_L8("RDB data:"));    

    LOGHEX(rdb_data)

    n = 0;

    for ( i = 0; i < certChain.Count(); i++ )

        {

        n = n + KLengthSize + certChain[i]->Size();

        }

    certBlock = HBufC8::NewL( n );

    CleanupStack::PushL( certBlock );

    ptr.Set( certBlock->Des() );

    for ( i = 0; i < certChain.Count(); i++ )

        {

        WriteIntToBlock( certChain[i]->Size(), intBuf, 0 );

        ptr.Append( intBuf );

        ptr.Append( *certChain[i] );

        }

    n = KVersionSize + 

        KMessageIdSize + 

        KLengthSize + 

        iOneTimePassword->Size() + 

        KLengthSize +

        certBlock->Size() + 

        KLengthSize +