/*

* 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:  Session for the Scard server, to a single client-side session

*

*/

// INCLUDE FILES

#include    "ScardBase.h"

#include    "ScardReader.h"

#include    "ScardClsv.h"

#include    "ScardNotifyRegistry.h"

#include    "ScardSession.h"

#include    "ScardServer.h"

#include    "ScardAccessControl.h"

#include    "WimTrace.h"

#ifdef _DEBUG // for logging

#include    "ScardLogs.h"

#include    <flogger.h> 

#endif

// LOCAL CONSTANTS AND MACROS

const TInt KResponseLengthCloseChannel = 0;

const TInt KResponseLengthOpenChannel  = 1;

const TInt KCommandLengthCloseChannel  = 4;

const TInt KCommandLengthOpenChannel   = 6;

// Assert that the channel has been opened for this session, and if not, leave

#define __ASSERT_CHANNEL_OPEN( a ) TRAPD( channelClosed,\

                    iAccessCtrl->ValidateChannelL( ( a ), iSessionID ) );\

                    if ( channelClosed )\

                        {\

                        aMessage.Complete( KScServerErrIllegalChannel );\

                        return;\

                        }

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

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

// CScardSession::CScardSession

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CScardSession::CScardSession()

    : CSession2()

    {

    _WIMTRACE(_L("WIM|Scard|CScardSession::CScardSession|Begin"));

    }

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

// CScardSession::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CScardSession::ConstructL( CScardServer* aServer )

    {

    _WIMTRACE(_L("WIM|Scard|CScardSession::ConstructL|Begin"));

    iServer         = aServer;

    iNotifyRegistry = iServer->NotifyRegistry();

    }

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

// CScardSession::NewL

// Two-phased constructor.

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

//

CScardSession* CScardSession::NewL( CScardServer* aServer )

    {

    _WIMTRACE(_L("WIM|Scard|CScardSession::NewL|Begin"));

    CScardSession* self = new( ELeave ) CScardSession;

    CleanupStack::PushL( self );

    self->ConstructL( aServer );

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CScardSession::~CScardSession()

    {

    DeleteBuffers();

    }

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

// CScardSession::ServiceL

// Handle the client message

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

//

void CScardSession::ServiceL( const TMessageHandle& aMessageHandle )

    {

    _WIMTRACE(_L("WIM|Scard|CScardSession::ServiceL|Begin"));

    ServiceL( aMessageHandle.iMessage );

    }

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

// CScardSession::CloseSession

// Clean up the reader event listeners

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

//

void CScardSession::CloseSession( const RMessage2& aMessage )

    {

    _WIMTRACE(_L("WIM|Scard|CScardSession::CloseSession|Begin"));

    if ( iAccessCtrl && iAccessCtrl->IsAttached( this ) )

        {

        iAccessCtrl->DetachSessionFromReader( iSessionID );

        }

    RThread client;

    aMessage.Client( client );

    iNotifyRegistry->RemoveReaderEventListeners( client );

    }

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

// CScardSession::AsynchronousServiceComplete

// An asynchronous service has been completed by the reader.

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

//

void CScardSession::AsynchronousServiceComplete(

    const TMessageHandle& aMessageHandle, 

    const TInt aErrorCode )

    {

    _WIMTRACE(_L("WIM|Scard|CScardSession::AsynchronousServiceComplete|Begin"));

    const RMessage2& aMessage = aMessageHandle.iMessage;

    //  In all cases, if the operation has encountered a problem, ignore 

    //  results and just complain to the client that something went wrong.

    if ( aErrorCode != KErrNone )

        {

#ifdef _DEBUG

         RFileLogger::WriteFormat( KScardLogDir, KScardLogFileName, 

            EFileLoggingModeAppend, 

            _L( "CScardSession::AsynchronousServiceComplete ERROR: %d.\n" ),

            aErrorCode );

#endif

        DeleteBuffers();

        aMessage.Complete( aErrorCode );

        return;

        }

    //  Now, see what got serviced

    _WIMTRACE2(_L("WIM|Scard|CScardSession::AsynchronousServiceComplete|Event=%d"), aMessage.Function());

    switch ( aMessage.Function() )

        {

        case EScardServerTransmitToCard:

            {

#ifdef _DEBUG

             RFileLogger::Write( KScardLogDir, KScardLogFileName, 

                EFileLoggingModeAppend, 

                _L( "Transmit to card completed.\n" ) );

#endif

            //  Write response to client and cleanup

            WriteToClient( aMessage, *iResponse, 1 );

            DeleteBuffers();

            aMessage.Complete( KErrNone );

            break;

            }

        case EScardServerGetCapabilities:

            {

#ifdef _DEBUG

             RFileLogger::Write( KScardLogDir, KScardLogFileName, 

                EFileLoggingModeAppend, 

                _L( "Get capabilities completed.\n" ) );

#endif

            //  Write response to client and cleanup

            WriteToClient( aMessage, *iResponse, 2 );

            DeleteBuffers();

            aMessage.Complete( KErrNone );

            break;

            }

        case EScardServerManageChannel:

            {

#ifdef _DEBUG

             RFileLogger::Write( KScardLogDir, KScardLogFileName, 

                EFileLoggingModeAppend, 

                _L( "Manage channel completed.\n" ) );

#endif

            //  Which type of channel management got serviced?

            switch ( aMessage.Int0() )

                {

                case EOpenAnyChannel:

                    {

                    //  Was there a proper response 

                    //  (aka. the command was successful)

                    if ( iResponse->Length() == KOpenChannelResponseLength )

                        {

                        //  Add this session to the newly opened channel

                        TBool ok( EFalse );

                        TRAPD( mem, ok = iAccessCtrl->AddSessionToChannelL( 

                            (*iResponse)[0], iSessionID ) ); 

                        __ASSERT_MEMORY( mem );

                        if ( !ok )

                            {

                            aMessage.Complete( KScErrNotSupported );

                            return;

                            }

                        }

                    //  Then write the card's response back to the client 

                    //  and cleanup

                    WriteToClient( aMessage, *iResponse, 1 );

                    DeleteBuffers();                    

                    aMessage.Complete( KErrNone );

                    break;

                    }

                case ECloseChannel:

                    {

                    //  Channel closed, OK

                    aMessage.Complete( KErrNone );

                    DeleteBuffers();

                    break;

                    }

                default:

                    {

                    break;

                    }

                }

            return;

            }

        default:

            {

            User::Panic( _L( "Message Stack Corrupted" ), 

                KScServerPanicInternalError );

            break;

            }

        }

    }

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

// CScardSession::ServiceL

// Message handler for the session.

// Dispatches requests to the appropriate handler

// Trap harness for dispatcher

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

//

void CScardSession::ServiceL( const RMessage2& aMessage )

    {

    _WIMTRACE2(_L("WIM|Scard|CScardSession::ServiceL|Begin|Event=%d"), aMessage.Function());

    //  Divide the operation to the handler functions

    switch ( aMessage.Function() )

        {

        //  These functions are synchronous, and don't use message stack,

        //  so we can complete the messages here.

        case EScardServerNotifyChange:

            {

            iNotifyRegistry->AddReaderEventListenerL( aMessage );

            // Does not complete message because it is completed when card

            // event occurs

            break;

            }

        case EScardServerCancelNotifyChange:

            {

            iNotifyRegistry->RemoveReaderEventListener( aMessage );

            aMessage.Complete( KErrNone );

            break;

            }

        case EScardServerCloseSession:

            {

            CloseSession( aMessage );

            aMessage.Complete( KErrNone );

            break;

            }

        case EScardServerDisconnectFromReader:

            {

            DisconnectFromReader();

            aMessage.Complete( KErrNone );

            break;

            }

        case EScardServerCancelTransmit:

            {

            CancelTransmitL();

            aMessage.Complete( KErrNone );

            break;

            }

        //  These functions are asynchronous, and (may) put their messages

        //  in the message stack, so they do completion internally.

        case EScardServerConnectToReader:

            {

            TInt desLen = aMessage.GetDesMaxLength( 1 );

            _WIMTRACE2(_L( "WIM|Scard|EScardServerConnectToReader desLen %d" ), desLen );

            if ( desLen <= 0 )

               {

               _WIMTRACE(_L(" WIM|Scard|EScardServerConnectToReader Descriptor is bad"));

               aMessage.Panic( _L( "ScardServer" ), KErrBadDescriptor );

               break;

               }

            ConnectToReaderL( aMessage );

            break;

            }

         case EScardServerGetATR:

            {

            aMessage.Complete( KErrNotSupported );

            break;

            }

        case EScardServerTransmitToCard:

            {

            TransmitToCard( aMessage );

            break;

            }

        case EScardServerGetCapabilities:

            {

            GetCapabilities( aMessage );

            break;

            }

        case EScardServerManageChannel:

            {

            ManageChannel( aMessage );

            break;

            }

        //  A corrupt request

        default:

            aMessage.Panic( _L( "ScardServer" ), KScServerPanicBadRequest );

            break;

        }

    }

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

// CScardSession::ConnectToReaderL

// Ask Access Control to add this session to registry, and update session ID

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

//

void CScardSession::ConnectToReaderL( const RMessage2& aMessage )

    {

    _WIMTRACE(_L("WIM|Scard|CScardSession::ConnectToReaderL|Begin"));

#ifdef _DEBUG

    RFileLogger::WriteFormat( KScardLogDir, KScardLogFileName, 

        EFileLoggingModeAppend,

        _L( "CScardSession::ConnectToReaderL entered.\n" ) );

#endif

    //  If already connected, what more could the client want??

    if ( iConnectedToReader )

        {

#ifdef _DEBUG

        RFileLogger::WriteFormat( KScardLogDir, KScardLogFileName, 

         EFileLoggingModeAppend, 

         _L( "CScardSession::ConnectToReaderL FAILED: already connected.\n" ) );

#endif

        aMessage.Complete( KScErrAlreadyExists );

        return;

        }

    // Store client thread from message to member to be used in PanicClient().

    aMessage.Client( iClient );

    // If not, get on with it...            

    iServer->ConnectToReaderL( this, aMessage );

    }

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

// CScardSession::DisconnectFromReader

// Ask Access Control to detach this session from the reader.

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

//

void CScardSession::DisconnectFromReader()

    {

    _WIMTRACE(_L("WIM|Scard|CScardSession::DisconnectFromReader|Begin"));

    //  If connected at all, disconnect

    if ( iConnectedToReader )

        {

        iAccessCtrl->DetachSessionFromReader( iSessionID );

        iConnectedToReader = EFalse;

        iAccessCtrl = NULL;

        }

    }

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

// CScardSession::GetCapabilities

// Get capabilities of the card

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

//

void CScardSession::GetCapabilities( const RMessage2& aMessage )

    {

    _WIMTRACE(_L("WIM|Scard|CScardSession::GetCapabilities|Begin"));

    if ( !iConnectedToReader )

        {

        aMessage.Panic( _L( "Reader not contacted" ), 

            KScPanicNoResourceConnection );

        return;

        }

    const TInt8 channel( 0 );

    if ( iAccessCtrl->ReaderIsReady( iSessionID, channel ) )

        {

        TRequestStatus& status =

            iAccessCtrl->InitiateCommunication( iSessionID, aMessage,

                reinterpret_cast< TInt32>( aMessage.Ptr3() ), channel );

        __ASSERT_MEMORY( status.Int() );

        TInt32 commandCode( 0 );

        commandCode = aMessage.Int1();

        commandCode |= ( aMessage.Int0() << 8 ) & 0xff00;

        //  Get the response buffer

        TInt error = AllocateResponse( aMessage, 2 );

        if ( error )

            {

            aMessage.Complete( error );

            return;

            }

        TInt32 timeout = reinterpret_cast< TInt32>( aMessage.Ptr3() );

        //  ...do the control command

        iReader->GetCapabilities( status, commandCode, *iResponse, timeout );

        }

    //  The reader was busy, queue

    else

        {

#ifdef _DEBUG

        RFileLogger::Write( KScardLogDir, KScardLogFileName, 

        EFileLoggingModeAppend, 

        _L("CScardSession::GetCapabilities()-reader busy, message queued.\n") );

#endif

        iAccessCtrl->QueueExecution( aMessage, iSessionID,

            reinterpret_cast< TInt32 >( aMessage.Ptr3() ), channel );

        }

    }

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

// CScardSession::TransmitToCard

// Transmit data to the card

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

//

void CScardSession::TransmitToCard( const RMessage2& aMessage )

    {

    _WIMTRACE(_L("WIM|Scard|CScardSession::TransmitToCard|Begin"));

    if ( !iConnectedToReader )

        {

        aMessage.Panic( _L( "Reader not contacted" ), 

            KScPanicNoResourceConnection );

        return;

        }

    // check if this client has the access rights for the reader

    // and reader is ready

    const TInt8 channel( static_cast< TInt8>( aMessage.Int3() ) );

    __ASSERT_CHANNEL_OPEN( channel );

    if ( iAccessCtrl->ReaderIsReady( iSessionID, channel ) )

        {

        //  Read the command APDU from the client

        TInt error = ReadFromClient( aMessage, iCommandBuffer, iCommand, 0 );

        if ( error )

            {

#ifdef _DEBUG

    RFileLogger::WriteFormat( KScardLogDir, KScardLogFileName, 

        EFileLoggingModeAppend, 

        _L("CScardSession::TransmitToCard()-Cmd APDU couldn't be read from\

        client. Error: %d.\n"), error );

#endif

            return;

            }

        //  If the channel number is not the same one as asked for

        //  in the parameter 3 of the message, adjust the command...

        if ( ( (*iCommand)[KCLA] & 0x0f) != channel )

            {

#ifdef _DEBUG

            RFileLogger::WriteFormat( KScardLogDir, KScardLogFileName, 

            EFileLoggingModeAppend, 

            _L("CScardSession::TransmitToCard() -- Channel changed from %d\

             to: %d.\n"), (*iCommand)[KCLA] & 0x0f, channel & 0x0f );

#endif

            (*iCommand)[KCLA] &= 0xf0;

            (*iCommand)[KCLA] |= channel;

            }

        //  No manage channel apdu's are allowed. 

        //  Use CScardComm::ManageChannel() instead.

        if ( (*iCommand)[KINS] == KManageChannel )

            {

#ifdef _DEBUG

            RFileLogger::Write( KScardLogDir, KScardLogFileName, 

                EFileLoggingModeAppend, 

                _L( "CScardSession::TransmitToCard() -- Error! Manage channel\

                APDU.\n" ) );

#endif

            delete iCommand;

            iCommand = NULL;

            aMessage.Complete( KScServerErrIllegalOperation );

            return;

            }

        //  Alloc response 

        error = AllocateResponse( aMessage, 1 );

        if ( error )

            {

#ifdef _DEBUG

            RFileLogger::Write( KScardLogDir, KScardLogFileName, 

                EFileLoggingModeAppend, 

                _L( "CScardSession::TransmitToCard() -- Could not allocate\

                response.\n" ) );

#endif

            return;

            }

        //  Transfer APDU

        TRequestStatus& sr =

            iAccessCtrl->InitiateCommunication( iSessionID, aMessage,

                reinterpret_cast< TInt32>( aMessage.Ptr2() ), channel );

        __ASSERT_MEMORY( sr.Int() );

        const TInt32 timeout = static_cast< TInt32>( aMessage.Int2() );

#ifdef _DEBUG

        RFileLogger::HexDump( KScardLogDir, KScardLogFileName, 

            EFileLoggingModeAppend, 

            _S( "CScardSession::TransmitToCard() command APDU:\n" ), 0,

            iCommand->Ptr(), iCommand->Length() );

#endif

        iReader->TransmitToCard( sr, *iCommand, *iResponse, timeout );

        }

    //  The reader was busy, queue

    else