/*

* Copyright (c) 2007 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 bootstrap and data retriever

*

*/

#include <e32math.h> 

#include <hash.h>

#include <commdb.h>

#include <es_enum.h>

#include <centralrepository.h>

#include <cmconnectionmethoddef.h>

#include <cmpluginpacketdatadef.h>

#include <http/thttpevent.h>

#include "dataretriever.h"

#include "GbaCommon.h"

#include "GBALogger.h"

#include "bootstrap.h"	 

_LIT8(KUserAgent,"S60 GBA 1.0");

_LIT8(KAccept,"*/*");

_LIT8(KNCVal_2, ":00000001:");

_LIT8(Kfopaque,"");

_LIT8(Kfalgo,"AKAv1-MD5");

_LIT8(Kalgorithm,"algorithm");

_LIT8(formatStr, "%02x");

_LIT8(KAuthInt,"auth-int");

_LIT8(KAuts,"auts");

_LIT8(KHTTPAuthInfo,"Authentication-Info");

_LIT8(KMD5HashofEmpty,"d41d8cd98f00b204e9800998ecf8427e");

_LIT8(KClose, "Close");

_LIT(KColon, ":");

//Constants

const TInt KNumber3 = 3;

const TInt KNumber5 = 5;

const TInt KNumber8 = 8;

const TInt KNumber32 = 32;

const TInt KNumber33 = 33;

const TInt KNumber34 = 34;

// Length of a digest hash when represented in hex

const TInt KHashLength = 32;

// Length of a digest hash before converting to hex.

const TInt KRawHashLength = 16;

const TInt KMaxRequestBuffer = 255;

const TInt KAlgLength = 40;

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

// CDataRetriever::NewL()

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

//

CDataRetriever* CDataRetriever::NewL( MBootstrapCallBack* aBootstrapCallBack )

    {

    CDataRetriever* self = NewLC( aBootstrapCallBack );

    CleanupStack::Pop( self );

    return self;

    }

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

// CDataRetriever::NewLC()

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

//

CDataRetriever* CDataRetriever::NewLC( MBootstrapCallBack* aBootstrapCallBack )

    {

    CDataRetriever* self = new (ELeave) CDataRetriever( aBootstrapCallBack ) ;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CDataRetriever::CDataRetriever()

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

//

CDataRetriever::CDataRetriever( MBootstrapCallBack* aBootstrapCallBack ) 

    : iBootstrapCallBack( aBootstrapCallBack ) 

    { 

    }

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

// CDataRetriever::ConstructL()

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

//

void CDataRetriever::ConstructL()

    {

    iHttpHandler = C3GPPBootstrapHttpHandler::NewL( this, iBootstrapCallBack );

    iInternalState = EReadyForRequest;

    }

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

// CDataRetriever::~CDataRetriever()

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

//

CDataRetriever::~CDataRetriever()

    {

    GBA_TRACE_DEBUG(("CDataRetriever::~CDataRetriever"));

    delete iHttpHandler;

    iHTTPTransaction.Close();

    iHTTPSession.Close();

    iConnection.Close();

    iSockServ.Close();

    if ( iInternalState == EMakeRequestCalled )

        {

        GBA_TRACE_DEBUG(("CDataRetriever::~CDataRetriever EMakeRequestCalled"));

        User::RequestComplete(iCallerRequestStatus, KErrCancel);

        }

    GBA_TRACE_DEBUG(("CDataRetriever::~CDataRetriever End"));

    }

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

// CDataRetriever::EventRequestCompletedL()

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

//

void CDataRetriever::EventRequestCompletedL(TInt aErrorCode)

    {

    GBA_TRACE_DEBUG(("CDataRetriever::EventRequestCompletedL enter"));

    if ( iInternalState == EMakeRequestCalled )

        {

        GBA_TRACE_DEBUG(("CDataRetriever::EventRequestCompletedL EMakeRequestCalled"));

        TRAPD( err, iBootstrapCallBack->CompleteBootStrappingL( aErrorCode ) );

        if( err == KErrNone )

            User::RequestComplete(iCallerRequestStatus,aErrorCode);

        else

            User::RequestComplete(iCallerRequestStatus, err);

        // Get Ready for new request

        iHttpHandler->Reset();

        iHTTPTransaction.Close();

        iHTTPSession.Close();

        iConnection.Close();

        iSockServ.Close();

        iInternalState = EReadyForRequest;

        }

    }

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

// CDataRetriever::CancelRequest()

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

//

void CDataRetriever::CancelRequest()

    {

    GBA_TRACE_DEBUG(("CDataRetriever::CancelRequest"));

    if ( iInternalState == EMakeRequestCalled )

        {        

        iInternalState = EReadyForRequest;

        iHttpHandler->Reset();

        iHTTPTransaction.Close();

        iHTTPSession.Close();

        iConnection.Close();

        iSockServ.Close();

        User::RequestComplete( iCallerRequestStatus, KErrCancel );

        }

    }

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

// CDataRetriever::MakeRequestL()

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

//

void CDataRetriever::MakeRequestL(

                 TRequestStatus* aRequestStatus,

                 const TDesC8& aIdentity,

                 const TDesC8& aRealm,

                 const TDesC8& aBsfUri,

                 const TDesC8& aReferrerNAFUri,

                 const TInt& aIAPID )

    {

    GBA_TRACE_BEGIN(); 

    if ( iInternalState != EReadyForRequest )

        {        

        User::LeaveIfError( KErrInUse );

        }

    iCallerRequestStatus = aRequestStatus;

    SetupSessionL( aIAPID );

    // Add headers appropriate to all methods

    TUriParser8 URIParse; 

    User::LeaveIfError( URIParse.Parse( aBsfUri ) );

    iHTTPTransaction = iHTTPSession.OpenTransactionL( URIParse, *iHttpHandler );

    RHTTPHeaders hdr = iHTTPTransaction.Request().GetHeaderCollection();

    GBA_TRACE_DEBUG(URIParse.Extract(EUriHost) );

    SetHeaderL(hdr,HTTP::EHost, URIParse.Extract(EUriHost) );     

    SetHeaderL(hdr,HTTP::EUserAgent, KUserAgent);

    SetHeaderL(hdr,HTTP::EAccept, KAccept);     

    SetHeaderL(hdr,HTTP::EReferer, aReferrerNAFUri);

    SetHeaderL(hdr, HTTP::EConnection, KClose);

    TBuf8<KMaxRequestBuffer> bufAuth;

    bufAuth.Copy(_L8("Digest username=\""));

    bufAuth.Append(aIdentity);

    bufAuth.Append(_L8("\", realm=\""));

    bufAuth.Append(aRealm);

    bufAuth.Append(_L8("\", nonce=\"\", uri=\"/\", response=\"\""));

    GBA_TRACE_DEBUG(bufAuth);

    SetHeaderL(hdr,HTTP::EAuthorization,bufAuth);

    iHTTPTransaction.SubmitL();    

    iInternalState = EMakeRequestCalled;

    GBA_TRACE_END();

    }

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

// CDataRetriever::SetHeaderL()

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

//

void CDataRetriever::SetHeaderL(RHTTPHeaders aHeaders, TInt aHdrField, const TDesC8& aHdrValue)

    {

    RStringF valStr = iHTTPSession.StringPool().OpenFStringL(aHdrValue);

    THTTPHdrVal val(valStr);

    aHeaders.SetFieldL(iHTTPSession.StringPool().StringF(aHdrField,RHTTPSession::GetTable()), val);

    valStr.Close();

    }

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

// CDataRetriever::SetupSessionL()

// Establish a connection for bootstrapping

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

//

void CDataRetriever::SetupSessionL( const TInt& aIAPID )

    {

    GBA_TRACE_DEBUG(("CDataRetriever::SetupSession"));

    // check that sockserver is available

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

    GBA_TRACE_DEBUG(("Socket server connected")); 

    // check that connection is possible

    User::LeaveIfError(iConnection.Open(iSockServ) );

    GBA_TRACE_DEBUG(("Connection opened")); 

    if ( !ValidateGivenIAPIDL( aIAPID ) )

        {	

        GBA_TRACE_DEBUG(("No valid iapid from user")); 

        TConnSnapPref snapPref;

        TUint32 snapid = GetInternetDestIDL();

        GBA_TRACE_DEBUG_NUM(("the chosen snap id is %d"), snapid ); 

        snapPref.SetSnap( snapid );

        TInt err = iConnection.Start( snapPref );

        if ( err != KErrNone )

            {

            GBA_TRACE_DEBUG_NUM(("internet nap error is %d"), err ); 

            TCommDbConnPref connPref;

            connPref.SetDialogPreference( ECommDbDialogPrefPrompt );

            User::LeaveIfError( iConnection.Start( connPref ) );

            }    

       }

    else

        {

        GBA_TRACE_DEBUG(("User gives valid iapid go with it"));

        //given iapid is valid, go with it

        TCommDbConnPref connPref;

        connPref.SetDirection( ECommDbConnectionDirectionOutgoing );

        //No dialog present

        connPref.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );

        connPref.SetIapId( aIAPID );	

        User::LeaveIfError( iConnection.Start( connPref ) );

        }

    GBA_TRACE_DEBUG(("Access point selection done!"));       

    GBA_TRACE_DEBUG(("CDataRetriever::SetupSession, connect choosen is done "));

    iHTTPSession.OpenL();

    //GBA Http  filter gets loaded into to http session when session is opened

	//Remove GBA http filter from http session iHTTPSession

    //Reason: Ub interface should not have the User-Agent string "3gpp-gba"

	RStringF filterName = iHTTPSession.StringPool().OpenFStringL( KHTTPFilterGBAName );

    CleanupClosePushL<RStringF>( filterName );

    iHTTPSession.FilterCollection().RemoveFilter( filterName );

    CleanupStack::PopAndDestroy( &filterName );

    GBA_TRACE_DEBUG(("Session opened"));  

    //Set selected access point.

    RStringPool strPool = iHTTPSession.StringPool();

    RHTTPConnectionInfo httpconnInfo = iHTTPSession.ConnectionInfo();

    httpconnInfo.SetPropertyL ( strPool.StringF(HTTP::EHttpSocketServ,

            RHTTPSession::GetTable() ), THTTPHdrVal (iSockServ.Handle()) );

    TInt connPtr = REINTERPRET_CAST(TInt, &iConnection);

    httpconnInfo.SetPropertyL ( strPool.StringF(HTTP::EHttpSocketConnection,

              RHTTPSession::GetTable() ), THTTPHdrVal (connPtr) );

    //if 2G interface and cert is untrusted, surpress the warning dialog

    if ( iBootstrapCallBack->InterfaceIs2G() )

        {

        //surpress the warning dialog

        httpconnInfo.SetPropertyL ( strPool.StringF(HTTP::ESecureDialog,

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

              RHTTPSession::GetTable() )  );

        }

    GBA_TRACE_DEBUG(("SetupSession done")); 

    }

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

// CDataRetriever::ValidateGivenIAPIDL()

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

//

TBool CDataRetriever::ValidateGivenIAPIDL( const TInt& aIAPID )

    {

    using namespace CMManager;

    GBA_TRACE_DEBUG((" start valid iapid given by user"));

    //aIAPID == -1 selected default accesspoint

    if ( aIAPID == -1 )

        {

        return EFalse;

        }

    else

        {

        TInt CleanupCounter = 0;

        RArray<TUint32> destIdArray;

        CleanupClosePushL( destIdArray );

        CleanupCounter++;

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

           {

           CleanupClosePushL( dest );

           CleanupCounter++;

           for ( TInt j=0; j < dest.ConnectionMethodCount(); j++ )

              {

              TUint32 iapId = dest. ConnectionMethodL(j).GetIntAttributeL( ECmIapId );

              if ( iapId == aIAPID )

                  {

                  GBA_TRACE_DEBUG((" IAPID matches !!"));

                  CleanupStack::PopAndDestroy( CleanupCounter );

                  return ETrue;

                  }

              }

           CleanupStack::PopAndDestroy( &dest ); //dest

           CleanupCounter--; // dest

           }

        GBA_TRACE_DEBUG((" search is over no matching IAPID!!"));

        CleanupStack::PopAndDestroy( CleanupCounter );

        return EFalse;    

        }    

    }

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

// CDataRetriever::QueryResponseValueL()

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

//

HBufC8* CDataRetriever::QueryResponseValueL() 

    {

    return iHttpHandler->GetResponse();

    } 

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

// CDataRetriever::GetInternetDestIDL()

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

//

TUint32 CDataRetriever::GetInternetDestIDL()

    {

    using namespace CMManager;

    GBA_TRACE_DEBUG((" Get the Dest ID of Internet"));

    TInt CleanupCounter = 0;

    RArray<TUint32> destIdArray;

    CleanupClosePushL( destIdArray );

    CleanupCounter++;

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

         {

         CleanupClosePushL( dest );

         CleanupCounter++;

         if ( dest.MetadataL( ESnapMetadataInternet ) )

             {

             GBA_TRACE_DEBUG_NUM((" found the internet dest id = %d"), destIdArray[i] );

             TUint32 desID = destIdArray[i];

             CleanupStack::PopAndDestroy( CleanupCounter );

             return desID; 

             }

         CleanupStack::PopAndDestroy( &dest );

         CleanupCounter--; // dest

         }

    GBA_TRACE_DEBUG(("not found the internet dest id") );

    CleanupStack::PopAndDestroy( CleanupCounter );

    return NULL;

	}

// C3GPPBootstrapHttpHandler 

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

// C3GPPBootstrapHttpHandler::ConstructL()

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

//

void C3GPPBootstrapHttpHandler::ConstructL()

    {

    iResponse=HBufC8::NewL(KMaxBootstrapRespLen);

    iMD5Calculator =  CMD5::NewL(); 

    iSucceeded=EFalse;

    }

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

// C3GPPBootstrapHttpHandler::C3GPPBootstrapHttpHandler()

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

//

C3GPPBootstrapHttpHandler::C3GPPBootstrapHttpHandler( MHttpRequestEvents* aEventSink, M3GPPAuthenticationCallback* aDataRetrieverCallBack )

        : iEventSink ( aEventSink ), iDataRetrieverCallBack ( aDataRetrieverCallBack )

    {

    }

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

// C3GPPBootstrapHttpHandler::~C3GPPBootstrapHttpHandler()

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

//

C3GPPBootstrapHttpHandler::~C3GPPBootstrapHttpHandler()

    {

    GBA_TRACE_DEBUG(("C3GPPBootstrapHttpHandler::~C3GPPBootstrapHttpHandler()"));

    Reset();

	delete iResponse;

	delete iMD5Calculator;

    GBA_TRACE_DEBUG(("C3GPPBootstrapHttpHandler::~C3GPPBootstrapHttpHandler() end"));

    }

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

// C3GPPBootstrapHttpHandler::Reset()

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

//

void C3GPPBootstrapHttpHandler::Reset()

    {

    // close strings in string pool if they were opened 

    iUsername.Close();

    iPassword.Close();

    iNonce.Close();

    iCnonce.Close();

    iUri.Close();

    iRealm.Close();

    iMethod.Close();

    }

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

// C3GPPBootstrapHttpHandler::NewLC()

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

//

C3GPPBootstrapHttpHandler* C3GPPBootstrapHttpHandler::NewLC( MHttpRequestEvents* aEventSink, 

                                                             M3GPPAuthenticationCallback* aDataRetrieverCallBack )

    {

    C3GPPBootstrapHttpHandler* me = new(ELeave)C3GPPBootstrapHttpHandler( aEventSink, aDataRetrieverCallBack );

    CleanupStack::PushL(me);

    me->ConstructL();

    return me;

    }

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

// C3GPPBootstrapHttpHandler::NewL()

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

//

C3GPPBootstrapHttpHandler* C3GPPBootstrapHttpHandler::NewL( MHttpRequestEvents* aEventSink ,

                                                            M3GPPAuthenticationCallback* aDataRetrieverCallBack )

    {

    C3GPPBootstrapHttpHandler* me = NewLC(aEventSink, aDataRetrieverCallBack );

    CleanupStack::Pop(me);

    return me;

    }

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

// C3GPPBootstrapHttpHandler::MHFRunL()

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

//

void C3GPPBootstrapHttpHandler::MHFRunL( RHTTPTransaction aTransaction, const THTTPEvent& aEvent )

    {

    GBA_TRACE_DEBUG_NUM(("MHFRunL received event %d"), aEvent.iStatus );

    switch (aEvent.iStatus)