windows-server-2003/drivers/smartcrd/smclib/smcprot.c

/*++

Copyright (C) Microsoft Corporation, 1996 - 1999

Module Name:

    smcprot.c

Author:

    Klaus U. Schutz 

Environment:

    Kernel mode only.

Revision History:

    - Dec. 96:  Initial version
    - Nov. 97:  Release 1.0
    - Feb. 98:  T=1 uses now the min of IFSC, IFSD for SmartcardT1Request
                T=1 fixed number of bytes to invert for inverse convention cards
                

--*/

#ifdef SMCLIB_VXD

#define try 
#define leave goto __label
#define finally __label:

#else

#ifndef SMCLIB_CE
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <ntddk.h>
#endif // SMCLIB_CE
#endif

#include "smclib.h"
#define SMARTCARD_POOL_TAG 'bLCS'

#ifdef DEBUG_INTERFACE
BOOLEAN
DebugT1Reply(
    PSMARTCARD_EXTENSION SmartcardExtension
    );

void
DebugGetT1Request(
    PSMARTCARD_EXTENSION SmartcardExtension,
    NTSTATUS Status
    );

BOOLEAN
DebugSetT1Request(
    PSMARTCARD_EXTENSION SmartcardExtension
    );
#endif // DEBUG_INTERFACE

void
DumpData(
    const ULONG DebugLevel,
    PUCHAR Data,
    ULONG DataLen
    );

//
// Usually an io-request consists only of the SCARD_IO_REQUEST header
// followed by the data to be transmitted. To allow modification of 
// protocol data, it is possible to pass down the data to be modified.
// These data are ASN1 encoded.
//
typedef struct _IO_HEADER {
    SCARD_IO_REQUEST ScardIoRequest;
    UCHAR Asn1Data[1];      
} IO_HEADER, *PIO_HEADER;

NTSTATUS
#ifdef SMCLIB_VXD
SMCLIB_SmartcardRawRequest(
#else
SmartcardRawRequest(
#endif
    PSMARTCARD_EXTENSION SmartcardExtension
    )
    
/*++

Routine Description:

Arguments:

Return Value:

   -

--*/
{
    PSMARTCARD_REQUEST smartcardRequest = &(SmartcardExtension->SmartcardRequest);

    if ((smartcardRequest->BufferSize < smartcardRequest->BufferLength) ||
        (smartcardRequest->BufferSize - smartcardRequest->BufferLength 
         <= SmartcardExtension->IoRequest.RequestBufferLength)) {
        
        return STATUS_BUFFER_TOO_SMALL;
    }
    
    //
    // Copy request data to the buffer
    //        
    RtlCopyMemory(
        &smartcardRequest->Buffer[smartcardRequest->BufferLength],
        SmartcardExtension->IoRequest.RequestBuffer,
        SmartcardExtension->IoRequest.RequestBufferLength
        );
        
    //
    // If the card uses invers convention invert the data
    // 
    if (SmartcardExtension->CardCapabilities.InversConvention) {

        SmartcardInvertData(
            &smartcardRequest->Buffer[smartcardRequest->BufferLength],
            SmartcardExtension->IoRequest.RequestBufferLength
            );
    }

    //
    // number of bytes to send to the reader 
    //    
    smartcardRequest->BufferLength += 
        SmartcardExtension->IoRequest.RequestBufferLength;

    return STATUS_SUCCESS;
}    

NTSTATUS
#ifdef SMCLIB_VXD
SMCLIB_SmartcardRawReply(
#else
SmartcardRawReply(
#endif
    PSMARTCARD_EXTENSION SmartcardExtension
    )
    
/*++

Routine Description:

Arguments:

Return Value:

   -

--*/
{
    if (SmartcardExtension->IoRequest.ReplyBufferLength <
        SmartcardExtension->SmartcardReply.BufferLength) {
        
        return STATUS_BUFFER_TOO_SMALL;
    }
    
    //
    // Copy data to user buffer
    //
    RtlCopyMemory(
        SmartcardExtension->IoRequest.ReplyBuffer,
        SmartcardExtension->SmartcardReply.Buffer,
        SmartcardExtension->SmartcardReply.BufferLength
        );

    // 
    // Length of data to return
    //        
    *SmartcardExtension->IoRequest.Information = 
        SmartcardExtension->SmartcardReply.BufferLength;
              
    return STATUS_SUCCESS;
}   

NTSTATUS
#ifdef SMCLIB_VXD
SMCLIB_SmartcardT0Request(
#else
SmartcardT0Request(
#endif
    PSMARTCARD_EXTENSION SmartcardExtension
    )
    
/*++

Routine Description:

    Prepares the buffer SmartcardExtension->SmartcardRequest.Buffer 
    to send data to the smart card

Arguments:

    NOTE: On input SmartcardExtension->SmartcardRequest.BufferLenght indicates
          the offset where we should copy the data to. This is usually
          used by readers that needs to have some bytes as header bytes
          to send to the reader before the data bytes for the card

Return Value:

   -

--*/
{
    PSMARTCARD_REQUEST smartcardRequest = &SmartcardExtension->SmartcardRequest;
    PSCARD_IO_REQUEST scardIoRequest;
    PUCHAR ioRequestData;
    ULONG ioRequestDataLength, headerSize;
    
    if ((smartcardRequest->BufferSize < smartcardRequest->BufferLength) ||
        (smartcardRequest->BufferSize - smartcardRequest->BufferLength 
         <= SmartcardExtension->IoRequest.RequestBufferLength)) {

        SmartcardDebug(
            DEBUG_ERROR,
            (TEXT("%s!SmartcardT0Request: IoRequest.RequestBuffer too big\n"),
            DRIVER_NAME)
            );

        return STATUS_BUFFER_OVERFLOW;
    }

    scardIoRequest = (PSCARD_IO_REQUEST) 
        SmartcardExtension->IoRequest.RequestBuffer;

    ioRequestData = 
        SmartcardExtension->IoRequest.RequestBuffer + 
        sizeof(SCARD_IO_REQUEST);

    ioRequestDataLength = 
        SmartcardExtension->IoRequest.RequestBufferLength - 
        sizeof(SCARD_IO_REQUEST);

    //
    // Copy T=0 protocol-info into buffer
    //
    RtlCopyMemory(
        &smartcardRequest->Buffer[smartcardRequest->BufferLength],
        ioRequestData,
        ioRequestDataLength
        );
        
    //
    // Remember number of bytes for the header offset
    //
    headerSize = 
        smartcardRequest->BufferLength;

    //
    // Number of bytes to send to the reader 
    //    
    smartcardRequest->BufferLength += 
        ioRequestDataLength;

    if (ioRequestDataLength < 4) {

        //
        // A T=0 request needs at least 4 bytes
        //
        SmartcardDebug(
            DEBUG_ERROR,
            (TEXT("%s!SmartcardT0Request: TPDU is too short (%d). Must be at least 4 bytes\n"),
            DRIVER_NAME,
            ioRequestDataLength)
            );

        return STATUS_INVALID_PARAMETER;

    } else {

        PUCHAR requestBuffer = SmartcardExtension->SmartcardRequest.Buffer;

        if (ioRequestDataLength <= 5) {

            //
            // We request to read data from the card
            //
            SmartcardExtension->T0.Lc = 0;

            if (ioRequestDataLength == 4) {

                //
                // This is a special case where a 4 byte APDU is mapped to 
                // a 5 byte TPDU (ISO 7816 - Part 4, Annex A, A.1 Case 1)
                // This case requires that we append a 0 to the 
                // APDU to make it a TPDU
                //
                SmartcardExtension->T0.Le = 0;
                smartcardRequest->Buffer[headerSize + 4] = 0;
                smartcardRequest->BufferLength += 1;

            } else {
                
                SmartcardExtension->T0.Le = 
                    (requestBuffer[headerSize + 4] ? requestBuffer[headerSize + 4] : 256);
            }

        } else {
            
            //
            // We want to send data to the card
            //
            SmartcardExtension->T0.Lc = requestBuffer[headerSize + 4];
            SmartcardExtension->T0.Le = 0;

            if (SmartcardExtension->T0.Lc != ioRequestDataLength - 5) {

                SmartcardDebug(
                    DEBUG_ERROR,
                    (TEXT("%s!SmartcardT0Request: Lc(%d) in TPDU doesn't match number of bytes to send(%d).\n"),
                    DRIVER_NAME,
                    SmartcardExtension->T0.Lc,
                    ioRequestDataLength - 5)
                    );

                return STATUS_INVALID_PARAMETER;
            }
        }

#if DEBUG
        {
            PUCHAR T0Data = requestBuffer + headerSize;

            SmartcardDebug(
                DEBUG_PROTOCOL,
                (TEXT(" CLA:  %02X\n INS:  %02X\n P1:   %02X\n P2:   %02X\n Lc:   %02X\n Le:   %02X\n"), 
                T0Data[0], T0Data[1], T0Data[2], T0Data[3],
                SmartcardExtension->T0.Lc,
                SmartcardExtension->T0.Le)
                );

            if (SmartcardExtension->T0.Lc) {

                SmartcardDebug(
                    DEBUG_PROTOCOL,
                    (TEXT(" Data: "))
                    );

                DumpData(
                    DEBUG_PROTOCOL,
                    T0Data + 5, 
                    SmartcardExtension->T0.Lc
                    );
            }
        }
#endif 

        //
        // If the card uses invers convention invert the data
        // 
        if (SmartcardExtension->CardCapabilities.InversConvention) {

            SmartcardInvertData(
                &smartcardRequest->Buffer[headerSize], 
                smartcardRequest->BufferLength - headerSize
                );
        }

        return STATUS_SUCCESS;

#ifdef APDU_SUPPORT
        ULONG requestLength = SmartcardExtension->SmartcardRequest.BufferLength;
        ULONG L;

        //
        // Figure out Lc and Le
        // (See 'Decoding of the command APDUs' in ISO Part 4, 5.3.2)
        // (Variable names used are according to ISO designations)
        //
        L = requestLength - 4;

        if (L > 65536) {

            return STATUS_INVALID_PARAMETER;
        }

        if (L == 0) {

            //
            // Lc = 0, No Data, Le = 0;
            //
            SmartcardExtension->T0.Lc = 0;
            SmartcardExtension->T0.Le = 0;

        } else if (L == 1) {
            
            //
            // Case 2S, Lc = 0, Le = B1
            //
            SmartcardExtension->T0.Lc = 0;
            SmartcardExtension->T0.Le = requestBuffer[4];

        } else {

            UCHAR B1 = requestBuffer[4];

            if (B1 != 0) {

                //
                // Short form
                //
                if (L == (ULONG) (1 + B1)) {

                    //
                    // Case 3S, Lc = B1, Le = 0
                    //
                    SmartcardExtension->T0.Lc = B1;
                    SmartcardExtension->T0.Le = 0;

                } else {
                    
                    //
                    // Case 4S, Lc = B1, Le = BL
                    // 
                    SmartcardExtension->T0.Lc = B1;
                    SmartcardExtension->T0.Le = requestBuffer[L - 1];
                }

            } else {
                
                //
                // Extended form
                //
                if (L == 3) {

                    //
                    // Case 2E, Lc = 0, Le = B(L - 1, L)
                    //
                    LENGTH length;

                    length.l.l0 = 0;
                    length.b.b0 = requestBuffer[L - 1];
                    length.b.b1 = requestBuffer[L - 2];

                    SmartcardExtension->T0.Lc = 0;
                    SmartcardExtension->T0.Le = (length.l.l0 ? length.l.l0 : 65536);

                } else {

                    LENGTH length;
                    
                    length.l.l0 = 0;
                    length.b.b0 = requestBuffer[6];
                    length.b.b1 = requestBuffer[5];

                    SmartcardExtension->T0.Lc = length.l.l0;

                    if (L == 3 + length.l.l0) {

                        //
                        // Case 3E, Lc = B(2,3)
                        //
                        SmartcardExtension->T0.Le = 0;

                    } else {

                        //
                        // Case 4E, Lc = B(2,3), Le = B(L - 1, L)
                        //
                        LENGTH length;
                        
                        length.l.l0 = 0;
                        length.b.b0 = requestBuffer[L - 1];
                        length.b.b1 = requestBuffer[L - 2];

                        SmartcardExtension->T0.Le = (length.l.l0 ? length.l.l0 : 65536);
                    }
                }
            }
        }
#endif
    }

    return STATUS_SUCCESS;
}    

NTSTATUS
#ifdef SMCLIB_VXD
SMCLIB_SmartcardT0Reply(
#else
SmartcardT0Reply(
#endif
    PSMARTCARD_EXTENSION SmartcardExtension
    )
/*++

Routine Description:

Arguments:

Return Value:

   -

--*/
{
    PSMARTCARD_REPLY smartcardReply = &SmartcardExtension->SmartcardReply;

    //
    // The reply must be at least to 2 bytes long. These 2 bytes are
    // the return value (StatusWord) from the smart card
    //
    if (smartcardReply->BufferLength < 2) {

        return STATUS_DEVICE_PROTOCOL_ERROR;
    }
    
    if (SmartcardExtension->IoRequest.ReplyBufferLength < 
        smartcardReply->BufferLength + sizeof(SCARD_IO_REQUEST)) {
        
        SmartcardDebug(
            DEBUG_ERROR,
            (TEXT("%s!SmartcardT0Request: ReplyBuffer too small\n"),
            DRIVER_NAME)
            );

        return STATUS_BUFFER_TOO_SMALL;
    }

    // Copy protocol header to user buffer
    RtlCopyMemory(
        SmartcardExtension->IoRequest.ReplyBuffer,
        SmartcardExtension->IoRequest.RequestBuffer,
        sizeof(SCARD_IO_REQUEST)
        );
        
    // If the card uses invers convention invert the data
    if (SmartcardExtension->CardCapabilities.InversConvention) {

        SmartcardInvertData(
            smartcardReply->Buffer,
            smartcardReply->BufferLength
            );
    }

    // Copy all data to user buffer
    RtlCopyMemory(
        SmartcardExtension->IoRequest.ReplyBuffer + sizeof(SCARD_IO_REQUEST),
        smartcardReply->Buffer,
        smartcardReply->BufferLength
        );
              
    // Length of answer
    *SmartcardExtension->IoRequest.Information = 
        smartcardReply->BufferLength + 
        sizeof(SCARD_IO_REQUEST);

    return STATUS_SUCCESS;
}    

BOOLEAN
SmartcardT1Chksum(
    PUCHAR Block,
    UCHAR Edc,
    BOOLEAN Verify
    )
/*++

Routine Description:

    This routine calculates the epilogue field for a T1 block. It calculates the LRC
    for all the data in the IBlock.

Arguments:

    Block - T1 Information block, to be sent, or just read, from the card.
    Edc - ErrorDetectionCode as described in ISO 
    Verify - If this is a block that was recieved form the card, TRUE will cause this routine
              to check the epilogue field, included with this buffer, against the calculated one

Return Value:

    TRUE if Verify = TRUE and epilogue fields match or Verify = FALSE
    FALSE if Verify = TRUE and an error was detected (mismatch)


--*/

{
    USHORT i;
    UCHAR lrc;
    USHORT crc = 0;
    USHORT offset = Block[2] + SCARD_T1_PROLOGUE_LENGTH;

    unsigned short crc16a[] = {
        0000000,  0140301,  0140601,  0000500,
        0141401,  0001700,  0001200,  0141101,
        0143001,  0003300,  0003600,  0143501,
        0002400,  0142701,  0142201,  0002100,
    };
    unsigned short crc16b[] = {
        0000000,  0146001,  0154001,  0012000,
        0170001,  0036000,  0024000,  0162001,
        0120001,  0066000,  0074000,  0132001,
        0050000,  0116001,  0104001,  0043000,
    };

    if (Edc & T1_CRC_CHECK) {

        UCHAR tmp;

        // Calculate CRC using tables.
        for ( i = 0; i < offset;  i++) {

             tmp = Block[i] ^ (UCHAR) crc;
             crc = (crc >> 8) ^ crc16a[tmp & 0x0f] ^ crc16b[tmp >> 4];
        }

        if (Verify) {

            if (crc == (Block[offset + 1] | (Block[offset] << 8))) {

                return TRUE;

            } else {

                return FALSE;
            }

        } else {

            Block[offset] = (UCHAR) (crc >> 8 );       //MSB of crc
            Block[offset + 1] = (UCHAR) (crc & 0x00ff);  //LSB of crc
            return TRUE;
        }

    } else {

        // Calculate LRC by X-Oring all the bytes.
        lrc = Block[0];

        for(i = 1; i < offset; i++){

            lrc ^= Block[i];
        }

        if (Verify) {

            return (lrc == Block[offset] ? TRUE : FALSE);

        } else {

            Block[offset] = lrc;
            return TRUE;
        }
    }
    return TRUE;
}

#if (DEBUG)
static 
void
DumpT1Block(
    PUCHAR Buffer,
    UCHAR Edc
    )
{

    SmartcardDebug(
        DEBUG_PROTOCOL,
        (TEXT("   NAD: %02X\n   PCB: %02X\n   LEN: %02X\n   INF: "), 
        Buffer[0], Buffer[1], Buffer[2])
        );

    if (Buffer[2] == 0) {
        
        SmartcardDebug(
            DEBUG_PROTOCOL,
            (TEXT("- "))
            );
    }

    DumpData(
        DEBUG_PROTOCOL,
        Buffer + 3,
        Buffer[2]
        );

    if (Edc & T1_CRC_CHECK) {
        
        SmartcardDebug(
            DEBUG_PROTOCOL,
            (TEXT("\n   CRC: %02X %02X"),
            Buffer[Buffer[2] + 3],
            Buffer[Buffer[2] + 4])
            );

    } else {
        
        SmartcardDebug(
            DEBUG_PROTOCOL,
            (TEXT("\n   LRC: %02X"),
            Buffer[Buffer[2] + 3])
            );
    }

    SmartcardDebug(
        DEBUG_PROTOCOL,
        (TEXT("\n"))
        );
}   
#endif

#if DEBUG
#pragma optimize( "", off )
#endif

NTSTATUS
#ifdef SMCLIB_VXD
SMCLIB_SmartcardT1Request(
#else
SmartcardT1Request(
#endif
    PSMARTCARD_EXTENSION SmartcardExtension
    )
/*++                     
                         
 Routine Description:
 
 Arguments:
 
    SmartcardExtension - Supplies a pointer to the smart card data
    
 Return Value:
                         
--*/
    
{
    PSMARTCARD_REQUEST smartcardRequest = &(SmartcardExtension->SmartcardRequest);
    PIO_HEADER IoHeader = (PIO_HEADER) SmartcardExtension->IoRequest.RequestBuffer;
    T1_BLOCK_FRAME t1SendFrame;
    NTSTATUS status = STATUS_SUCCESS;

#if (DEBUG)
    ULONG headerSize = smartcardRequest->BufferLength;
#endif

#ifdef DEBUG_INTERFACE
    if (DebugSetT1Request(SmartcardExtension)) {
        
        //
        // the debugger gave us a new packet that we have to 
        // send instead of the original packet which will be sent later
        //
        return STATUS_SUCCESS;
    }
#endif

    if (SmartcardExtension->T1.WaitForReply) {

        // we did not get an answer to our last request
        SmartcardExtension->T1.State = T1_INIT;
    }
    SmartcardExtension->T1.WaitForReply = TRUE;

    __try {
        
        switch (SmartcardExtension->T1.State) {

            case T1_INIT:
                SmartcardExtension->T1.State = T1_IFS_REQUEST;

                // NO break here !!!

            case T1_START:
                //
                // Since this is the very first block in a 
                // transmission we reset the resynch counter
                //
                SmartcardExtension->T1.Resynch = 0;

                //
                // Allocate a buffer that receives the result.
                // This is necessary since we otherwise overwite our
                // request data which we might wish to resend in case
                // of an error
                //
                if (SmartcardExtension->T1.ReplyData != NULL) {

#ifdef SMCLIB_VXD
                    _HeapFree(SmartcardExtension->T1.ReplyData, 0);
#elif defined(SMCLIB_CE)
                    LocalFree(SmartcardExtension->T1.ReplyData);
#else                
                    ExFreePool(SmartcardExtension->T1.ReplyData);
#endif
                    SmartcardExtension->T1.ReplyData = NULL;
                }

                if (SmartcardExtension->IoRequest.ReplyBufferLength <
                    IoHeader->ScardIoRequest.cbPciLength + 2) {

                    //
                    // We should at least be able to store 
                    // the io-header plus SW1 and SW2
                    //
                    status = STATUS_BUFFER_TOO_SMALL;               
                    __leave;
                }
#ifdef SMCLIB_VXD
                SmartcardExtension->T1.ReplyData = (PUCHAR) _HeapAllocate(
                    SmartcardExtension->IoRequest.ReplyBufferLength, 
                    0
                    );
#elif defined(SMCLIB_CE)
                SmartcardExtension->T1.ReplyData = (PUCHAR) LocalAlloc(LPTR,
                    SmartcardExtension->IoRequest.ReplyBufferLength 
                    );

#else
                SmartcardExtension->T1.ReplyData = ExAllocatePool(
                    NonPagedPool,
                    SmartcardExtension->IoRequest.ReplyBufferLength
                    );
#endif
                ASSERT(SmartcardExtension->T1.ReplyData != NULL);

                if (SmartcardExtension->T1.ReplyData == NULL) {

                    status = STATUS_INSUFFICIENT_RESOURCES;
                    __leave;
                }

                // No break here !!!

            case T1_RESTART:
                SmartcardDebug(
                    DEBUG_PROTOCOL,
                    (TEXT("%s!SmartcardT1Request: T1_%s\n"),
                    DRIVER_NAME,
                    (SmartcardExtension->T1.State == T1_START ? TEXT("START") : TEXT("RESTART")))
                    );

                // Copy protocol header back to user buffer
                RtlCopyMemory(
                    SmartcardExtension->T1.ReplyData,
                    SmartcardExtension->IoRequest.RequestBuffer,
                    IoHeader->ScardIoRequest.cbPciLength
                    );

                //
                // Check for the special case where the io-header is followed 
                // by asn1 data that contains the NAD value to be used.
                // This was done for VISA, because they need access to the NAD.
                // The NAD is ASN1 encoded as 81h 00h NAD 00h
                //
                if (IoHeader->ScardIoRequest.cbPciLength > sizeof(SCARD_IO_REQUEST) &&
                    IoHeader->Asn1Data[0] == 0x81 &&
                    IoHeader->Asn1Data[1] == 0x01 &&
                    IoHeader->Asn1Data[3] == 0x00) {

                    SmartcardExtension->T1.NAD = IoHeader->Asn1Data[2]; 

                    SmartcardDebug(
                        DEBUG_PROTOCOL,
                        (TEXT("%s!SmartcardT1Request: NAD set to %02xh\n"),
                        DRIVER_NAME,
                        SmartcardExtension->T1.NAD)
                        );
                } 

                // Initialize the T1 protocol data 
                SmartcardExtension->T1.BytesToSend = 
                    SmartcardExtension->IoRequest.RequestBufferLength - 
                    IoHeader->ScardIoRequest.cbPciLength;
                
                SmartcardExtension->T1.BytesSent = 0;
                SmartcardExtension->T1.BytesReceived = 0;
                //
                // This is the maximum number of bytes that the smartcard can
                // accept in a single block. The smartcard can extend this size
                // during the transmission
                //
                SmartcardExtension->T1.IFSC = 
                    SmartcardExtension->CardCapabilities.T1.IFSC;
                
                //
                // Since this is the first block in a transmission we reset 
                // the re-transmission counter. 
                //
                SmartcardExtension->T1.Resend = 0;
                SmartcardExtension->T1.OriginalState = 0;
            
                SmartcardExtension->T1.MoreData = FALSE;
                //
                // NO break here !!!
                //
                // After a card reset we first send an IFS-Request to the card.
                // Otherwise we start with an I-Block
                //

            case T1_IFS_REQUEST:
                if (SmartcardExtension->T1.State == T1_IFS_REQUEST) {
                    
                    SmartcardDebug(
                        DEBUG_PROTOCOL,
                        (TEXT("%s!SmartcardT1Request: T1_IFSD_REQUEST\n"),
                        DRIVER_NAME)
                        );

                    SmartcardExtension->T1.State = 
                        T1_IFS_REQUEST;

                    t1SendFrame.Nad = SmartcardExtension->T1.NAD;
                    //
                    // IFS request.
                    // Send our IFSD size to the card
                    //
                    t1SendFrame.Pcb = 0xC1;
                    t1SendFrame.Len = 1;
                    t1SendFrame.Inf = &SmartcardExtension->T1.IFSD;

                    break;

                } else {
                    
                    SmartcardExtension->T1.State = T1_I_BLOCK;
                }

                // No break here !!
            
            case T1_I_BLOCK:
                SmartcardExtension->T1.State = T1_I_BLOCK;

                //
                // Set the number of bytes we will transmit to the card.
                // This is the lesser of IFSD and IFSC
                //
                SmartcardExtension->T1.InfBytesSent = SmartcardExtension->T1.IFSC;
    
                if (SmartcardExtension->T1.InfBytesSent > SmartcardExtension->T1.IFSD) {

                    SmartcardExtension->T1.InfBytesSent = SmartcardExtension->T1.IFSD;
                }

                // Send either max frame size or remaining bytes
                if (SmartcardExtension->T1.BytesToSend > SmartcardExtension->T1.InfBytesSent) {
                    
                    SmartcardExtension->T1.MoreData = TRUE;
                    t1SendFrame.Len = SmartcardExtension->T1.InfBytesSent;

                } else {

                    SmartcardExtension->T1.MoreData = FALSE;                
                    t1SendFrame.Len = (UCHAR) SmartcardExtension->T1.BytesToSend;
                }
                
                t1SendFrame.Nad = SmartcardExtension->T1.NAD;

                //
                // ProtocolControlByte:
                //      b7 - SendSequenceNumber
                //      b6 - MoreDatatBit
                //
                t1SendFrame.Pcb = 
                    (SmartcardExtension->T1.SSN) << 6 |
                    (SmartcardExtension->T1.MoreData ? T1_MORE_DATA : 0);
            
                t1SendFrame.Inf = 
                    SmartcardExtension->IoRequest.RequestBuffer + 
                    IoHeader->ScardIoRequest.cbPciLength +
                    SmartcardExtension->T1.BytesSent;

                SmartcardDebug(
                    DEBUG_PROTOCOL,
                    (TEXT("%s!SmartcardT1Request: I(%d.%d) ->\n"),
                    DRIVER_NAME,
                    SmartcardExtension->T1.SSN,
                    (SmartcardExtension->T1.MoreData ? 1 : 0))
                    );
                break; 
            
            case T1_R_BLOCK:
                SmartcardDebug(
                    DEBUG_PROTOCOL,
                    (TEXT("%s!SmartcardT1Request: R(%d) ->\n"),
                    DRIVER_NAME,
                    SmartcardExtension->T1.RSN)
                    );

                t1SendFrame.Nad = SmartcardExtension->T1.NAD;
                //
                // ProtocolControlByte:
                //      b5 -    SequenceNumber
                //      b1-4 -  ErrorCode
                //
                t1SendFrame.Pcb = 
                    0x80 | 
                    (SmartcardExtension->T1.RSN) << 4 |
                    (SmartcardExtension->T1.LastError);
            
                //
                // If this R-Block is a response to an error
                // we have to restore to the original state we had before 
                //
                if (SmartcardExtension->T1.LastError) {

                    SmartcardExtension->T1.LastError = 0;

                    //
                    // We must have a defined original state here
                    //
                    ASSERT(SmartcardExtension->T1.OriginalState != 0);

                    if (SmartcardExtension->T1.OriginalState == 0) {

                        SmartcardExtension->T1.State = T1_START;
                        status = STATUS_INTERNAL_ERROR;                     
                        __leave;
                    }

                    SmartcardExtension->T1.State = 
                        SmartcardExtension->T1.OriginalState;
                }
                
                t1SendFrame.Len = 0;
                t1SendFrame.Inf = NULL;
                break;    

            case T1_IFS_RESPONSE:
                SmartcardDebug(
                    DEBUG_PROTOCOL,
                    (TEXT("%s!SmartcardT1Request: T1_IFSD_RESPONSE\n"),
                    DRIVER_NAME)
                    );
                
                // Restore to the original state we had before
                ASSERT(SmartcardExtension->T1.OriginalState != 0);

                SmartcardExtension->T1.State = 
                    SmartcardExtension->T1.OriginalState;

                t1SendFrame.Nad = SmartcardExtension->T1.NAD;

                // Send IFS response
                t1SendFrame.Pcb = 0xE1;
                t1SendFrame.Len = 1;

                // New length of INF-Field
                t1SendFrame.Inf = &SmartcardExtension->T1.IFSC;
                break;    
            
            case T1_RESYNCH_REQUEST:
                SmartcardDebug(
                    DEBUG_PROTOCOL,
                    (TEXT("%s!SmartcardT1Request: T1_RESYNCH_REQUEST\n"),
                    DRIVER_NAME)
                    );

                t1SendFrame.Nad = SmartcardExtension->T1.NAD;

                // Resynch request
                t1SendFrame.Pcb = 0xC0;
                t1SendFrame.Len = 0;
                t1SendFrame.Inf = NULL;

                // Set the send sequence number to 0
                SmartcardExtension->T1.SSN = 0;    
                break;
            
            case T1_ABORT_REQUEST:
                SmartcardDebug(
                    DEBUG_PROTOCOL,
                    (TEXT("%s!SmartcardT1Request: T1_ABORT_REQUEST\n"),
                    DRIVER_NAME)
                    );
                
                t1SendFrame.Nad = SmartcardExtension->T1.NAD;

                // Send ABORT request
                t1SendFrame.Pcb = 0xC2;
                t1SendFrame.Len = 0;
                t1SendFrame.Inf = NULL;
                break;    
            
            case T1_ABORT_RESPONSE:
                SmartcardDebug(
                    DEBUG_PROTOCOL,
                    (TEXT("%s!SmartcardT1Request: T1_ABORT_RESPONSE\n"),
                    DRIVER_NAME)
                    );
                SmartcardExtension->T1.State = T1_START;
                
                t1SendFrame.Nad = SmartcardExtension->T1.NAD;

                // Send ABORT response
                t1SendFrame.Pcb = 0xE2;
                t1SendFrame.Len = 0;
                t1SendFrame.Inf = NULL;
                break;    
            
            case T1_WTX_RESPONSE:
                SmartcardDebug(
                    DEBUG_PROTOCOL,
                    (TEXT("%s!SmartcardT1Request: T1_WTX_RESPONSE\n"),
                    DRIVER_NAME)
                    );

                // Restore to the original state we had before
                ASSERT(SmartcardExtension->T1.OriginalState != 0);

                SmartcardExtension->T1.State = 
                    SmartcardExtension->T1.OriginalState;

                SmartcardExtension->T1.OriginalState = 0;

                t1SendFrame.Nad = SmartcardExtension->T1.NAD;

                // Send WTX response
                t1SendFrame.Pcb = 0xE3;
                t1SendFrame.Len = 1;
                t1SendFrame.Inf = &SmartcardExtension->T1.Wtx;
                break;    
            
        }

        // Insert Node Address byte
        smartcardRequest->Buffer[smartcardRequest->BufferLength] = 
            t1SendFrame.Nad;
        
        // Insert ProtocolControlByte
        smartcardRequest->Buffer[smartcardRequest->BufferLength + 1] = 
            t1SendFrame.Pcb;
        
        // Length of INF field
        smartcardRequest->Buffer[smartcardRequest->BufferLength + 2] = 
            t1SendFrame.Len;

        // Insert INF field data
        if (t1SendFrame.Len > 0) {
    
            RtlCopyMemory(
                &smartcardRequest->Buffer[smartcardRequest->BufferLength + 3],
                t1SendFrame.Inf,
                t1SendFrame.Len
            );
        }

        // Compute checksum
        SmartcardT1Chksum(
            &smartcardRequest->Buffer[smartcardRequest->BufferLength],
            SmartcardExtension->CardCapabilities.T1.EDC,
            FALSE
            );

#if defined(DEBUG)
#if defined(SMCLIB_NT)
        if (SmartcardGetDebugLevel() & DEBUG_T1_TEST) {
    
            LARGE_INTEGER Ticks;
            UCHAR RandomVal;
            KeQueryTickCount(&Ticks);

            RandomVal = (UCHAR) Ticks.LowPart % 4;

            if (RandomVal == 0) {

                smartcardRequest->Buffer[smartcardRequest->BufferLength - 1] += 1;

                SmartcardDebug(
                    DEBUG_ERROR,
                    (TEXT("%s!SmartcardT1Request: Simulating bad checksum\n"),
                    DRIVER_NAME)
                    );
            }
        }
#endif

        DumpT1Block(
            smartcardRequest->Buffer + headerSize,
            SmartcardExtension->CardCapabilities.T1.EDC
            );
#endif

        //
        // If the card uses invers convention invert the data
        // NOTE: do not invert any header data the reader may use
        //
        if (SmartcardExtension->CardCapabilities.InversConvention) {

            SmartcardInvertData(
                &smartcardRequest->Buffer[smartcardRequest->BufferLength],
                (SmartcardExtension->CardCapabilities.T1.EDC & T1_CRC_CHECK ? 5 : 4) +
                t1SendFrame.Len
                );
        }

        //
        // Update the number of bytes that are in the buffer
        // A T1 block is at least 4 bytes long with LRC check and 5 bytes with CRC check
        //
        smartcardRequest->BufferLength +=
            (SmartcardExtension->CardCapabilities.T1.EDC & T1_CRC_CHECK ? 5 : 4) +
            t1SendFrame.Len;
    }
    __finally {
        
#ifdef DEBUG_INTERFACE
        DebugGetT1Request(SmartcardExtension, status);
#endif
    }

    return status;
}        

NTSTATUS
#ifdef SMCLIB_VXD
SMCLIB_SmartcardT1Reply(
#else
SmartcardT1Reply(
#endif
    PSMARTCARD_EXTENSION SmartcardExtension
    )
/*++                     
                         
 Routine Description:
 
 Arguments:
 
    DeviceObject - Supplies a pointer to the device object for this request.
    
 Return Value:
                         
--*/
    
{
    T1_BLOCK_FRAME t1RecFrame;
    NTSTATUS status = STATUS_MORE_PROCESSING_REQUIRED;
    PIO_HEADER IoHeader = (PIO_HEADER) SmartcardExtension->T1.ReplyData;
    BOOLEAN packetOk = TRUE, chksumOk = TRUE;

    ASSERT(IoHeader != NULL);

    if (IoHeader == NULL) {

        return STATUS_INTERNAL_ERROR;
    }

#ifdef DEBUG_INTERFACE
    if (DebugT1Reply(SmartcardExtension)) {
        
        // the debugger processed this packet which means
        // that we should not parse it.
        return STATUS_MORE_PROCESSING_REQUIRED;
    }
#endif

    // signal that we received an answer
    SmartcardExtension->T1.WaitForReply = FALSE;

    // Invert the data of an inverse convention card
    if (SmartcardExtension->CardCapabilities.InversConvention) {

        SmartcardInvertData(
            SmartcardExtension->SmartcardReply.Buffer,
            SmartcardExtension->SmartcardReply.BufferLength
            );
    }

    // Clear waiting time extension
    SmartcardExtension->T1.Wtx = 0;

    try {                

        ULONG expectedLength = 
            SCARD_T1_PROLOGUE_LENGTH +
            SmartcardExtension->SmartcardReply.Buffer[2] +
            (SmartcardExtension->CardCapabilities.T1.EDC & T1_CRC_CHECK ? 2 : 1);

        if (SmartcardExtension->SmartcardReply.BufferLength < 4 ||
            SmartcardExtension->SmartcardReply.BufferLength != expectedLength) {

            SmartcardDebug(
                DEBUG_ERROR,
                (TEXT("%s!SmartcardT1Reply: Packet length incorrect\n"),
                DRIVER_NAME)
                );

            packetOk = FALSE;

        } else {
            
            // calculate the checksum
            chksumOk = SmartcardT1Chksum(
                SmartcardExtension->SmartcardReply.Buffer,
                SmartcardExtension->CardCapabilities.T1.EDC,
                TRUE
                );

#if DEBUG
#ifndef SMCLIB_VXD
            if (SmartcardGetDebugLevel() & DEBUG_T1_TEST) {

                // inject some checksum errors

                LARGE_INTEGER Ticks;
                UCHAR RandomVal;
                KeQueryTickCount(&Ticks);

                RandomVal = (UCHAR) Ticks.LowPart % 4;

                if (RandomVal == 0) {

                    chksumOk = FALSE;

                    SmartcardDebug(
                        DEBUG_ERROR,
                        (TEXT("%s!SmartcardT1Reply: Simulating bad checksum\n"),
                        DRIVER_NAME)
                        );
                }
            }
#endif
#endif
        }

        if (chksumOk == FALSE) {

            SmartcardDebug(
                DEBUG_ERROR,
                (TEXT("%s!SmartcardT1Reply: Bad checksum\n"), 
                DRIVER_NAME)
                );
        }

        if (packetOk == FALSE || chksumOk == FALSE) {

            SmartcardExtension->T1.LastError = 
                (chksumOk ? T1_ERROR_OTHER : T1_ERROR_CHKSUM);

            if (SmartcardExtension->T1.OriginalState == 0) {

                SmartcardExtension->T1.OriginalState = 
                    SmartcardExtension->T1.State;
            }
        
            if (SmartcardExtension->T1.Resend++ == T1_MAX_RETRIES) {
        
                SmartcardExtension->T1.Resend = 0;
            
                // Try to resynchronize since the resend requests have failed
                SmartcardExtension->T1.State = T1_RESYNCH_REQUEST;
                __leave;

            } 
            
            // If the last request was a resynch we try again to resynch
            if (SmartcardExtension->T1.State != T1_RESYNCH_REQUEST) {
        
                // Chksum not OK; request resend of last block
                SmartcardExtension->T1.State = T1_R_BLOCK;
            }
            __leave;
        }

        //
        // The checksum of the packet is ok.
        // Now check the rest of the packet
        //

        // Clear the last error
        SmartcardExtension->T1.LastError = 0;

        t1RecFrame.Nad = SmartcardExtension->SmartcardReply.Buffer[0];
        t1RecFrame.Pcb = SmartcardExtension->SmartcardReply.Buffer[1];
        t1RecFrame.Len = SmartcardExtension->SmartcardReply.Buffer[2];
        t1RecFrame.Inf = &SmartcardExtension->SmartcardReply.Buffer[3];

        // 
        // If the last block we sent was a ifs request, 
        // we expect the card to reply with an ifs response.
        //
        if (SmartcardExtension->T1.State == T1_IFS_REQUEST) {

            // Check if the card properly responded to an ifs request
            if (t1RecFrame.Pcb == T1_IFS_RESPONSE) {

                SmartcardDebug(
                    DEBUG_PROTOCOL,
                    (TEXT("%s!SmartcardT1Reply:   T1_IFSC_RESPONSE\n"),
                    DRIVER_NAME)
                    );

                // The smart card acked our ifsd size
                SmartcardExtension->T1.State = T1_I_BLOCK;
                __leave;
            }

            if ((t1RecFrame.Pcb & 0x82) == 0x82) {

                //
                // The card does not support ifs request, so we stop 
                // sending this and continue with a data block
                // (the card is NOT ISO conform)
                //
                SmartcardDebug(
                    DEBUG_ERROR,
                    (TEXT("%s!SmartcardT1Reply:   Card does not support IFS REQUEST\n"),
                    DRIVER_NAME)
                    );

                SmartcardExtension->T1.State = T1_I_BLOCK;
                __leave;
            }

            //
            // The card replied with junk to our ifs request.
            // It doesn't make sense to continue.
            //
            status = STATUS_DEVICE_PROTOCOL_ERROR;
            __leave;
        }
    
        // 
        // If the last block was a resync. request,
        // we expect the card to answer with a resynch response.
        //
        if (SmartcardExtension->T1.State == T1_RESYNCH_REQUEST) {

            // Check if the card properly responded to an resynch request
            if (t1RecFrame.Pcb != T1_RESYNCH_RESPONSE) {
        
                SmartcardDebug(
                    DEBUG_ERROR,
                    (TEXT("%s!SmartcardT1Reply:   Card response is not ISO conform! Aborting...\n"),
                    DRIVER_NAME)
                    );

                status = STATUS_DEVICE_PROTOCOL_ERROR;
                __leave;

            } 
            
            SmartcardDebug(
                DEBUG_PROTOCOL,
                (TEXT("%s!SmartcardT1Reply:   T1_RESYNCH_RESPONSE\n"),
                DRIVER_NAME)
                );

            // Reset error counter
            SmartcardExtension->T1.Resend = 0;

            // The smart card has successfully responded to a resynch request
            SmartcardExtension->T1.RSN = 0;
            SmartcardExtension->T1.SSN = 0;

            //
            // Do a complete restart of the whole transmission
            // but without resetting the resynch counter
            //
            SmartcardExtension->T1.State = T1_RESTART;
            __leave;
        }

        //
        // Now check for other protocol states...
        //
    
        //
        // Copy NAD value back to user buffer if this is an extended io-header
        // containing the nad
        //
        if (IoHeader->ScardIoRequest.cbPciLength > sizeof(SCARD_IO_REQUEST) &&
            IoHeader->Asn1Data[0] == 0x81 &&
            IoHeader->Asn1Data[1] == 0x01 &&
            IoHeader->Asn1Data[3] == 0x00) {

            IoHeader->Asn1Data[2] = t1RecFrame.Nad;             
        }

        if ((t1RecFrame.Pcb & 0x80) == 0) {

            // This is an I-block

            SmartcardDebug(
                DEBUG_PROTOCOL,
                (TEXT("%s!SmartcardT1Reply:   I(%d.%d) <-\n"),
                DRIVER_NAME,
                (t1RecFrame.Pcb & 0x40) >> 6,
                (t1RecFrame.Pcb & 0x20) >> 5)
                );

            if (((t1RecFrame.Pcb & 0x40) >> 6) == SmartcardExtension->T1.RSN) {

                // I-Block with correct sequence number
    
                PUCHAR data;
                ULONG minBufferSize;

                // Reset error counter and error indicator
                SmartcardExtension->T1.Resend = 0;
                SmartcardExtension->T1.OriginalState = 0;

                // We can 'increase' the number of correctly received I-Blocks
                SmartcardExtension->T1.RSN ^= 1;

                if (SmartcardExtension->T1.State == T1_I_BLOCK) {

                    // This I-Block is also an acknowledge for the I-Block we sent 
                    SmartcardExtension->T1.SSN ^= 1;
                }
        
                // Check size of user buffer
                minBufferSize = 
                    IoHeader->ScardIoRequest.cbPciLength +
                    SmartcardExtension->T1.BytesReceived +
                    t1RecFrame.Len;
        
                if (SmartcardExtension->IoRequest.ReplyBufferLength < minBufferSize) {
            
                    status = STATUS_BUFFER_TOO_SMALL;
                    __leave;
                }

                ASSERT(SmartcardExtension->T1.ReplyData);
                //
                // Let data pointer point behind struct.
                // All reply data will be stored there.
                // 
                data = 
                    SmartcardExtension->T1.ReplyData + 
                    IoHeader->ScardIoRequest.cbPciLength +
                    SmartcardExtension->T1.BytesReceived;

                // Copy data to user buffer
                RtlCopyMemory(
                    data,
                    t1RecFrame.Inf,
                    t1RecFrame.Len
                    );
              
                SmartcardExtension->T1.BytesReceived += t1RecFrame.Len;
        
                if (t1RecFrame.Pcb & T1_MORE_DATA) {
    
                    // Ack this block and request the next block
                    SmartcardExtension->T1.State = T1_R_BLOCK;
        
                } else {
        
                    //
                    // This was the last block of the transmission
                    // Set number of bytes returned by this transmission
                    //
                    *SmartcardExtension->IoRequest.Information = 
                        IoHeader->ScardIoRequest.cbPciLength + 
                        SmartcardExtension->T1.BytesReceived;

                    // Copy the result back to the user buffer
                    ASSERT(SmartcardExtension->IoRequest.ReplyBuffer != NULL);

                    RtlCopyMemory(
                        SmartcardExtension->IoRequest.ReplyBuffer,
                        SmartcardExtension->T1.ReplyData,
                        IoHeader->ScardIoRequest.cbPciLength +
                            SmartcardExtension->T1.BytesReceived                        
                        );
        
                    status = STATUS_SUCCESS;
                }
                __leave;
            }

            //
            // I-Block with wrong sequence number
            // We try T1_MAX_RETRIES times to resend the last block.
            // If this is unsuccessfull, we try to resynch.
            // If resynch is unsuccessfull we abort the transmission.
            //
            SmartcardDebug(
                DEBUG_ERROR,
                (TEXT("%s!SmartcardT1Reply: Block number incorrect\n"),
                DRIVER_NAME)
                );

            SmartcardExtension->T1.LastError = T1_ERROR_OTHER;

            if (SmartcardExtension->T1.OriginalState == 0) {
                
                SmartcardExtension->T1.OriginalState = 
                    SmartcardExtension->T1.State;
            }

            if (SmartcardExtension->T1.Resend++ == T1_MAX_RETRIES) {
    
                SmartcardExtension->T1.Resend = 0;
        
                // Try to resynchronize
                SmartcardExtension->T1.State = T1_RESYNCH_REQUEST;
                __leave;
            }

            // request the block again.
            SmartcardExtension->T1.State = T1_R_BLOCK;
            __leave;
        } 
    
        if ((t1RecFrame.Pcb & 0xC0) == 0x80) {

            // This is an R-block

            UCHAR RSN = (t1RecFrame.Pcb & 0x10) >> 4;
    
            SmartcardDebug(
                DEBUG_PROTOCOL,
                (TEXT("%s!SmartcardT1Reply:   R(%d) <-\n"),
                DRIVER_NAME,
                RSN)
                );
    
            if (RSN != SmartcardExtension->T1.SSN &&  
                SmartcardExtension->T1.MoreData) {
    
                // The ICC has acked the last block
                SmartcardExtension->T1.Resend = 0;

                SmartcardExtension->T1.BytesSent += SmartcardExtension->T1.InfBytesSent;
                SmartcardExtension->T1.BytesToSend -= SmartcardExtension->T1.InfBytesSent;
                SmartcardExtension->T1.SSN ^= 1;
                SmartcardExtension->T1.State = T1_I_BLOCK;

                __leave;
            } 

            //
            // We have an error condition...
            //

            ASSERT(t1RecFrame.Pcb & 0x0f);
            
            if ((t1RecFrame.Pcb & 0x02) && 
                SmartcardExtension->T1.State == T1_IFS_REQUEST) {

                //
                // The card does not support ifs request, so 
                // we stop sending this and continue with a data block
                // (the card is NOT ISO conform)
                //
                SmartcardDebug(
                    DEBUG_ERROR,
                    (TEXT("%s!SmartcardT1Reply:   Card does not support IFS REQUEST\n"),
                    DRIVER_NAME)
                    );

                SmartcardExtension->T1.State = T1_I_BLOCK;
                __leave;
            } 

            // We have to resend the last block
            SmartcardDebug(
                DEBUG_ERROR,
                (TEXT("%s!SmartcardT1Reply:   Card reports error\n"),
                DRIVER_NAME)
                );

            if (SmartcardExtension->T1.Resend++ == T1_MAX_RETRIES) {

                SmartcardExtension->T1.Resend = 0;
    
                if (SmartcardExtension->T1.OriginalState == 0) {
                
                    // Save current state
                    SmartcardExtension->T1.OriginalState = 
                        SmartcardExtension->T1.State;
                }

                // Try to resynchronize
                SmartcardExtension->T1.State = T1_RESYNCH_REQUEST;
            } 
            __leave;        
        } 

        //
        // This is an S-block
        // 

        switch (t1RecFrame.Pcb) {

            case T1_IFS_REQUEST:
                SmartcardDebug(
                    DEBUG_PROTOCOL,
                    (TEXT("%s!SmartcardT1Reply:   T1_IFSC_REQUEST\n"),
                    DRIVER_NAME)
                    );

                // The smart card wants to exend the IFS - size
                SmartcardExtension->T1.IFSC = 
                    SmartcardExtension->SmartcardReply.Buffer[3];
       
                // Save current state
                ASSERT(SmartcardExtension->T1.OriginalState == 0);

                SmartcardExtension->T1.OriginalState =
                    SmartcardExtension->T1.State;

                SmartcardExtension->T1.State = T1_IFS_RESPONSE;
                break;
        
            case T1_ABORT_REQUEST:
                SmartcardDebug(
                    DEBUG_PROTOCOL,
                    (TEXT("%s!SmartcardT1Reply:   T1_ABORT_REQUEST\n"),
                    DRIVER_NAME)
                    );

                SmartcardExtension->T1.State = T1_ABORT_RESPONSE;
                break;
        
            case T1_WTX_REQUEST:
                SmartcardDebug(
                    DEBUG_PROTOCOL,
                    (TEXT("%s!SmartcardT1Reply:   T1_WTX_REQUEST\n"),
                    DRIVER_NAME)
                    );
            
                // Smart card needs longer wait time
                SmartcardExtension->T1.Wtx = 
                    SmartcardExtension->SmartcardReply.Buffer[3];

                // Save current state
                ASSERT(SmartcardExtension->T1.OriginalState == 0 ||
                       SmartcardExtension->T1.OriginalState == T1_WTX_RESPONSE);

                SmartcardExtension->T1.OriginalState =
                    SmartcardExtension->T1.State;
            
                SmartcardExtension->T1.State = T1_WTX_RESPONSE;
                break;
        
            case T1_VPP_ERROR:
                SmartcardDebug(
                    DEBUG_ERROR,
                    (TEXT("%s!SmartcardT1Reply:   T1_VPP_ERROR\n"),
                    DRIVER_NAME)
                    );

                status = STATUS_DEVICE_POWER_FAILURE;
                break;

            default:
                ASSERTMSG(
                    TEXT("SmartcardT1Reply: Invalid Pcb "),
                    FALSE
                    );

                status = STATUS_DEVICE_PROTOCOL_ERROR;
                break;
        }
    }
    finally {
        
#if DEBUG
        if (packetOk && chksumOk) {
            
            DumpT1Block(
                SmartcardExtension->SmartcardReply.Buffer,
                SmartcardExtension->CardCapabilities.T1.EDC
                );
        }
#endif

        if (SmartcardExtension->T1.State == T1_RESYNCH_REQUEST && 
            SmartcardExtension->T1.Resynch++ == T1_MAX_RETRIES) {
    
            SmartcardDebug(
                DEBUG_ERROR,
                (TEXT("%s!SmartcardT1Reply: Too many errors! Aborting...\n"),
                DRIVER_NAME)
                );

            status = STATUS_DEVICE_PROTOCOL_ERROR;
        }
            
        if (status != STATUS_MORE_PROCESSING_REQUIRED) {

            if (SmartcardExtension->T1.OriginalState == T1_IFS_REQUEST) {
        
                SmartcardExtension->T1.State = T1_IFS_REQUEST;

            } else {
        
                SmartcardExtension->T1.State = T1_START;
            }

            if (SmartcardExtension->T1.ReplyData) {
                
                // free the reply data buffer
#ifdef SMCLIB_VXD
                _HeapFree(SmartcardExtension->T1.ReplyData, 0);
#elif defined(SMCLIB_CE)
                LocalFree(SmartcardExtension->T1.ReplyData);
#else               
                
                ExFreePool(SmartcardExtension->T1.ReplyData);
#endif
                SmartcardExtension->T1.ReplyData = NULL;                
            }
            SmartcardExtension->T1.OriginalState = 0;
            SmartcardExtension->T1.NAD = 0;
        }

    }
    return status;
}

#if DEBUG
#pragma optimize( "", on )
#endif