977 lines
28 KiB
C
977 lines
28 KiB
C
/*++
|
|
|
|
Copyright (c) 1997 - 1999 SCM Microsystems, Inc.
|
|
|
|
Module Name:
|
|
|
|
PscrCmd.c
|
|
|
|
Abstract:
|
|
|
|
Basic command functions for SCM PSCR smartcard reader
|
|
|
|
Author:
|
|
|
|
Andreas Straub
|
|
|
|
Environment:
|
|
|
|
|
|
Win 95 Sys... calls are resolved by Pscr95Wrap.asm functions and
|
|
Pscr95Wrap.h macros, resp.
|
|
|
|
NT 4.0 Sys... functions resolved by PscrNTWrap.c functions and
|
|
PscrNTWrap.h macros, resp.
|
|
|
|
Revision History:
|
|
|
|
Andreas Straub 8/18/1997 1.00 Initial Version
|
|
Andreas Straub 9/24/1997 1.02 delay for read/write removed
|
|
|
|
--*/
|
|
|
|
#if defined( SMCLIB_VXD )
|
|
|
|
#include <Pscr95.h>
|
|
|
|
#else // SMCLIB_VXD
|
|
|
|
#include <PscrNT.h>
|
|
|
|
#endif // SMCLIB_VXD
|
|
|
|
#include <PscrRdWr.h>
|
|
#include <PscrCmd.h>
|
|
|
|
NTSTATUS
|
|
CmdResetInterface(
|
|
PREADER_EXTENSION ReaderExtension
|
|
)
|
|
/*++
|
|
CmdResetInterface:
|
|
|
|
Performs a reset of the reader interface (NOT of the PCMCIA controller)
|
|
- flush available data
|
|
- set RESET bit
|
|
- perform a buffer size exchange between reader & host
|
|
- enables interrupts for freeze events
|
|
- disables default PTS
|
|
|
|
Arguments:
|
|
ReaderExtension context of call
|
|
|
|
Return Value:
|
|
STATUS_SUCCESS
|
|
STATUS_IO_DEVICE_ERROR
|
|
|
|
--*/
|
|
{
|
|
|
|
NTSTATUS NTStatus = STATUS_SUCCESS;
|
|
ULONG IOBytes;
|
|
UCHAR Len,
|
|
Tag,
|
|
Cnt,
|
|
InData[ TLV_BUFFER_SIZE ];
|
|
PPSCR_REGISTERS IOBase;
|
|
UCHAR EnableInterrupts[] = { 0x28, 0x01, 0x01};
|
|
|
|
|
|
IOBase = ReaderExtension->IOBase;
|
|
|
|
// discard any data
|
|
PscrFlushInterface( ReaderExtension );
|
|
|
|
// reset reader
|
|
WRITE_PORT_UCHAR( &IOBase->CmdStatusReg, PSCR_RESET_BIT );
|
|
SysDelay( DELAY_WRITE_PSCR_REG );
|
|
WRITE_PORT_UCHAR( &IOBase->CmdStatusReg, CLEAR_BIT );
|
|
|
|
NTStatus = PscrWait( ReaderExtension, PSCR_DATA_AVAIL_BIT );
|
|
|
|
// read & check vendor string
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
|
|
WRITE_PORT_UCHAR( &IOBase->CmdStatusReg, PSCR_HOST_CONTROL_BIT );
|
|
SysDelay( DELAY_WRITE_PSCR_REG );
|
|
//
|
|
// get actual len from TLV list
|
|
//
|
|
READ_PORT_UCHAR( &IOBase->SizeMSReg );
|
|
READ_PORT_UCHAR( &IOBase->SizeLSReg );
|
|
|
|
Tag = READ_PORT_UCHAR( &IOBase->DataReg );
|
|
Len = READ_PORT_UCHAR( &IOBase->DataReg );
|
|
//
|
|
// avoid overwrite of buffer
|
|
//
|
|
if ( Len > TLV_BUFFER_SIZE ) {
|
|
Len = TLV_BUFFER_SIZE;
|
|
}
|
|
for ( Cnt = 0; Cnt < Len; Cnt++ ) {
|
|
InData[ Cnt ] = READ_PORT_UCHAR( &IOBase->DataReg );
|
|
}
|
|
WRITE_PORT_UCHAR( &IOBase->CmdStatusReg, CLEAR_BIT );
|
|
//
|
|
// check vendor string
|
|
//
|
|
if ( SysCompareMemory(
|
|
InData,
|
|
PSCR_ID_STRING,
|
|
sizeof( PSCR_ID_STRING )
|
|
)) {
|
|
NTStatus = STATUS_IO_DEVICE_ERROR;
|
|
} else {
|
|
//
|
|
// vendor string was correct, check buffer size
|
|
//
|
|
WRITE_PORT_UCHAR( &IOBase->CmdStatusReg, PSCR_SIZE_READ_BIT );
|
|
NTStatus = PscrWait( ReaderExtension, PSCR_DATA_AVAIL_BIT );
|
|
//
|
|
// reader ready to transfer interface buffer size
|
|
//
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
//
|
|
// set size read & host control
|
|
//
|
|
WRITE_PORT_UCHAR(
|
|
&IOBase->CmdStatusReg,
|
|
PSCR_SIZE_READ_BIT | PSCR_HOST_CONTROL_BIT
|
|
);
|
|
|
|
SysDelay( DELAY_WRITE_PSCR_REG );
|
|
//
|
|
// read buffer length
|
|
//
|
|
Len = READ_PORT_UCHAR( &IOBase->SizeMSReg );
|
|
Len = READ_PORT_UCHAR( &IOBase->SizeLSReg );
|
|
for ( Cnt = 0; Cnt < Len; Cnt++ ) {
|
|
InData[ Cnt ] = READ_PORT_UCHAR( &IOBase->DataReg );
|
|
}
|
|
//
|
|
// transfer of interface buffer size okay
|
|
//
|
|
WRITE_PORT_UCHAR( &IOBase->CmdStatusReg, CLEAR_BIT );
|
|
SysDelay( DELAY_WRITE_PSCR_REG );
|
|
//
|
|
// notify the reader about the supported buffer size
|
|
//
|
|
WRITE_PORT_UCHAR( &IOBase->CmdStatusReg, PSCR_HOST_CONTROL_BIT );
|
|
SysDelay( DELAY_WRITE_PSCR_REG );
|
|
|
|
WRITE_PORT_UCHAR( &IOBase->SizeMSReg, 0 );
|
|
WRITE_PORT_UCHAR( &IOBase->SizeLSReg, 2 );
|
|
//
|
|
// Write the same data buffer size as the one we just got.
|
|
//
|
|
WRITE_PORT_UCHAR( &IOBase->DataReg, InData[ 0 ] );
|
|
WRITE_PORT_UCHAR( &IOBase->DataReg, InData[ 1 ] );
|
|
//
|
|
// store the size to report to the lib
|
|
// The maximum buffer size of the reader is to betrieved with
|
|
// ((ULONG)InData[ 1 ] << 8) | InData[ 0 ]
|
|
//
|
|
ReaderExtension->MaxIFSD = 254;
|
|
|
|
//
|
|
// let the reader process the size write command
|
|
//
|
|
WRITE_PORT_UCHAR( &IOBase->CmdStatusReg, PSCR_SIZE_WRITE_BIT );
|
|
NTStatus = PscrWait( ReaderExtension, PSCR_FREE_BIT );
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// clean up any host control settings
|
|
//
|
|
WRITE_PORT_UCHAR( &IOBase->CmdStatusReg, CLEAR_BIT );
|
|
//
|
|
// enable interrupts
|
|
//
|
|
CmdSetInterfaceParameter(
|
|
ReaderExtension,
|
|
ReaderExtension->Device,
|
|
EnableInterrupts,
|
|
sizeof( EnableInterrupts )
|
|
);
|
|
|
|
return( NTStatus );
|
|
}
|
|
|
|
NTSTATUS
|
|
CmdReset(
|
|
PREADER_EXTENSION ReaderExtension,
|
|
UCHAR Device,
|
|
BOOLEAN WarmReset,
|
|
PUCHAR pATR,
|
|
PULONG pATRLength
|
|
)
|
|
/*++
|
|
CmdReset:
|
|
performs a reset of the reader / ICC
|
|
|
|
Arguments:
|
|
ReaderExtension context of call
|
|
Device device requested ( ICC_1, ICC_2, PSCR )
|
|
WarmReset kind of ICC reset
|
|
pATR ptr to ATR buffer, NULL if no ATR required
|
|
pATRLength size of ATR buffer / length of ATR
|
|
|
|
Return Value:
|
|
STATUS_SUCCESS
|
|
STATUS_NO_MEDIA
|
|
STATUS_UNRECOGNIZED_MEDIA
|
|
error values from PscrRead / PscrWrite
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS NTStatus = STATUS_SUCCESS;
|
|
UCHAR IOData[ MAX_T1_BLOCK_SIZE ],
|
|
P2;
|
|
USHORT ICCStatus;
|
|
ULONG IOBytes;
|
|
|
|
// ATR from the smartcard requestet? P2 = 1
|
|
P2 = 0;
|
|
if (( pATR != NULL ) && ( pATRLength != NULL )) {
|
|
if ( *pATRLength > 0 )
|
|
P2 = 0x01;
|
|
}
|
|
|
|
// build the RESET command.
|
|
IOData[ PSCR_NAD ] = NAD_TO_PSCR;
|
|
IOData[ PSCR_PCB ] = PCB_DEFAULT;
|
|
IOData[ PSCR_LEN ] = 0x05;
|
|
|
|
if ( WarmReset == TRUE ) {
|
|
IOData[ PSCR_INF+0 ] = CLA_WARM_RESET;
|
|
IOData[ PSCR_INF+1 ] = INS_WARM_RESET;
|
|
} else {
|
|
IOData[ PSCR_INF+0 ] = CLA_RESET;
|
|
IOData[ PSCR_INF+1 ] = INS_RESET;
|
|
}
|
|
IOData[ PSCR_INF+2 ] = Device;
|
|
IOData[ PSCR_INF+3 ] = P2;
|
|
IOData[ PSCR_INF+4 ] = 0x00;
|
|
|
|
// write command
|
|
NTStatus = PscrWrite(
|
|
ReaderExtension,
|
|
IOData,
|
|
8,
|
|
&IOBytes
|
|
);
|
|
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
// read data
|
|
IOBytes = 0;
|
|
NTStatus = PscrRead(
|
|
ReaderExtension,
|
|
IOData,
|
|
MAX_T1_BLOCK_SIZE,
|
|
&IOBytes
|
|
);
|
|
|
|
// error detection
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
//
|
|
// the location of the error code in the buffer
|
|
// is: ( data ) - STATUS_MSB - STATUS_LSB - EPILOGUE
|
|
//
|
|
ICCStatus = (( USHORT )IOData[ IOBytes-PSCR_EPILOGUE_LENGTH-2 ]) << 8;
|
|
ICCStatus |= ( USHORT )IOData[ IOBytes-PSCR_EPILOGUE_LENGTH-1 ];
|
|
|
|
switch ( ICCStatus ) {
|
|
case PSCR_SW_SYNC_ATR_SUCCESS:
|
|
case PSCR_SW_ASYNC_ATR_SUCCESS:
|
|
break;
|
|
|
|
case PSCR_SW_NO_ICC:
|
|
NTStatus = STATUS_NO_MEDIA;
|
|
break;
|
|
|
|
case PSCR_SW_NO_PROTOCOL:
|
|
case PSCR_SW_NO_ATR:
|
|
case PSCR_SW_NO_ATR_OR_PROTOCOL:
|
|
case PSCR_SW_NO_ATR_OR_PROTOCOL2:
|
|
case PSCR_SW_ICC_NOT_ACTIVE:
|
|
case PSCR_SW_NON_SUPPORTED_PROTOCOL:
|
|
case PSCR_SW_PROTOCOL_ERROR:
|
|
default:
|
|
NTStatus = STATUS_UNRECOGNIZED_MEDIA;
|
|
}
|
|
//
|
|
// copy ATR if required
|
|
//
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
if ( P2 == 0x01 ) {
|
|
IOBytes -= PSCR_PROLOGUE_LENGTH + PSCR_EPILOGUE_LENGTH;
|
|
if ( IOBytes > *pATRLength ) {
|
|
IOBytes = *pATRLength;
|
|
}
|
|
SysCopyMemory(
|
|
pATR,
|
|
&IOData[ PSCR_PROLOGUE_LENGTH ],
|
|
IOBytes
|
|
);
|
|
*pATRLength = IOBytes;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return( NTStatus );
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
CmdDeactivate(
|
|
PREADER_EXTENSION ReaderExtension,
|
|
UCHAR Device
|
|
)
|
|
/*++
|
|
CmdDeactivate:
|
|
Deactivates the requested device
|
|
|
|
Arguments:
|
|
ReaderExtension context of call
|
|
Device requested device
|
|
|
|
Return Value:
|
|
STATUS_SUCCESS
|
|
error values from PscrRead / PscrWrite
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS NTStatus = STATUS_SUCCESS;
|
|
UCHAR IOData[ MAX_T1_BLOCK_SIZE ];
|
|
ULONG IOBytes;
|
|
|
|
//
|
|
// build the DEACTIVATE command.
|
|
//
|
|
IOData[ PSCR_NAD ] = NAD_TO_PSCR;
|
|
IOData[ PSCR_PCB ] = PCB_DEFAULT;
|
|
IOData[ PSCR_LEN ] = 0x05;
|
|
|
|
IOData[ PSCR_INF+0 ] = CLA_DEACTIVATE;
|
|
IOData[ PSCR_INF+1 ] = INS_DEACTIVATE;
|
|
IOData[ PSCR_INF+2 ] = Device;
|
|
IOData[ PSCR_INF+3 ] = 0x00;
|
|
IOData[ PSCR_INF+4 ] = 0x00;
|
|
//
|
|
// write command
|
|
//
|
|
NTStatus = PscrWrite(
|
|
ReaderExtension,
|
|
IOData,
|
|
8,
|
|
&IOBytes
|
|
);
|
|
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
//
|
|
// read data to trap communication errors
|
|
//
|
|
IOBytes = 0;
|
|
NTStatus = PscrRead(
|
|
ReaderExtension,
|
|
IOData,
|
|
MAX_T1_BLOCK_SIZE,
|
|
&IOBytes
|
|
);
|
|
}
|
|
return( NTStatus );
|
|
}
|
|
|
|
NTSTATUS
|
|
CmdReadBinary(
|
|
PREADER_EXTENSION ReaderExtension,
|
|
USHORT Offset,
|
|
PUCHAR pBuffer,
|
|
PULONG pBufferLength
|
|
)
|
|
/*++
|
|
CmdReadBinary:
|
|
read binary data from an PSCR data file
|
|
|
|
Arguments:
|
|
ReaderExtension context of call
|
|
Offset offset in file
|
|
pBuffer ptr to data buffer
|
|
pBufferLength length of buffer / number of bytes read
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS
|
|
STATUS_UNSUCCESSFUL
|
|
error values from PscrRead / PscrWrite
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS NTStatus = STATUS_SUCCESS;
|
|
UCHAR IOData[ MAX_T1_BLOCK_SIZE ];
|
|
USHORT ICCStatus;
|
|
ULONG IOBytes;
|
|
//
|
|
// check parameters
|
|
//
|
|
if (( pBuffer == NULL ) || ( pBufferLength == NULL)) {
|
|
NTStatus = STATUS_INVALID_PARAMETER;
|
|
} else {
|
|
//
|
|
// build the READ BINARY command
|
|
//
|
|
IOData[ PSCR_NAD] = NAD_TO_PSCR;
|
|
IOData[ PSCR_PCB] = PCB_DEFAULT;
|
|
IOData[ PSCR_LEN] = 0x05;
|
|
|
|
IOData[ PSCR_INF+0 ] = CLA_READ_BINARY;
|
|
IOData[ PSCR_INF+1 ] = INS_READ_BINARY;
|
|
IOData[ PSCR_INF+2 ] = HIBYTE( Offset );
|
|
IOData[ PSCR_INF+3 ] = LOBYTE( Offset );
|
|
IOData[ PSCR_INF+4 ] = 0x00;
|
|
//
|
|
// write command
|
|
//
|
|
NTStatus = PscrWrite(
|
|
ReaderExtension,
|
|
IOData,
|
|
8,
|
|
&IOBytes
|
|
);
|
|
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
//
|
|
// read data
|
|
//
|
|
IOBytes = 0;
|
|
NTStatus = PscrRead(
|
|
ReaderExtension,
|
|
IOData,
|
|
MAX_T1_BLOCK_SIZE,
|
|
&IOBytes
|
|
);
|
|
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
//
|
|
// error check
|
|
//
|
|
ICCStatus =
|
|
((USHORT)IOData[ IOBytes-2-PSCR_EPILOGUE_LENGTH ]) << 8;
|
|
ICCStatus |=
|
|
(USHORT)IOData[ IOBytes-1-PSCR_EPILOGUE_LENGTH ];
|
|
|
|
switch ( ICCStatus ) {
|
|
case PSCR_SW_FILE_NO_ACCEPPTED_AUTH:
|
|
case PSCR_SW_FILE_NO_ACCESS:
|
|
case PSCR_SW_FILE_BAD_OFFSET:
|
|
case PSCR_SW_END_OF_FILE_READ:
|
|
NTStatus = STATUS_UNSUCCESSFUL;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
//
|
|
// copy data
|
|
//
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
if ( *pBufferLength <
|
|
IOBytes-PSCR_PROLOGUE_LENGTH-PSCR_STATUS_LENGTH ) {
|
|
NTStatus = STATUS_BUFFER_TOO_SMALL;
|
|
} else {
|
|
( *pBufferLength ) =
|
|
IOBytes-PSCR_PROLOGUE_LENGTH-PSCR_STATUS_LENGTH;
|
|
SysCopyMemory(
|
|
pBuffer,
|
|
&IOData[ PSCR_PROLOGUE_LENGTH ],
|
|
*pBufferLength
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return( NTStatus );
|
|
}
|
|
|
|
NTSTATUS
|
|
CmdSelectFile(
|
|
PREADER_EXTENSION ReaderExtension,
|
|
USHORT FileId
|
|
)
|
|
/*++
|
|
CmdSelectFile:
|
|
selects a file/directoy of the reader
|
|
|
|
Arguments:
|
|
ReaderExtension context of call
|
|
FileId ID of file
|
|
|
|
Return Value:
|
|
STATUS_SUCCESS
|
|
STATUS_UNSUCCESSFUL
|
|
error values from PscrRead / PscrWrite
|
|
--*/
|
|
{
|
|
NTSTATUS NTStatus = STATUS_SUCCESS;
|
|
UCHAR IOData[ MAX_T1_BLOCK_SIZE ];
|
|
USHORT ICCStatus;
|
|
ULONG IOBytes;
|
|
|
|
//
|
|
// build the SELECT FILE command
|
|
//
|
|
IOData[ PSCR_NAD ] = NAD_TO_PSCR;
|
|
IOData[ PSCR_PCB ] = PCB_DEFAULT;
|
|
IOData[ PSCR_LEN ] = 0x07;
|
|
|
|
IOData[ PSCR_INF+0 ] = CLA_SELECT_FILE;
|
|
IOData[ PSCR_INF+1 ] = INS_SELECT_FILE;
|
|
IOData[ PSCR_INF+2 ] = 0x00;
|
|
IOData[ PSCR_INF+3 ] = 0x00;
|
|
IOData[ PSCR_INF+4 ] = 0x02;
|
|
IOData[ PSCR_INF+5 ] = HIBYTE( FileId );
|
|
IOData[ PSCR_INF+6 ] = LOBYTE( FileId );
|
|
//
|
|
// write command
|
|
//
|
|
NTStatus = PscrWrite(
|
|
ReaderExtension,
|
|
IOData,
|
|
10,
|
|
&IOBytes
|
|
);
|
|
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
//
|
|
// get the response of the reader
|
|
//
|
|
IOBytes = 0;
|
|
NTStatus = PscrRead(
|
|
ReaderExtension,
|
|
IOData,
|
|
MAX_T1_BLOCK_SIZE,
|
|
&IOBytes
|
|
);
|
|
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
//
|
|
// check errors
|
|
//
|
|
ICCStatus =
|
|
((USHORT)IOData[ IOBytes-2-PSCR_EPILOGUE_LENGTH ]) << 8;
|
|
ICCStatus |=
|
|
(USHORT)IOData[ IOBytes-1-PSCR_EPILOGUE_LENGTH ];
|
|
|
|
if ( ICCStatus == PSCR_SW_FILE_NOT_FOUND ) {
|
|
NTStatus = STATUS_UNSUCCESSFUL;
|
|
}
|
|
}
|
|
}
|
|
return( NTStatus );
|
|
}
|
|
|
|
NTSTATUS
|
|
CmdSetInterfaceParameter(
|
|
PREADER_EXTENSION ReaderExtension,
|
|
UCHAR Device,
|
|
PUCHAR pTLVList,
|
|
UCHAR TLVListLen
|
|
)
|
|
/*++
|
|
CmdSetInterfaceParameter:
|
|
Sets the interface pareameter of the ICC interface to the values specified
|
|
in the TLV list
|
|
|
|
Arguments:
|
|
ReaderExtension context of call
|
|
Device device
|
|
pTLVList ptr to list of tag-len-value's specified by caller
|
|
TLVListLen length of list
|
|
|
|
Return Value:
|
|
STATUS_SUCCESS
|
|
STATUS_INVALID_PARAMETER
|
|
STATUS_INVALID_DEVICE_STATE
|
|
error values from PscrRead / PscrWrite
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS NTStatus = STATUS_SUCCESS;
|
|
UCHAR IOData[ MAX_T1_BLOCK_SIZE ];
|
|
USHORT ICCStatus;
|
|
ULONG IOBytes;
|
|
|
|
//
|
|
// check parameter
|
|
//
|
|
if ( pTLVList == NULL ) {
|
|
NTStatus = STATUS_INVALID_PARAMETER;
|
|
} else {
|
|
//
|
|
// build the SET INTERFACE PARAMETER command
|
|
//
|
|
IOData[ PSCR_NAD ] = NAD_TO_PSCR;
|
|
IOData[ PSCR_PCB ] = PCB_DEFAULT;
|
|
IOData[ PSCR_LEN ] = 0x05 + TLVListLen;
|
|
|
|
IOData[ PSCR_INF+0 ] = CLA_SET_INTERFACE_PARAM;
|
|
IOData[ PSCR_INF+1 ] = INS_SET_INTERFACE_PARAM;
|
|
IOData[ PSCR_INF+2 ] = Device;
|
|
IOData[ PSCR_INF+3 ] = 0x00;
|
|
IOData[ PSCR_INF+4 ] = TLVListLen;
|
|
|
|
SysCopyMemory( &IOData[ PSCR_INF+5 ], pTLVList, TLVListLen );
|
|
//
|
|
// write command
|
|
//
|
|
NTStatus = PscrWrite(
|
|
ReaderExtension,
|
|
IOData,
|
|
8 + TLVListLen,
|
|
&IOBytes
|
|
);
|
|
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
|
|
// do an dummy read to catch errors.
|
|
IOBytes = 0;
|
|
NTStatus = PscrRead(
|
|
ReaderExtension,
|
|
IOData,
|
|
MAX_T1_BLOCK_SIZE,
|
|
&IOBytes
|
|
);
|
|
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
|
|
// check error
|
|
ICCStatus =
|
|
((USHORT)IOData[ IOBytes - 2 - PSCR_EPILOGUE_LENGTH ]) << 8;
|
|
ICCStatus |=
|
|
(USHORT)IOData[ IOBytes - 1 - PSCR_EPILOGUE_LENGTH ];
|
|
|
|
if ( ICCStatus != 0x9000 ) {
|
|
NTStatus = STATUS_INVALID_DEVICE_STATE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return( NTStatus );
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
CmdReadStatusFile (
|
|
PREADER_EXTENSION ReaderExtension,
|
|
UCHAR Device,
|
|
PUCHAR pTLVList,
|
|
PULONG pTLVListLen
|
|
)
|
|
/*++
|
|
CmdReadStatusFile:
|
|
read the status file of the requested device from the reader filesystem
|
|
|
|
Arguments:
|
|
ReaderExtension context of call
|
|
Device requested device
|
|
pTLVList ptr to list (i.e. the status file)
|
|
pTLVListLen length of buffer / returned list
|
|
|
|
Return Value:
|
|
STATUS_SUCCESS
|
|
STATUS_BUFFER_TOO_SMALL
|
|
error values from PscrRead / PscrWrite
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS NTStatus = STATUS_UNSUCCESSFUL;
|
|
UCHAR IOData[ MAX_T1_BLOCK_SIZE ];
|
|
ULONG IOBytes;
|
|
|
|
// select ICC status file if it's not the active file
|
|
if ( ReaderExtension->StatusFileSelected == FALSE ) {
|
|
|
|
// select master file on reader
|
|
NTStatus = CmdSelectFile( ReaderExtension, FILE_MASTER );
|
|
|
|
// select ICC directory
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
if ( Device != DEVICE_ICC1 ) {
|
|
NTStatus = STATUS_UNSUCCESSFUL;
|
|
} else {
|
|
NTStatus = CmdSelectFile(
|
|
ReaderExtension,
|
|
FILE_ICC1_DIR
|
|
);
|
|
|
|
// select status file
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
NTStatus = CmdSelectFile(
|
|
ReaderExtension,
|
|
FILE_ICC1_DIR_STATUS
|
|
);
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
ReaderExtension->StatusFileSelected = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// read status file if successful selected
|
|
if ( ReaderExtension->StatusFileSelected == TRUE ) {
|
|
IOBytes = MAX_T1_BLOCK_SIZE;
|
|
NTStatus = CmdReadBinary(
|
|
ReaderExtension,
|
|
0,
|
|
IOData,
|
|
&IOBytes
|
|
);
|
|
|
|
// copy data to user buffer
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
if (( pTLVList != NULL ) && ( IOBytes < *pTLVListLen )) {
|
|
*pTLVListLen = IOBytes;
|
|
SysCopyMemory( pTLVList, IOData, IOBytes );
|
|
} else {
|
|
NTStatus = STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
}
|
|
}
|
|
return( NTStatus );
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
CmdGetFirmwareRevision (
|
|
PREADER_EXTENSION ReaderExtension
|
|
)
|
|
/*++
|
|
CmdGetFirmwareRevision:
|
|
get the firmware revision of the reader. Ther firmware revision is found
|
|
in the PSCR configuration file (ID 0x0020) in the master directory.
|
|
The tag of the revision is 0x0F, and the value is coded as an ASCII string,
|
|
p.E. "2.20"
|
|
|
|
Arguments:
|
|
ReaderExtension context of call
|
|
|
|
Return Value:
|
|
STATUS_SUCCESS
|
|
error values from PscrRead / PscrWrite
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS NTStatus = STATUS_SUCCESS;
|
|
UCHAR TLVList[ MAX_T1_BLOCK_SIZE ],
|
|
Len;
|
|
char Revision[ 0x10 ],
|
|
UpdateKey[ 0x10 ];
|
|
ULONG IOBytes;
|
|
//
|
|
// select master file on reader
|
|
//
|
|
NTStatus = CmdSelectFile( ReaderExtension, FILE_MASTER );
|
|
//
|
|
// select pscr configuration file
|
|
//
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
NTStatus = CmdSelectFile( ReaderExtension, FILE_PSCR_CONFIG );
|
|
//
|
|
// read confiuration file
|
|
//
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
IOBytes = MAX_T1_BLOCK_SIZE;
|
|
NTStatus = CmdReadBinary(
|
|
ReaderExtension,
|
|
0,
|
|
TLVList,
|
|
&IOBytes
|
|
);
|
|
//
|
|
// get the value of revison
|
|
//
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
Len = sizeof(Revision);
|
|
CmdGetTagValue(
|
|
TAG_SOFTWARE_REV,
|
|
TLVList,
|
|
IOBytes,
|
|
&Len,
|
|
Revision
|
|
);
|
|
//
|
|
// the coding is always X.YY (in ASCII), so we can get the numeric
|
|
// values hardcoded by taking the low nibbles of the char's.
|
|
//
|
|
ReaderExtension->FirmwareMajor = Revision[0] & 0x0F;
|
|
ReaderExtension->FirmwareMinor = ( Revision[2] & 0x0F ) << 4;
|
|
ReaderExtension->FirmwareMinor |= Revision[3] & 0x0F;
|
|
//
|
|
// get value of update key
|
|
//
|
|
Len = sizeof(UpdateKey);
|
|
CmdGetTagValue(
|
|
TAG_UPDATE_KEY,
|
|
TLVList,
|
|
IOBytes,
|
|
&Len,
|
|
UpdateKey
|
|
);
|
|
|
|
ReaderExtension->UpdateKey = UpdateKey[0];
|
|
}
|
|
}
|
|
}
|
|
ReaderExtension->StatusFileSelected = FALSE;
|
|
return( NTStatus );
|
|
}
|
|
|
|
NTSTATUS
|
|
CmdPscrCommand (
|
|
PREADER_EXTENSION ReaderExtension,
|
|
PUCHAR pInData,
|
|
ULONG InDataLen,
|
|
PUCHAR pOutData,
|
|
ULONG OutDataLen,
|
|
PULONG pNBytes
|
|
)
|
|
/*++
|
|
CmdPscrCommand:
|
|
send a command transparent to the reader
|
|
|
|
Arguments:
|
|
ReaderExtension context of call
|
|
pInData, ptr to input buffer
|
|
InDataLen, len of input buffer
|
|
pOutData, ptr to output buffer
|
|
OutDataLen, len of output buffer
|
|
pNBytes number of bytes transferred
|
|
|
|
Return Value:
|
|
STATUS_SUCCESS
|
|
STATUS_INVALID_PARAMETER
|
|
error values from PscrRead / PscrWrite
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS NTStatus = STATUS_SUCCESS;
|
|
UCHAR IOData[ MAX_T1_BLOCK_SIZE ] = { 0};
|
|
ULONG IOBytes;
|
|
//
|
|
// the function is used for generic ioctl's, so carful ALL
|
|
// parametes will be checked!
|
|
//
|
|
if ( ( pInData == NULL ) ||
|
|
( pOutData == NULL ) ||
|
|
( pNBytes == NULL ) ||
|
|
(InDataLen == 0 ) ||
|
|
(OutDataLen == 0 )
|
|
) {
|
|
NTStatus = STATUS_INVALID_PARAMETER;
|
|
} else {
|
|
IOBytes = 0;
|
|
NTStatus = PscrWriteDirect(
|
|
ReaderExtension,
|
|
pInData,
|
|
InDataLen,
|
|
&IOBytes
|
|
);
|
|
|
|
if ( NT_SUCCESS( NTStatus )) {
|
|
//
|
|
// get result. ignore all reader errors
|
|
//
|
|
IOBytes = 0;
|
|
NTStatus = PscrRead(
|
|
ReaderExtension,
|
|
IOData,
|
|
MAX_T1_BLOCK_SIZE,
|
|
&IOBytes
|
|
);
|
|
//
|
|
// tranfer data
|
|
//
|
|
if ( IOBytes > OutDataLen ) {
|
|
NTStatus = STATUS_BUFFER_TOO_SMALL;
|
|
} else {
|
|
*pNBytes = IOBytes;
|
|
SysCopyMemory( pOutData, IOData, IOBytes );
|
|
}
|
|
}
|
|
}
|
|
return( NTStatus );
|
|
}
|
|
|
|
NTSTATUS
|
|
CmdGetTagValue (
|
|
UCHAR Tag,
|
|
PUCHAR pTLVList,
|
|
ULONG TLVListLen,
|
|
PUCHAR pTagLen,
|
|
PVOID pTagVal
|
|
)
|
|
/*++
|
|
CmdGetTagValue:
|
|
scans a TLV list for the value of a user specified tag
|
|
it is assumed, the caller knows the kind of the requested
|
|
field, so only the ptr to the buffer will be checked
|
|
|
|
Arguments:
|
|
Tag requested Tag
|
|
pTLVList ptr to list
|
|
TLVListLen length of list
|
|
pTagLen ptr to length
|
|
pTagVal ptr to value
|
|
|
|
Return Value:
|
|
STATUS_SUCCESS
|
|
STATUS_UNSUCCESSFUL
|
|
STATUS_INVALID_PARAMETER
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS NTStatus = STATUS_SUCCESS;
|
|
ULONG Idx;
|
|
UCHAR maxLen = *pTagLen;
|
|
//
|
|
// step through the given list
|
|
//
|
|
if (( pTLVList != NULL ) && ( pTagVal != NULL ) && ( pTagLen != NULL )) {
|
|
//
|
|
// look for requested tag
|
|
//
|
|
Idx = 0;
|
|
while ( Idx < TLVListLen ) {
|
|
if ( pTLVList[ Idx ] == Tag ) {
|
|
//
|
|
// ASSUMED THE CALLER KNOWS KIND OF FIELD!!!
|
|
//
|
|
|
|
if (pTLVList[Idx+1] > maxLen) {
|
|
NTStatus = STATUS_UNSUCCESSFUL;
|
|
break;
|
|
}
|
|
*pTagLen = pTLVList[ Idx + 1 ];
|
|
SysCopyMemory(
|
|
pTagVal,
|
|
&pTLVList[ Idx+2 ],
|
|
pTLVList[ Idx+1 ]
|
|
);
|
|
|
|
break;
|
|
}
|
|
Idx += pTLVList[ Idx+1 ] + 2;
|
|
}
|
|
if ( Idx >= TLVListLen ) {
|
|
NTStatus = STATUS_UNSUCCESSFUL;
|
|
}
|
|
} else {
|
|
NTStatus = STATUS_INVALID_PARAMETER;
|
|
}
|
|
return( NTStatus );
|
|
}
|
|
|
|
// ------------------------------- END OF FILE -------------------------------
|