/*

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

*

*/

#ifndef CSCARDSESSION_H

#define CSCARDSESSION_H

//  INCLUDES

#include "ScardDefs.h"

#include <f32file.h>    // f32file header needed for loading dlls

//  CONSTANTS  

const TInt KOpenChannelResponseLength = 3;

const TInt KApduHeaderLength          = 4;

const TInt KCLA    = 0;    //  class byte

const TInt KINS    = 1;    //  instruction code

const TInt KP1     = 2;    //  control parameter 1

const TInt KP2     = 3;    //  control parameter 2

const TInt KLcHigh = 4;    //  command length high byte

const TInt KLcLow  = 5;    //  command length low byte

const TInt8 KNoChannel     = 0;

const TInt8 KChannelByCard = 1;

const TInt8 KChannelByCID  = 2;

//  FORWARD DECLARATIONS

class CScardAccessControl;

class CScardServer;

class MScardReader;

class CScardNotifyRegistry;

// CLASS DECLARATION

/**

*  Session for the Scard server, to a single client-side session

*

*  @lib Scard.lib

*  @since Series60 2.1

*/

class CScardSession : public CSession2

    {

    public:  // Constructors and destructor

        /**

        * Two-phased constructor.

        * @param aServer Pointer to ScardServer object

        */

        static CScardSession* NewL( CScardServer* aServer );  

        /**

        * Destructor.

        */

        virtual ~CScardSession();

    public: // New functions

        /**

        * Clean up the reader event listeners.

        * @param aMessage Client message

        * @return void

        */

        void CloseSession( const RMessage2& aMessage );

        /**

        * Wrapper for the actual ServiceL() (this needed only because of

        * connector class)

        * @param aMessageHandle Handle to client message

        * @return void

        */

        virtual void ServiceL( const TMessageHandle& aMessageHandle );

        /**

        * Asynchronous operation completed

        * @param aMessageHandle Handle to client message

        * @param aErrorCode Error code

        * @return void

        */

        virtual void AsynchronousServiceComplete( 

            const TMessageHandle& aMessageHandle,

            const TInt aErrorCode );

        /**

        * This is here only for derivative class CScardConnector

        * It implements and needs this function

        * @param aServiceStatus Service status

        * @param aATR ATR bytes

        * @param aReaderID Reader ID from which event comes

        * @return void

        */

        virtual void CardEvent( const TScardServiceStatus aServiceStatus,

                                const TScardATR& aATR,

                                const TReaderID& aReaderID );

        /**

        * A reader has finally been contacted.

        * @param aReaderID Reader ID

        * @param aMessage Client essage

        * @param aErrorCode Error code

        * @return void

        */

        void ConnectionDone( const TReaderID& aReaderID, 

                             const RMessage2& aMessage,

                             const TInt aErrorCode );

        /**

        * Detach this session from the reader

        * @return void

        */

        void DisconnectFromReader();

    protected:

        /**

        * C++ default constructor.

        */

        CScardSession();

    protected:  // Functions from base classes

        /**

        * From CSharableSession. Service a request message

        * @param aMessage Message

        * @return void

        */

        void ServiceL( const RMessage2& aMessage );

    private:

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL( CScardServer* aServer );

        /**

        * Connect to reader

        * @param aMessage Message

        * @return void

        */

        void ConnectToReaderL( const RMessage2& aMessage );

        /**

        * Get reader/card capabilities

        * @param aMessage Message

        * @return void

        */

        void GetCapabilities( const RMessage2& aMessage );

        /**

        * Send data to card

        * @param aMessage Message

        * @return void

        */

        void TransmitToCard( const RMessage2& aMessage );

        /**

        * Cancel everything

        * @return void

        */

        void CancelTransmitL();

        /**

        * Open/close channel, get channel status

        * @param aMessage Message

        * @return void

        */

        void ManageChannel( const RMessage2& aMessage );

        /**

        * Helper function for ManageChannel. Create and send a 

        * manage channel apdu according to parameters

        * @param aMessage Message

        * @param aCommand Command

        * @param aP2 Control parameter 2

        * @param aCommandLength Command APDU length

        * @param aResponseLength Response APDU length

        * @param aTimeOut Timeout

        * @param aChannel Channel used to transmit APDU

        * @return void

        */

        void DoCommandAndTransmit( const RMessage2& aMessage,

                                   const TUint8 aCommand, 

                                   const TUint8 aP2,

                                   const TInt8 aCommandLength, 

                                   const TUint8 aResponseLength,

                                   const TInt32 aTimeOut,

                                   const TUint8 aChannel );

        /**

        * Helper function for ManageChannel. Create and send a 

        * manage channel apdu according to parameters

        * @param aMessage Message

        * @param aCommand Command

        * @param aP2 Control parameter 2

        * @param aCommandLength Command APDU length

        * @param aResponseLength Response APDU length

        * @param aTimeOut Timeout

        * @param aChannel Channel used to transmit APDU

        * @return void

        */

        void DoCommandAndTransmitL( const RMessage2& aMessage,

                                   const TUint8 aCommand, 

                                   const TUint8 aP2,

                                   const TInt8 aCommandLength, 

                                   const TUint8 aResponseLength,

                                   const TInt32 aTimeOut,

                                   const TUint8 aChannel );

        /**

        * Write descriptors to client thread. 8 bit version.

        * @param aMessage Message

        * @param aResponseBuffer Response Buffer

        * @param aPtrIndex Pointer index

        * @return void

        */

        void WriteToClient( const RMessage2& aMessage,

                            const TDesC8& aResponseBuffer,

                            const TInt aPtrIndex );

        /**

        * Read descriptors from client thread. 8 bit version.

        * @param aMessage Message

        * @param aBuffer Buffer for data

        * @param aPointer Pointer to buffer data

        * @param aPtrIndex Pointer index

        * @return Symbian or Scard error code

        */

        TInt ReadFromClient( const RMessage2& aMessage,

                                   HBufC8*& aBuffer, 

                                   TPtr8*& aPointer,

                                   const TInt aPtrIndex );

        /**

        * Write descriptors to client thread. 16 bit version.

        * @param aMessage Message

        * @param aResponseBuffer

        * @param aPtrIndex

        * @return void

        */

        void WriteToClient( const RMessage2& aMessage,

                            const TDesC16& aResponseBuffer,

                            const TInt aPtrIndex );

        /**

        * Allocate space for the internal response buffer. The lenght of the

        * necessary space is deduced from the message.

        * @param aMessage Message

        * @param aPtrIndex Pointer index of message.

        * @return TInt

        */

        TInt AllocateResponse( const RMessage2& aMessage,

                                     const TInt aPtrIndex );

        /**

        * Allocate space for the internal response buffer. The lenght of the

        * necessary space is deduced from the message.

        * @param aDesLen Length of buffer to be allocated.

        * @return void

        */

        void AllocateResponseL( TInt aDesLen );

        /**

        * Delete all internal buffers

        * @return void

        */

        void DeleteBuffers();

        /**

        * Return pointer to wanted slot of client message 

        * @param aMessage Message

        * @param aPtrIndex Pointer index of message.

        * @return Pointer to message slot

        */

        TAny* MessagePointer( const RMessage2& aMessage, const TInt aPtrIndex );

        /**

        * Return length of descriptor in client message 

        * @param aMessage Message

        * @param aPtrIndex Pointer index of message.

        * @param aMaxLength ETrue: get maxlength of descriptor

        *                   EFalse: get length of descriptor

        * @return Length of descriptor (MaxLength or just Length)

        */

        TInt DesLength( const RMessage2& aMessage,

                        const TInt aPtrIndex, 

                        const TBool aMaxLength  );

    private:    // Data

        // Pointer to owning server. Not owned.

        CScardServer*         iServer; 

        //  Pointer to notify registry. Owned by server

        CScardNotifyRegistry* iNotifyRegistry;

        //  Reader handler associated with this session

        MScardReader*         iReader;

        //  Reader access controller for this session's reader

        CScardAccessControl*  iAccessCtrl; 

        //  This is, obviously, the session's ID number

        TInt                  iSessionID;

        //  Pointers to command and response parameters. Owned.

        TPtr8*                iResponse;

        TPtr8*                iCommand;

        //  Heap pointers containing the buffers. Owned.

        HBufC8*               iResponseBuffer;

        HBufC8*               iCommandBuffer;

        // Flag to tell if connected to readed

        TBool                 iConnectedToReader;

        // Client thread

        RThread iClient;

    };

#endif      // CSCARDSESSION_H

// End of File