/*

* Copyright (c) 2003 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:  This file contain the implementation of CWimCallBack class.

*

*/

// INCLUDE FILES

#include    "WimCallbackImpl.h"

#include    "WimSession.h"

#include    "WimServer.h"

#include    "WimResponse.h"

#include    "WimApduImpl.h"

#include    "WimSimFileHandler.h"

#include    "WimUtilityFuncs.h"

#include    "WimConsts.h"

#include    "WimTrace.h"

#include    <x509cert.h>

// These variables are static because static function calls from WIMI

static CWimApdu* gApdu = NULL;

static CWimSimFileHandler* gSimFileHandler = NULL;

static TRequestStatus* gStatus = NULL;

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

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

// CWimCallBack::InitOkResp

// Respond to InitOK operation

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

//

void CWimCallBack::InitOkResp( WIMI_STAT aStatus )

    {

    _WIMTRACE2(_L("WIM|WIMServer|CWimCallBack::InitOkResp|Begin aStatus=%d"), aStatus);

    CWimServer::iWimStatus = CWimUtilityFuncs::MapWIMError( aStatus );   

    if ( aStatus == WIMI_Ok )

        {

        CWimServer::SetWimInitialized( ETrue, KErrNone ); // WIM has initialized

        _WIMTRACE(_L("WIM|WIMServer|CWimCallBack::InitOkResp|Initialized=True"));

        }

    else

        {

        if( aStatus == WIMI_ERR_UserCancelled )

	        {

	        CWimServer::iWimStatus = KErrCancel;

	        CWimServer::SetWimInitialized( EFalse, KErrCancel );

            WIMI_CloseDownReq();

	        }

        else

	        {

	        CWimServer::SetWimInitialized( EFalse, CWimServer::iWimStatus ); // WIM has not initialized	

            WIMI_CloseDownReq();

	        }

        _WIMTRACE(_L("WIM|WIMServer|CWimCallBack::InitOkResp|Initialized=False"));

        }

    }

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

// CWimCallBack::CloseDownResp

// Respond to CloseDown operation

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

//

void CWimCallBack::CloseDownResp( WIMI_STAT aStatus )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::CloseDownResp | Begin"));

    CWimServer::iWimStatus = CWimUtilityFuncs::MapWIMError( aStatus );

    CWimServer::SetWimInitialized( EFalse, CWimServer::iWimStatus ); // WIM has not initialized

    delete gSimFileHandler; // Close connection to CustomAPI

    gSimFileHandler = NULL;

    }

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

// CWimCallBack::CompleteResponse

// Complete response

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

//

void CWimCallBack::CompleteResponse(

    WIMI_TransactId_t aTrId,

    WIMI_STAT aStatus )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::CompleteResponse | Begin"));

    TWimReqTrId* trIdType = ( TWimReqTrId* )aTrId;

    CWimResponse* pTrId = ( CWimResponse* )( trIdType->iReqTrId );

    pTrId->iStatus = aStatus;

    pTrId->CompleteMsgAndDelete();

    delete trIdType;

    }

/* ------------ Digital signature ------------------------------------------- */

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

// CWimCallBack::SetSignTextRequestStatus

// Set RequestStatus of SignTextHandler

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

//

void CWimCallBack::SetSignTextRequestStatus( TRequestStatus* aStatus )

    {

    gStatus = aStatus;

    }

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

// CWimCallBack::SignResp

// Respond to the digital signature operation

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

//

void CWimCallBack::SignResp(

    WIMI_TransactId_t aTrId, 

    WIMI_STAT aStatus,

    TUint8 aSignLen,

    TUint8* aSign )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::SignResp | Begin"));

    TWimReqTrId* trIdType = ( TWimReqTrId* )aTrId;

    CWimResponse* trId = ( CWimResponse* )( trIdType->iReqTrId );

    trId->iStatus = aStatus;

    // In case PIN was incorrect try ask PIN again, don't complete message

    // If PIN is blocked show note and don't complete message yet.

    if ( aStatus != WIMI_ERR_BadPIN && aStatus != WIMI_ERR_PINBlocked && aStatus != WIMI_ERR_CardIOError )

        {

        if ( trId->iStatus == WIMI_Ok )

            {

            TRAP( trId->iError, SignRespL( trId, aSignLen, aSign ) );

            }

        WIMI_Ref_pt pWimRefTemp = NULL;

        pWimRefTemp = WIMI_GetWIMRef( 0 );

        if ( pWimRefTemp )  // Close the WIM

            {

            WIMI_CloseWIM( pWimRefTemp );

            free_WIMI_Ref_t( pWimRefTemp );

            }

        trId->CompleteMsgAndDelete(); 

        delete trIdType;

        }

    // Complete SignTextHandler status

    if ( gStatus )

        {

        User::RequestComplete( gStatus, aStatus );

        }

    else // SignTextHandler not active, complete message with error if not done

        {

        if ( aStatus == WIMI_ERR_BadPIN || aStatus == WIMI_ERR_PINBlocked || aStatus == WIMI_ERR_CardIOError )

            {

            trId->CompleteMsgAndDelete();

            delete trIdType;

            }

        }

    }

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

// CWimCallBack::SignRespL

// Write signed text to client memory. Signature allocated in WIMI is freed 

// also by WIMI.

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

//

void CWimCallBack::SignRespL(

    CWimResponse* aTrId,

    TUint8 aSignLen,

    TUint8* aSign )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::SignRespL | Begin"));

    RMessage2& message = aTrId->iMessage;

    TPtr8 signaturePtr( aSign, aSignLen, aSignLen );

    message.WriteL( 3, signaturePtr );

    }

/* ------------ Certificate management -------------------------------------- */

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

// CWimCallBack::CertificateResp

// Respond to Certificate fetch operation

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

//

void CWimCallBack::CertificateResp( 

    WIMI_TransactId_t aTrId,

    WIMI_STAT aStatus,

    WIMI_Ref_t* aCertRef,

    TUint16 aCertlen,

    TUint8* aCert )

    {

    if ( aTrId )

    	{

        _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::CertificateResp | Begin"));

        TWimReqTrId* trIdType = ( TWimReqTrId* )aTrId;

        CWimResponse* pTrId = ( CWimResponse* )( trIdType->iReqTrId );

        pTrId->iStatus = aStatus;

        if ( pTrId->iStatus == WIMI_Ok)

            {

            TRAP( pTrId->iError,

                CertificateRespL( pTrId, aStatus, aCertRef, aCertlen, aCert ) );

            }

        pTrId->CompleteMsgAndDelete(); 

        delete trIdType;

    	}

    else

    	{

    	_WIMTRACE(_L("WIM | WIMServer | CWimCallBack::CertificateResp | certhandler starts this"));

    	if ( gStatus )

	        {

	        TPtrC8 certPtr( aCert, aCertlen );

	        CX509Certificate* cert = NULL;

	        TRAPD( err, cert =  CX509Certificate::NewL( certPtr ) );

	        _WIMTRACE2(_L("WIM | WIMServer | CWimCallBack::CertificateResp | x509 err %d"), err );

	        User::RequestComplete( gStatus, err );

	        delete cert;

	        cert = NULL;

	        }

    	}

    }

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

// CWimCallBack::CertificateRespL

// Respond to the certificate fetch operation

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

//

void CWimCallBack::CertificateRespL(

    CWimResponse* aTrId,

    WIMI_STAT /*aStatus*/,

    WIMI_Ref_t* /*aWimiRef*/,

    TUint16 aCertLen,

    TUint8* aCert )

    {

    _WIMTRACE(_L("WIM | WIMServer | CertificateRespL | Begin"));

    _WIMTRACE2(_L("WIM | WIMServer | The length of certificate is %d"), aCertLen);

    RMessage2& message = aTrId->iMessage;

    if ( aTrId->iStatus == WIMI_Ok )

        {

        TPtr8 certPtr( aCert, aCertLen, aCertLen );

        message.WriteL( 2, certPtr );

        }

    }

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

// CWimCallBack::CertificateDeleteResp

// Respond to the certificate delete operation

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

//

void CWimCallBack::CertificateDeleteResp( 

    WIMI_TransactId_t aTrId,

    WIMI_STAT aStatus )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::CertificateDeleteResp | Begin"));

    CompleteResponse( aTrId, aStatus );

    }

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

// CWimCallBack::CertificateStoreResp

// Respond to the certificate store operation

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

//

void CWimCallBack::CertificateStoreResp(

    WIMI_TransactId_t aTrId,

    WIMI_STAT aStatus,

    WIMI_Ref_t* /*aCertRef*/ )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::CertificateStoreResp | Begin"));

    TWimReqTrId* trIdType = ( TWimReqTrId* )aTrId;

    CWimResponse* pTrId = (CWimResponse*)( trIdType->iReqTrId );

    pTrId->iStatus = aStatus;

    pTrId->CompleteMsgAndDelete();

    delete trIdType;

    }

/* ------------ PIN management ---------------------------------------------- */

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

// CWimCallBack::VerifyPINResp

// Respond to Verify PIN operation

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

//

void CWimCallBack::VerifyPINResp( WIMI_TransactId_t aTrId, WIMI_STAT aStatus )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::VerifyPINResp | Begin"));

    if( aTrId )

	    {

	    TWimReqTrId* trIdType = ( TWimReqTrId* )aTrId;

	    CWimResponse* trId = ( CWimResponse* )( trIdType->iReqTrId );

	    trId->iStatus = aStatus;

	    // In case PIN was incorrect try ask PIN again, don't complete message

	    // If PIN is blocked show note and don't complete message yet.

        if ( aStatus != WIMI_ERR_BadPIN && aStatus != WIMI_ERR_PINBlocked && aStatus != WIMI_ERR_CardIOError )

	        { 	

	        trId->CompleteMsgAndDelete(); 

	        delete trIdType;

	        }

	    if ( gStatus )

	        {

	        User::RequestComplete( gStatus, aStatus );

	        }

	    else // SignTextHandler not active, complete message with error if not done

	        {

	        if ( aStatus == WIMI_ERR_BadPIN || aStatus == WIMI_ERR_PINBlocked || aStatus == WIMI_ERR_CardIOError )

	            {

	            trId->CompleteMsgAndDelete();

	            delete trIdType;

	            }

	        }

	    }

    else

        {

    	if ( gStatus )

	        {

	        User::RequestComplete( gStatus, CWimUtilityFuncs::MapWIMError( aStatus ) );

	        }

        }    	 	

    }

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

// CWimCallBack::ChangePINResp

// Respond to Change PIN operation

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

//

void CWimCallBack::ChangePINResp( WIMI_TransactId_t aTrId, WIMI_STAT aStatus )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::ChangePINResp | Begin"));

    TWimReqTrId* trIdType = ( TWimReqTrId* )aTrId;

    CWimResponse* trId = ( CWimResponse* )( trIdType->iReqTrId );

    trId->iStatus = aStatus;

    // In case PIN was incorrect try ask PIN again, don't complete message

    // If PIN is blocked show note and don't complete message yet.

    if ( aStatus != WIMI_ERR_BadPIN && aStatus != WIMI_ERR_PINBlocked && aStatus != WIMI_ERR_CardIOError )

        {

        if( CWimServer::Server()->WimTimer()->TimeRemaining() == 0 )

            {

            _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::ChangePINResp | TimeRemaing =0 "));

            WIMI_Ref_pt pWimRefTemp = NULL;

            pWimRefTemp = WIMI_GetWIMRef( 0 );

            if ( pWimRefTemp )  // Close the WIM

                {

                WIMI_CloseWIM( pWimRefTemp );

                free_WIMI_Ref_t( pWimRefTemp );

                }

            }    	

        trId->CompleteMsgAndDelete(); 

        delete trIdType;

        }

    // Complete SignTextHandler status

    if ( gStatus )

        {

        User::RequestComplete( gStatus, aStatus );

        }

    else // SignTextHandler not active, complete message with error if not done

        {

        if ( aStatus == WIMI_ERR_BadPIN || aStatus == WIMI_ERR_PINBlocked || aStatus == WIMI_ERR_CardIOError )

            {

            trId->CompleteMsgAndDelete();

            delete trIdType;

            }

        }

      _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::ChangePINResp | 10"));   

    }

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

// CWimCallBack::UnblockPINResp

// Respond to Unblock PIN operation

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

//

void CWimCallBack::UnblockPINResp( WIMI_TransactId_t aTrId, WIMI_STAT aStatus )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::UnblockPINResp | Begin"));

    TWimReqTrId* trIdType = ( TWimReqTrId* )aTrId;

    CWimResponse* trId = ( CWimResponse* )( trIdType->iReqTrId );

    trId->iStatus = aStatus;

    // In case PIN was incorrect try ask PIN again, don't complete message

    // If PIN is blocked show note and don't complete message yet.

    if ( aStatus != WIMI_ERR_BadPIN && aStatus != WIMI_ERR_PINBlocked && aStatus != WIMI_ERR_CardIOError )

        {

        _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::SignResp | TimeRemaing =0 "));

        WIMI_Ref_pt pWimRefTemp = NULL;

        pWimRefTemp = WIMI_GetWIMRef( 0 );

        if ( pWimRefTemp )  // Close the WIM

            {

            WIMI_CloseWIM( pWimRefTemp );

            free_WIMI_Ref_t( pWimRefTemp );

            }

        //  WIMI_InitializeReq( &CWimServer::Server()->iWimCallBack );

        trId->CompleteMsgAndDelete(); 

        delete trIdType;

        }

    // Complete SignTextHandler status

    if ( gStatus )

        {

        User::RequestComplete( gStatus, aStatus );

        }

    else // SignTextHandler not active, complete message with error if not done

        {

        if ( aStatus == WIMI_ERR_BadPIN || aStatus == WIMI_ERR_PINBlocked || aStatus == WIMI_ERR_CardIOError )

            {

            trId->CompleteMsgAndDelete();

            delete trIdType;

            }

        }

    }

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

// CWimCallBack::EnablePINResp

// Respond to Enable PIN Response

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

//

void CWimCallBack::EnablePINResp( WIMI_TransactId_t aTrId, WIMI_STAT aStatus )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::EnablePINResp | Begin"));

    TWimReqTrId* trIdType = ( TWimReqTrId* )aTrId;

    CWimResponse* trId = ( CWimResponse* )( trIdType->iReqTrId );

    trId->iStatus = aStatus;

    // In case PIN was incorrect try ask PIN again, don't complete message

    // If PIN is blocked show note and don't complete message yet.

    if ( aStatus != WIMI_ERR_BadPIN && aStatus != WIMI_ERR_PINBlocked && aStatus != WIMI_ERR_CardIOError )

        {

        if( CWimServer::Server()->WimTimer()->TimeRemaining() == 0 )

            {

            _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::SignResp | TimeRemaing =0 "));

            WIMI_Ref_pt pWimRefTemp = NULL;

            pWimRefTemp = WIMI_GetWIMRef( 0 );

            if ( pWimRefTemp )  // Close the WIM

                {

                WIMI_CloseWIM( pWimRefTemp );

                free_WIMI_Ref_t( pWimRefTemp );

                }

            }    	

        trId->CompleteMsgAndDelete(); 

        delete trIdType;

        }

    // Complete SignTextHandler status

    if ( gStatus )

        {

        User::RequestComplete( gStatus, aStatus );

        }

    else // SignTextHandler not active, complete message with error if not done

        {

        if ( aStatus == WIMI_ERR_BadPIN || aStatus == WIMI_ERR_PINBlocked || aStatus == WIMI_ERR_CardIOError )

            {

            trId->CompleteMsgAndDelete();

            delete trIdType;

            }

        }

    }

/* ------------ Hardware driver support ------------------------------------- */

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

// CWimCallBack::CardInsertedResp

// Respond to CardInserted operation

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

//

void CWimCallBack::CardInsertedResp(

    TUint8 /*aReader*/,

    WIMI_STAT /*aStatus*/,

    WIMI_Ref_t* /*aWIMRef*/ )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::CardInsertedResp | Begin"));

    }

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

// CWimCallBack::Open

// Open connection to card

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

//

TUint8 CWimCallBack::Open( TUint8 aReader )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::Open | Begin"));

    __ASSERT_ALWAYS( gApdu, User::Panic( _L( "Null pointer" ), KErrGeneral ) );

    return gApdu->Open( aReader );

    }

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

// CWimCallBack::Close

// Close connection to card

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

//

TUint8 CWimCallBack::Close( TUint8 aReader )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::Close | Begin"));

    __ASSERT_ALWAYS( gApdu, User::Panic( _L( "Null pointer" ), KErrGeneral ) );

    TUint8 ret;

    ret = gApdu->Close( aReader );

     _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::Close | 1"));

    return ret;

    }

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

// CWimCallBack::APDUReq

// APDU Request

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

//

void CWimCallBack::APDUReq( TUint8 aReader, TUint8* aApdu, TUint16 aApdulen )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCallBack::APDUReq | Begin"));