/*

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

*

*/

// This component has the following responsibilities 

// 1. Allow configuration of the BSF URL   

// 2. Open http connection to bsf    

// 3. On digest auth req get nonce  

// 4. Use this to find RAND AUTN 

// 5. Execute SIM auth, get back SRES, IK,CK 

// 6. return SRES 

// 7. Store keymaterial  to a token   

#include <ecom.h>

#include "dataretriever.h"

#include "bootstrap.h" 

#include "GbaCommon.h"

#include "GBALogger.h"

#include "GbaSession.h"

const TInt KKsNAFMaxLength = 128;

const TInt KStringLength = 80;

const TInt KMaxLengthIMPI = 255;

const TInt KMaxLengthNAFID = 255; 

const TInt KMaxLengthBTID = 255;

const TInt KMaxLengthKs = 32;

const TInt KMaxLengthRES = 16;          //16 bytes for RES

const TInt KMaxLengthAUTS = 16;         //16 bytes for AUTS

const TInt KMaxLengthEnAUTS = 20;

const TInt KMaxLengthRAND = 16;         //16 bytes for RAND

const TInt KMaxLengthTimeString = 30 ;

const TInt KHTTPTagLength = 7;

const TInt KAlgorithmTybeBufferLength = 32;

const TInt KBufferSize255 = 255;

const TInt KVariableIndex0 = 0;

const TInt KVariableIndex1 = 1;

const TInt KVariableIndex2 = 2;

const TInt KVariableIndex3 = 3;

const TInt KVariableIndex4 = 4;

const TInt KVariableIndex5 = 5;

const TInt KVariableIndex6 = 6;

#define GBA_UICC_INTERFACE_IMPLE        0x20029F0F

#define GBA_SOFTISIM_INTERFACE_IMPLE    0x20029F0E

// XML tags

_LIT8(KBTIDFlag,"<btid>");

_LIT8(KBTIDEndFlag,"</btid>");

_LIT8(KLifetimeFlag,"<lifetime>");

_LIT8(KLifetimeEndFlag,"</lifetime>");

_LIT(KGbaCredentialsFileName, "GbaCredentials.dat");

_LIT(KGBAStoreStandardDrive, "C:");

_LIT(KTimeFormat, "time %d,%d,%d,%d,%d,%d");

_LIT(KErrorMessage, "FAILED error = %d");

_LIT(Kakav1, "akav1");

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

// C3GPPBootstrap::NewL()

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

//

C3GPPBootstrap* C3GPPBootstrap::NewL( CGbaServerSession* aSession )

    {

    C3GPPBootstrap* self = NewLC( aSession );

    CleanupStack::Pop(self);

    return(self) ;

    }

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

// C3GPPBootstrap::NewLC()

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

//

C3GPPBootstrap* C3GPPBootstrap::NewLC( CGbaServerSession* aSession )

    {

    C3GPPBootstrap* self = new (ELeave) C3GPPBootstrap( aSession );

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// C3GPPBootstrap::~C3GPPBootstrap()

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

//

C3GPPBootstrap::~C3GPPBootstrap()

    {

    REComSession::DestroyedImplementation(iDtorIDKey);  

    if(IsActive())

        Cancel();

    if( iSmartCardInterface )

        {

        iSmartCardInterface->Release();

        REComSession::FinalClose();

        }

    delete iKsNAF;

    delete iNAFID;

    delete iRand;

    delete iBTID;

    delete iIdentity;

    delete iMasterKey;

    delete iDataRetriever;

    }

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

// C3GPPBootstrap::ConstructL()

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

//

void C3GPPBootstrap::ConstructL()

    {

    GBA_TRACE_BEGIN();

    GBA_TRACE_DEBUG(("initializing buffers"));

    iKsNAF = HBufC8::NewL(KKsNAFMaxLength);

    iBTID = HBufC8::NewL(KMaxLengthBTID);

    iNAFID = HBufC8::NewL(KMaxLengthNAFID);

    iIdentity = HBufC8::NewL(KMaxLengthIMPI);

    iMasterKey = HBufC8::NewL(KMaxLengthKs);

    iRand = HBufC8::NewL(KMaxLengthRAND);

    GBA_TRACE_DEBUG(("initializing http handler"));

    iDataRetriever  = CDataRetriever::NewL( this );

    iImplementationUID.iUid = GBA_UICC_INTERFACE_IMPLE;

    //if want softisim for testing

    //iImplementationUID.iUid = GBA_SOFTISIM_INTERFACE_IMPLE;

    //Interface is initialized based on the plug in

    if ( !IsPluginExistL() )

        {

        GBA_TRACE_DEBUG(("There aren't plug-in existing"));

        User::LeaveIfError( KErrGeneral );

        }

    GBA_TRACE_DEBUG(("requesting uicc handler"));

    iSmartCardInterface = RequestUICCInterfaceL();

    GBA_TRACE_DEBUG(("request made"));

    if ( !iSmartCardInterface )

        {

        GBA_TRACE_DEBUG(("Get interface failed"));

        User::LeaveIfError( KErrGeneral );

        }

    CActiveScheduler::Add( this );

    GBA_TRACE_END();

    }

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

// C3GPPBootstrap::C3GPPBootstrap()

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

//

C3GPPBootstrap::C3GPPBootstrap( CGbaServerSession* aSession ): CActive( EPriorityStandard ),

        iSmartCardInterface( NULL ), iLifetime ( 0 ),iGBARunType( ENoType ), iBSState(EIdle), iSession ( aSession )

    {

    }

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

// CBootstrapStateMachine::InitializeL()

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

//

void C3GPPBootstrap::InitializeL()

    {

    if ( IsActive() )

        {

        User::LeaveIfError( KErrInUse );

        }

    iBSState = EInitialize;

    GBA_TRACE_DEBUG(("Bootstrapping State machine startL()"));

    iStatus = KRequestPending;

    SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    }

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

// C3GPPBootstrap::RunL()

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

//

void C3GPPBootstrap::RunL()

    {

    GBA_TRACE_DEBUG(("C3GPPBootstrap::RunL() -enter"));

    GBA_TRACE_DEBUG_NUM(("C3GPPBootstrap::RunL iStatus=%d"), iStatus.Int() );

    GBA_TRACE_DEBUG_NUM(("C3GPPBootstrap::RunL iBSState=%d"), iBSState );

    if((iBSState == ECancel) & iStatus.Int() == KErrCancel)

        {

        iBSState = EIdle;

        return;

        }

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

    switch(iBSState)

        {

        case EInitialize:

            {

            GBA_TRACE_DEBUG(("C3GPPBootstrap::RunL() - EInitialize"));

            DoBootstrapL();

            GBA_TRACE_DEBUG(("C3GPPBootstrap::RunL() - EInitialize end"));

            break;  

            }

        case EBusy:

            {

            GBA_TRACE_DEBUG(("C3GPPBootstrap::RunL() - EBusy"));

            iSession->StateMachineCallBack( iStatus.Int() );

            Cleanup();

            GBA_TRACE_DEBUG(("C3GPPBootstrap::RunL() - EBusy end"));

            break;

            }

       default:

           GBA_TRACE_DEBUG(("C3GPPBootstrap::RunL() - default"));

           break;

       }

    GBA_TRACE_DEBUG(("C3GPPBootstrap::RunL() -exit"));

    }

TInt C3GPPBootstrap::RunError(TInt aError)

    {

    GBA_TRACE_DEBUG_NUM(("Failed with error = %d"), aError );

    iSession->StateMachineCallBack( aError );

    //Back to EBootstrapIdle

    iBSState = EIdle;

    return KErrNone;

    }

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

// C3GPPBootstrap::DoCancel()

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

//

void C3GPPBootstrap::DoCancel()

    {

    GBA_TRACE_DEBUG(("C3GPPBootstrap::DoCancel()"));

    switch(iBSState)

        {

         case EInitialize:

         case EBusy:

             {

             GBA_TRACE_DEBUG(("C3GPPBootstrap::DoCancel() EBootstrapDone"));

             CancelBootstrap();

             break;

             }

        default:

            break;

        };

    Cleanup();

    }

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

// C3GPPBootstrap::CancelBootstrap()

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

//

void C3GPPBootstrap::CancelBootstrap()

    {

    GBA_TRACE_BEGIN();

    iBSState = ECancel;

    iDataRetriever->CancelRequest();

    GBA_TRACE_END();

    }

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

// C3GPPBootstrap::DoBootstrapL()

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

//

void C3GPPBootstrap::DoBootstrapL( )

    {

    HBufC8 *BsfUrl = HBufC8::NewLC(KMaxURLLength);

    TPtr8 PtrBSFUrl( BsfUrl->Des() );

    // fetch bsf address override if available

    if ( !iSession->Server()->ReadOptionL( KGbaBSFConfiguration, PtrBSFUrl ) )

        {

        //If no preset bsf, empty the buffer

        //We will calculate the address ourselves

        PtrBSFUrl.Zero();

        }

    GBA_TRACE_DEBUG((" BSF server address:"));

    GBA_TRACE_DEBUG( PtrBSFUrl );

    GetBootstrappingMaterialL(

                                   PtrBSFUrl,

                                   iSession->iGbaInputParams.iNAFName,

                                   iSession->iGbaInputParams.iUICCLabel,

                                   iSession->iGbaInputParams.iFlags,

                                   iSession->iGbaInputParams.iProtocolIdentifier,

                                   iSession->iGbaOutputParams.iKNAF, 

                                   iSession->iGbaOutputParams.iBTID, 

                                   iSession->iGbaOutputParams.iLifetime,

                                   iSession->iGbaOutputParams.iGbaRunType,

                                   iSession->iGbaInputParams.iAPID );

    GBA_TRACE_DEBUG(("Bootstrap Request is sent out, let us wait for callback "));

    CleanupStack::PopAndDestroy( BsfUrl );

    }

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

// C3GPPBootstrap::GetBootstrappingMaterialL()

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

//

void C3GPPBootstrap::GetBootstrappingMaterialL(

                                    const TDesC8& aBSFAddress, 

                                    const TDesC8& aNAFURL,

                                    const TDesC8& aUICC_LABEL,

                                    const TUint8& aFlags,

                                    const TDesC8& aKeyUsage,

                                    TDes8 &aKsNAF, 

                                    TDes8 &aBTID,

                                    TTime &aLifetime,

                                    EGBARunType& aGBARunType, 

                                    const TInt& aIAPID )

    { 

    GBA_TRACE_BEGIN();

    //save the return buffer's pointer. Copy the databack when bootstrapping is done

    iCallerKsNAFBuf = &aKsNAF;

    iCallerLifetime = &aLifetime;

    iCallerBTIDBuf  = &aBTID;

    iCallerGBARunType = &aGBARunType;

    TUriParser8 uriparser;

    GBA_TRACE_DEBUG(("the given naf url is:"));    

    GBA_TRACE_DEBUG(aNAFURL);

    //this implementation is used to solve symbian API's problem

    // when parsing pure ip address

    if ( (aNAFURL.FindF(KHTTPTag) != KErrNotFound) || (aNAFURL.FindF(KHTTPSTag) != KErrNotFound) )

        {

        //the naf url has http tag

        User::LeaveIfError( uriparser.Parse(aNAFURL) );

        } 

    else

        {

        GBA_TRACE_DEBUG(("the naf url has no http tag, add one for parser"));

        HBufC8* temp = HBufC8::NewL( aNAFURL.Length() +  KHTTPTagLength );

        CleanupStack::PushL(temp);

        TPtr8 ptrtemp = temp->Des();

        ptrtemp.Copy( KHTTPTag );

        ptrtemp.Append(aNAFURL);

        GBA_TRACE_DEBUG( *temp );

        User::LeaveIfError( uriparser.Parse( *temp ) );

        CleanupStack::PopAndDestroy(temp);

        }

    //Calculate the NAFID, NAFID= NAF_FQDN + keyusage

    TPtr8 ptrNAFID = iNAFID->Des();

    //parse the FQDN out from NAFaddress

    ptrNAFID.Copy( uriparser.Extract(EUriHost) );

    ptrNAFID.Append( aKeyUsage );

    GBA_TRACE_DEBUG(("NAF ID ="));

    GBA_TRACE_DEBUG(*iNAFID);

    GBA_TRACE_DEBUG(("UICC label is:"));

    GBA_TRACE_DEBUG(aUICC_LABEL);

    // Get IMPI   

    TPtr8 ptrIdentity = iIdentity->Des();

    //Clean the buffer and Set Length to 0

    ptrIdentity.Zero();

    //get the IMPI from smart card

    iSmartCardInterface->QueryIdentityL(ptrIdentity);

    GBA_TRACE_DEBUG(("IMPI is:"));

    GBA_TRACE_DEBUG( *iIdentity );

    // Get GBA_U availability 

    // EFalse means the call is not from gba client directly.

    iGBAUAvailable = CheckGBAUAvailabilityL( EFalse );

    if ( iGBAUAvailable )

        {

        GBA_TRACE_DEBUG(("GBA-U is available"));    

        }

    else

        {

        GBA_TRACE_DEBUG(("GBA-U is not available"));

        }   

    // Load Credentails from store.

    // First compare the IMPI and key lifetime

    // If IMPI is different or key expires, then return EFalse to 

    // start a new bootstrapping.

    // If IMPI & key lifetime checking both ok,

    // GBA_U will load B-TID and key lifetime and ask smart card to 

    // calculate the Ks_NAF

    // GBA_ME will load Ks, Rand, B-TId and key lifetime and calculate it

    // by ourselves.

    // The GBA run type is also taken from cached store

    if( !(aFlags & EGBAForce) && LoadCredentialsL() ) 

        {

        GBA_TRACE_DEBUG(("Still ok ???"));

        iStatus = KRequestPending;

        SetActive();

        iBSState = EBusy;

        TRequestStatus* callerStatus = &iStatus;

        User::RequestComplete(callerStatus, KErrNone);

        return;

        }

    // check if the BSF URL was overriden

    TBuf8<KMaxURLLength> BsfUrl;

    if ( aBSFAddress.Length() == 0 )

        {

        GBA_TRACE_DEBUG(("No preset BSF URL, calcuate from IMPI"));

        iSmartCardInterface->QueryHomeNetworkDnL(BsfUrl);

        }

    else

        {

        if ( iSmartCardInterface->InterfaceIs2G() )

            { 

            BsfUrl.Copy( KHTTPSTag );

            }

        else

            {

            BsfUrl.Copy( KHTTPTag ); 

            }    

       BsfUrl.Append( aBSFAddress );

       }

    GBA_TRACE_DEBUG(("The bsf url is:"));

    GBA_TRACE_DEBUG(BsfUrl);

    // dataretriever makes the actual http connection to the bsf

    // when it completes values can be retrieved 

    TUriParser8 uriparser1;

    User::LeaveIfError( uriparser1.Parse(BsfUrl) );

    iStatus = KRequestPending;

    SetActive(); // event should come from bootstrapper 

    iBSState = EBusy;

    //set reaml as FQDN of bsf

    iDataRetriever->MakeRequestL( &iStatus, *iIdentity, uriparser1.Extract( EUriHost ), BsfUrl, aNAFURL, aIAPID );

    GBA_TRACE_END();

    }

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

// C3GPPBootstrap::GBAUAvailabilityL()

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

//

TBool C3GPPBootstrap::GBAUAvailabilityL()

    {

    //the call is from gba client directly

    return CheckGBAUAvailabilityL( ETrue );

    }

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

// C3GPPBootstrap::GetState()

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

//

TInt C3GPPBootstrap::GetState() const 

    {   

    return iBSState;  

    };    

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

// C3GPPBootstrap::CompleteBootStrappingL()

// This is the callback function called by datareceiver

// when B-TID and key lifetime is received from BSF

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

//

void C3GPPBootstrap::CompleteBootStrappingL( TInt aError )

    {

    // check that we have handler to receive data  

    GBA_TRACE_DEBUG(("C3GPPBootstrapImpl::CompleteBootStrappingL"));

    // Check if triplet auth failed.

    if ( aError != KErrNone ) 

        {

        GBA_TRACE_DEBUG(("Bootstrap failed"));

        return;

        }

    HBufC8* rspbody = iDataRetriever->QueryResponseValueL();

    if (!rspbody)

        {

        GBA_TRACE_DEBUG(("Error no response body"));

        User::LeaveIfError( KErrGeneral );

        }

    CleanupStack::PushL( rspbody );

    GBA_TRACE_DEBUG(("response body is received. Loaded response:"));

    GBA_TRACE_DEBUG(*rspbody);

    // make sure it contains a B-TID

    TInt p = rspbody->FindC(KBTIDFlag);