able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/smartcrd/gpr400/gprcmd.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

2247 lines
52 KiB
C
Raw Blame History

/*++
Copyright (c) 1998 Gemplus Development
Name:
gprcmd.c
Description:
This is the module which holds the calls to the readers
functions.
Environment:
Kernel Mode
Revision History:
06/04/99: (Y. Nadeau + M. Veillette)
- Code Review
12/03/99: V1.00.005 (Y. Nadeau)
- Fix Set protocol to give reader the time to process the change
18/09/98: V1.00.004 (Y. Nadeau)
- Correction for NT5 beta 3
06/05/98: V1.00.003 (P. Plouidy)
- Power management for NT5
10/02/98: V1.00.002 (P. Plouidy)
- Plug and Play for NT5
03/07/97: V1.00.001 (P. Plouidy)
- Start of development.
--*/
//
// Include section:
// - stdio.h: standards definitons.
// - ntddk.h: DDK Windows NT general definitons.
// - ntdef.h: Windows NT general definitons.
//
#include <stdio.h>
#include <ntddk.h>
#include <ntdef.h>
//
// - gprcmd.h: common definition for this module.
// - gprnt.h: public interface definition for the NT module.
// - gprelcmd.h : elementary commands profile
// - gemerror.h : Gemplus error codes
#include "gprnt.h"
#include "gprcmd.h"
#include "gprelcmd.h"
#pragma alloc_text(PAGEABLE, GprCbSetProtocol)
#pragma alloc_text(PAGEABLE, GprCbTransmit)
#pragma alloc_text(PAGEABLE, GprCbVendorIoctl)
//
// Master driver code to load in RAM
//
UCHAR MASTER_DRIVER[133]={
0xC2,0xB5,0x12,0x14,0xC6,0xFC,0x78,0x00,0x7B,0x00,0x90,0x07,0xDF,0xE0,0xD2,0xE4,
0xF0,0xEB,0xF8,0x12,0x14,0xD0,0x12,0x0D,0x9B,0x40,0x5C,0x0B,0xDC,0xF3,0xD2,0xB4,
0x90,0x07,0xDF,0xE0,0xC2,0xE4,0xF0,0x90,0x06,0xD4,0xE4,0xF5,0x15,0xF5,0x11,0xC2,
0x4D,0xA3,0x05,0x11,0x75,0x34,0x0A,0x75,0x37,0x00,0x75,0x38,0x40,0x12,0x0B,0x75,
0x20,0x20,0x3B,0xF0,0xA3,0x05,0x11,0x7B,0x01,0x12,0x0B,0x75,0x20,0x20,0x2F,0xF0,
0xA3,0x05,0x11,0x7C,0x03,0x33,0x33,0x50,0x01,0x0B,0xDC,0xFA,0x12,0x0B,0x75,0x20,
0x20,0x1C,0xF0,0xA3,0x05,0x11,0xDB,0xF4,0xE4,0x90,0x06,0xD4,0xF0,0x75,0x16,0x00,
0x75,0x15,0x00,0x12,0x14,0x15,0x22,0x74,0x0C,0x75,0x11,0x01,0x80,0xEB,0x74,0x0D,
0x75,0x11,0x01,0x80,0xE4
};
// Hard coded structure for different values of TA1.
// eg. If TA= 0x92 is to set, this array of structure can be scanned and
// for member variable TA1 = 0x92 and that values can be written to
// approptiate location.
// This is done in ConfigureTA1() function.
struct tagCfgTa1
{
BYTE TA1;
BYTE ETU1;
BYTE ETU2;
BYTE ETU1P;
} cfg_ta1[] = {
// { 0x15, 0x01, 0x01, 0x01 },
// { 0x95, 0x01, 0x01, 0x01 },
// { 0x25, 0x03, 0x02, 0x01 },
// { 0x14, 0x05, 0x03, 0x01 },
// { 0x35, 0x05, 0x03, 0x01 },
// { 0xa5, 0x04, 0x02, 0x01 },
// { 0x94, 0x07, 0x04, 0x02 },
// { 0xb5, 0x07, 0x04, 0x02 },
// { 0x24, 0x09, 0x04, 0x04 },
// { 0x45, 0x09, 0x04, 0x04 },
{ 0x13, 0x0d, 0x06, 0x09 },
{ 0x34, 0x0d, 0x06, 0x09 },
{ 0x55, 0x0d, 0x06, 0x09 },
{ 0xa4, 0x0c, 0x06, 0x08 },
{ 0xc5, 0x0c, 0x06, 0x08 },
{ 0x65, 0x10, 0x08, 0x0c },
{ 0x93, 0x11, 0x09, 0x0d },
{ 0xb4, 0x11, 0x09, 0x0d },
{ 0xd5, 0x11, 0x09, 0x0d },
{ 0x23, 0x14, 0x0a, 0x10 },
{ 0x44, 0x14, 0x0a, 0x10 },
{ 0x12, 0x1c, 0x0e, 0x15 },
{ 0x33, 0x1c, 0x0e, 0x15 },
{ 0x54, 0x1c, 0x0e, 0x15 },
{ 0xa3, 0x1c, 0x0f, 0x15 },
{ 0xc4, 0x1c, 0x0f, 0x15 },
{ 0x64, 0x24, 0x12, 0x20 },
{ 0x92, 0x26, 0x14, 0x22 },
{ 0xb3, 0x26, 0x14, 0x22 },
{ 0xd4, 0x26, 0x14, 0x22 },
{ 0x22, 0x2b, 0x16, 0x27 },
{ 0x43, 0x2b, 0x16, 0x27 },
{ 0x11, 0x3b, 0x1e, 0x37 },
{ 0x32, 0x3b, 0x1e, 0x37 },
{ 0x53, 0x3b, 0x1e, 0x37 },
// { 0x71, 0x55, 0x2b, 0x51 },
// { 0x91, 0x55, 0x2b, 0x51 },
{ 0, 0, 0, 0 }
};
USHORT ATRLen (UCHAR *ATR, USHORT MaxChar)
/*++
Routine Description :
Used to calculate the ATR length according to its content.
Arguments
ATR - string to analyze
MaxChar - Maximum number of characters to verify.
--*/
{
USHORT Len;
UCHAR T0;
UCHAR Yi;
BOOLEAN EndInterChar;
BOOLEAN TCKPresent=FALSE;
T0 = ATR[1];
Len= 2; // TS + T0
Yi= (T0 & 0xF0);
EndInterChar = FALSE;
do
{
if (Yi & 0x10)
{
Len++; //TAi
}
if (Yi & 0x20)
{
Len++; //TBi
}
if (Yi & 0x40)
{
Len++; //TCi
}
if (Yi & 0x80)
{
Yi = ATR[Len];
if((Yi & 0x0F)!=0)
{
TCKPresent=TRUE;
}
Len++; //TDi
}
else
{
EndInterChar = TRUE;
}
} while(EndInterChar == FALSE);
Len = Len + (T0 & 0x0F);
if(TCKPresent==TRUE)
{
Len = Len+1; //TCK
}
return (Len);
}
BOOLEAN NeedToSwitchWithoutPTS(
BYTE *ATR,
DWORD LengthATR
)
/*++
Routine Description :
Examine if ATR identifies a specific mode (presence of TA2).
Arguments
ATR - string to analyze
LengthATR - Length of ATR.
--*/
{
DWORD pos, len;
// ATR[1] is T0. Examine precense of TD1.
if (ATR[1] & 0x80)
{
// Find position of TD1.
pos = 2;
if (ATR[1] & 0x10)
pos++;
if (ATR[1] & 0x20)
pos++;
if (ATR[1] & 0x40)
pos++;
// Here ATR[pos] is TD1. Examine presence of TA2.
if (ATR[pos] & 0x10)
{
// To be of any interest an ATR must contains at least
// TS, T0, TA1, TD1, TA2 [+ T1 .. TK] [+ TCK]
// Find the maximum length of uninteresting ATR.
if (ATR[pos] & 0x0F)
len = 5 + (ATR[1] & 0x0F);
else
len = 4 + (ATR[1] & 0x0F); // In protocol T=0 there is no TCK.
if (LengthATR > len) // Interface bytes requires changes.
if ((ATR[pos+1] & 0x10) == 0) // TA2 asks to use interface bytes.
return TRUE;
}
}
return FALSE;
}
NTSTATUS ValidateDriver( PSMARTCARD_EXTENSION pSmartcardExtension)
/*++
Routine Description :
Validate the Master driver loaded in RAM at address 2100h
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
--*/
{
READER_EXTENSION *pReaderExt = pSmartcardExtension->ReaderExtension;
NTSTATUS lStatus = STATUS_SUCCESS;
UCHAR Vi[GPR_BUFFER_SIZE];
UCHAR To;
USHORT Lo;
UCHAR Vo[GPR_BUFFER_SIZE];
Vi[0] = 0x83; // DIR
Vi[1] = 0x21; // ADR MSB
Vi[2] = 0x00; // ADR LSB
// Output variable initialisation
Lo = GPR_BUFFER_SIZE;
To = 0x00;
Vo[0] = 0x00;
// return a NTSTATUS
lStatus = GprllTLVExchange (
pReaderExt,
VALIDATE_DRIVER_CMD,
3,
Vi,
&To,
&Lo,
Vo
);
return (lStatus);
}
NTSTATUS Update(
PSMARTCARD_EXTENSION pSmartcardExtension,
UCHAR Addr,
UCHAR Value)
/*++
Routine Description :
Write a value in RAM
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
Addr: Address in RAM
Value: Value to write
--*/
{
READER_EXTENSION *pReaderExt = pSmartcardExtension->ReaderExtension;
NTSTATUS lStatus = STATUS_SUCCESS;
UCHAR Vi[GPR_BUFFER_SIZE];
UCHAR To;
USHORT Lo;
UCHAR Vo[GPR_BUFFER_SIZE];
Vi[0]= 0x01;
Vi[1]= Addr;
Vi[2]= Value;
// Output variable initialisation
Lo = GPR_BUFFER_SIZE;
To = 0x00;
Vo[0] = 0x00;
lStatus = GprllTLVExchange(
pReaderExt,
UPDATE_CMD,
0x03,
Vi,
&To,
&Lo,
Vo
);
return (lStatus);
}
NTSTATUS UpdateORL(
PSMARTCARD_EXTENSION pSmartcardExtension,
UCHAR Addr,
UCHAR Value)
/*++
Routine Description :
Write a value in RAM with OR mask
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
--*/
{
READER_EXTENSION *pReaderExt = pSmartcardExtension->ReaderExtension;
NTSTATUS lStatus = STATUS_SUCCESS;
UCHAR Vi[GPR_BUFFER_SIZE];
UCHAR To;
USHORT Lo;
UCHAR Vo[GPR_BUFFER_SIZE];
Vi[0]= 0x02;
Vi[1]= Addr;
// Output variable initialisation
Lo = GPR_BUFFER_SIZE;
To = 0x00;
Vo[0] = 0x00;
lStatus = GprllTLVExchange(
pReaderExt,
UPDATE_CMD,
0x02,
Vi,
&To,
&Lo,
Vo
);
if (STATUS_SUCCESS != lStatus)
{
return (lStatus);
}
Vi[0]= 0x01;
Vi[1]= Addr;
Vi[2] = Vo[1] | Value;
// Output variable initialisation
Lo = GPR_BUFFER_SIZE;
To = 0x00;
Vo[0] = 0x00;
lStatus = GprllTLVExchange(
pReaderExt,
UPDATE_CMD,
0x03,
Vi,
&To,
&Lo,
Vo
);
return (lStatus);
}
NTSTATUS T0toT1( PSMARTCARD_EXTENSION pSmartcardExtension)
/*++
Routine Description :
OS patch to put the reader in T1 mode
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
--*/
{
NTSTATUS lStatus = STATUS_SUCCESS;
// Verify each update to be done
lStatus = Update(pSmartcardExtension,0x09,0x03);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
lStatus = Update(pSmartcardExtension,0x20,0x03);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
lStatus = Update(pSmartcardExtension,0x48,0x00);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
lStatus = Update(pSmartcardExtension,0x49,0x0F);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
lStatus = Update(pSmartcardExtension,0x4A,0x20);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
lStatus = Update(pSmartcardExtension,0x4B,0x0B);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
lStatus = Update(pSmartcardExtension,0x4C,0x40);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
lStatus = UpdateORL(pSmartcardExtension,0x2A,0x02);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
// Give the reader the time to process the change
GprllWait(100);
return (STATUS_SUCCESS);
}
NTSTATUS T1toT0( PSMARTCARD_EXTENSION pSmartcardExtension)
/*++
Routine Description :
OS patch to put the reader in T0 mode
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
--*/
{
READER_EXTENSION *pReaderExt = pSmartcardExtension->ReaderExtension;
NTSTATUS lStatus = STATUS_SUCCESS;
lStatus = Update(pSmartcardExtension,0x09,0x02);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
lStatus = Update(pSmartcardExtension,0x20,0x02);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
// Give the reader the time to process the change
GprllWait(100);
return (STATUS_SUCCESS);
}
NTSTATUS IccColdReset(
PSMARTCARD_EXTENSION pSmartcardExtension
)
/*++
Routine Description :
Cold reset function.
The delay between the power down & the power up is strored
in the PowerTimeout field of the READER_EXTENSION structure.
The default value is 0.
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
--*/
{
//
// Local variables:
// - pReaderExt holds the pointer to the current ReaderExtension structure
// - lStatus holds the status to return.
// - Vi Holds the input buffer of the TLV commnand.
// - To holds the Tag of the returned TLV.
// - Lo holds the Length of the buffer of the returned TLV.
// - Vo holds the Buffer of the returned TLV.
// - RespLen holds the Length of the buffer of the TLV returned by the power up command.
// - Rbuff holds the buffer of the TLV returned by the power up command.
//
READER_EXTENSION *pReaderExt = pSmartcardExtension->ReaderExtension;
NTSTATUS lStatus = STATUS_SUCCESS;
UCHAR Vi[GPR_BUFFER_SIZE];
UCHAR To;
USHORT Lo;
UCHAR Vo[GPR_BUFFER_SIZE];
USHORT RespLen;
UCHAR RespBuff[GPR_BUFFER_SIZE];
UCHAR BWTimeAdjust;
USHORT MaxChar;
// Send power on command (GprllTLVExchange: T= 20h, L = 0)
// <= response
// Output variable initialisation
RespLen = GPR_BUFFER_SIZE;
To = 0x00;
RespBuff[0] = 0x00;
lStatus = GprllTLVExchange(
pReaderExt,
OPEN_SESSION_CMD,
0x00,
Vi,
&To,
&RespLen,
RespBuff
);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
// Correct the WTX pb
// Get the value set by the reader
Vi [0]=0x02;
Vi [1]=0x4A;
// Output variable initialisation
Lo = GPR_BUFFER_SIZE;
To = 0x00;
Vo[0] = 0x00;
lStatus = GprllTLVExchange(
pReaderExt,
UPDATE_CMD,
0x02,
Vi,
&To,
&Lo,
Vo
);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
// adjust the value of the BWT
if(Vo[1] >= 0x80)
{
BWTimeAdjust = 0xff;
}
else
{
BWTimeAdjust = Vo[1] * 2;
}
lStatus = Update(pSmartcardExtension,0x4A,BWTimeAdjust);
if (lStatus == STATUS_SUCCESS)
{
// Get the ATR length from this function
MaxChar = RespLen - 1;
RespLen = ATRLen(RespBuff+1, MaxChar) + 1;
//
// Copy ATR to smart card struct (remove the reader status byte)
// The lib needs the ATR for evaluation of the card parameters
//
// Verification if Response buffer is larger than ATR buffer.
//
if (
(pSmartcardExtension->SmartcardReply.BufferSize >= (ULONG) (RespLen - 1)) &&
(sizeof(pSmartcardExtension->CardCapabilities.ATR.Buffer) >= (ULONG)(RespLen - 1))
)
{
RtlCopyMemory(
pSmartcardExtension->SmartcardReply.Buffer,
RespBuff + 1,
RespLen - 1
);
pSmartcardExtension->SmartcardReply.BufferLength = (ULONG) (RespLen - 1);
RtlCopyMemory(
pSmartcardExtension->CardCapabilities.ATR.Buffer,
pSmartcardExtension->SmartcardReply.Buffer,
pSmartcardExtension->SmartcardReply.BufferLength
);
pSmartcardExtension->CardCapabilities.ATR.Length =
(UCHAR) pSmartcardExtension->SmartcardReply.BufferLength ;
pSmartcardExtension->CardCapabilities.Protocol.Selected =
SCARD_PROTOCOL_UNDEFINED;
// Parse the ATR string in order to check if it as valid
// and to find out if the card uses invers convention
lStatus = SmartcardUpdateCardCapabilities(pSmartcardExtension);
if (lStatus == STATUS_SUCCESS)
{
RtlCopyMemory(
pSmartcardExtension->IoRequest.ReplyBuffer,
pSmartcardExtension->CardCapabilities.ATR.Buffer,
pSmartcardExtension->CardCapabilities.ATR.Length
);
*pSmartcardExtension->IoRequest.Information =
pSmartcardExtension->SmartcardReply.BufferLength;
//
// Implicite protocol and parameters selection?
// Verify if TA2 require to switch in TA1
//
if ( NeedToSwitchWithoutPTS(
pSmartcardExtension->CardCapabilities.ATR.Buffer,
pSmartcardExtension->CardCapabilities.ATR.Length) == FALSE)
{
// send reader parameters
IfdConfig(pSmartcardExtension, 0x11);
}
}
}
else
{
lStatus = STATUS_BUFFER_TOO_SMALL;
}
}
return (lStatus);
}
NTSTATUS IccPowerDown(
PSMARTCARD_EXTENSION pSmartcardExtension
)
/*++
Routine Description : ICC power down function
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
--*/
{
// Local variables:
// - pReaderExt holds the pointer to the current ReaderExtension structure
// - lStatus holds the status to return.
// - Vi Holds the input buffer of the TLV commnand.
// - To holds the Tag of the returned TLV.
// - Lo holds the Length of the buffer of the returned TLV.
// - Vo holds the Buffer of the returned TLV.
READER_EXTENSION *pReaderExt = pSmartcardExtension->ReaderExtension;
NTSTATUS lStatus = STATUS_SUCCESS;
UCHAR Vi[GPR_BUFFER_SIZE];
UCHAR To;
USHORT Lo;
UCHAR Vo[GPR_BUFFER_SIZE];
// Power down
// Output variable initialisation
Lo = GPR_BUFFER_SIZE;
To = 0x00;
Vo[0] = 0x00;
lStatus = GprllTLVExchange(
pReaderExt,
CLOSE_SESSION_CMD,
0x00,
Vi,
&To,
&Lo,
Vo
);
if (lStatus == STATUS_SUCCESS)
{
pSmartcardExtension->ReaderCapabilities.CurrentState = SCARD_SWALLOWED;
}
return (lStatus);
}
NTSTATUS IccIsoOutput(
PSMARTCARD_EXTENSION pSmartcardExtension,
const UCHAR pCommand[5],
USHORT *pRespLen,
UCHAR pRespBuff[]
)
/*++
Routine Description : This function sends an ISO OUT command to the card
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
pCommand : Iso out command to send.
pRespLen : in - maximum buffer size available
out - returned buffer length.
pRespBuff: returned buffer
--*/
{
// Local variables:
// - pReaderExt holds the pointer to the current ReaderExtension structure
// - lStatus holds the status to return.
// - Vi Holds the input buffer of the TLV commnand.
// - To holds the Tag of the returned TLV.
// - Lo holds the Length of the buffer of the returned TLV.
// - Vo holds the Buffer of the returned TLV.
READER_EXTENSION *pReaderExt = pSmartcardExtension->ReaderExtension;
NTSTATUS lStatus = STATUS_SUCCESS;
UCHAR Vi[GPR_BUFFER_SIZE]= { 0x01 };
UCHAR To;
USHORT Lo;
UCHAR Vo[GPR_BUFFER_SIZE];
// The five command bytes are added in cmd buffer.
RtlCopyMemory(Vi + 1, pCommand, 5);
// The command is send to IFD.
// Fields RespLen and RespBuff are updates
// <= sResponse
Lo = *pRespLen;
To = 0x00;
Vo[0] = 0x00;
lStatus = GprllTLVExchange(
pReaderExt,
APDU_EXCHANGE_CMD,
6,
Vi,
&To,
&Lo,
Vo
);
if (lStatus != STATUS_SUCCESS)
{
*pRespLen = 0;
}
else
{
// To correct the bug of GPR400 version 1.0
// If the response is 0xE7 then correct the response
if (
(Lo != 1) &&
(pReaderExt->OsVersion<= 0x10 )&&
(Vo[0]==0xE7)
)
{
Lo = 0x03;
}
RtlCopyMemory(pRespBuff, Vo, Lo);
*pRespLen = Lo;
}
return (lStatus);
}
NTSTATUS IccIsoInput(
PSMARTCARD_EXTENSION pSmartcardExtension,
const UCHAR pCommand[5],
const UCHAR pData[],
USHORT *pRespLen,
BYTE pRespBuff[]
)
/*++
Routine Description : This function sends an ISO IN command to the card
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
pCommand : Iso out command to send.
pData : data to send.
pRespLen : in - maximum buffer size available
out - returned buffer length.
pRespBuff: returned buffer
--*/
{
// Local variables:
// - pReaderExt holds the pointer to the current ReaderExtension structure
// - Ti holds the apdu command tag.
// - Li holds the Iso out command length.
// - Vi holds Icc ISO In command whose format is
// <DIR=0x00> <CLA> <INS> <P1> <P2> <Length> [ Data ]
// Length = Length + Dir + CLA + INS + P1 + P2
// - To holds the response tag
// - Lo holds th response buffer length.
// - Vo holds the response buffer
READER_EXTENSION *pReaderExt = pSmartcardExtension->ReaderExtension;
UCHAR Vi[GPR_BUFFER_SIZE] = { 0x00 };
UCHAR Ti = APDU_EXCHANGE_CMD;
UCHAR To;
UCHAR Vo[GPR_BUFFER_SIZE];
USHORT Li;
USHORT Lo;
NTSTATUS lStatus=STATUS_SUCCESS;
// Length of the the TLV = Length of data + 6
Li = pCommand[4]+6,
// The five command bytes are added in cmd buffer.
RtlCopyMemory(Vi + 1, pCommand, 5);
//The data field is added.
RtlCopyMemory(Vi + 6, pData, pCommand[4]);
// The command is send to IFD.
// Fields RespLen and RespBuff are updates
// <= sResponse
Lo = *pRespLen;
lStatus = GprllTLVExchange(
pReaderExt,
Ti,
Li,
Vi,
&To,
&Lo,
Vo
);
if (lStatus == STATUS_SUCCESS)
{
*pRespLen = Lo;
RtlCopyMemory(pRespBuff, Vo, Lo);
}
else
{
*pRespLen = 0;
}
return (lStatus);
}
NTSTATUS IccIsoT1(
PSMARTCARD_EXTENSION pSmartcardExtension,
const USHORT Li,
const UCHAR Vi[],
USHORT *Lo,
UCHAR Vo[]
)
/*++
Routine Description : This function sends a T=1 frame to the card
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
Li : Length of the frame to send.
Vi : frame to send.
Lo : in - maximum buffer size available
out - Length of the response buffer.
Vo : Response buffer.
--*/
{
// Local variables:
// - pReaderExt holds the pointer to the current ReaderExtension structure
// - Ti Tag in TLV structure to send.
// - To Tag in response TLV structure.
UCHAR Ti = APDU_EXCHANGE_CMD;
UCHAR To;
NTSTATUS lStatus = STATUS_SUCCESS;
READER_EXTENSION *pReaderExt = pSmartcardExtension->ReaderExtension;
To = 0x00;
// Return value for To is not needed, The function GprllTLVExchange verify that
// it corresponds to the Ti
lStatus = GprllTLVExchange(
pReaderExt,
Ti,
Li,
Vi,
&To,
Lo,
Vo
);
return (lStatus);
}
NTSTATUS IfdConfig(
PSMARTCARD_EXTENSION pSmartcardExtension,
UCHAR TA1
)
/*++
Routine Description : This function Sets the correct internal values of the reader
regarding the TA1 of the ATR.
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
--*/
{
// Local variables:
// - sResponse holds the called function responses.
// - pReaderExt holds the pointer to the current ReaderExtension structure
// - lStatus holds the status to return.
// - Vi Holds the input buffer of the TLV commnand.
// - To holds the Tag of the returned TLV.
// - Lo holds the Length of the buffer of the returned TLV.
// - Vo holds the Buffer of the returned TLV.
//
UCHAR Card_ETU1;
UCHAR Card_ETU2;
UCHAR Card_ETU1P;
UCHAR Card_TA1;
READER_EXTENSION *pReaderExt = pSmartcardExtension->ReaderExtension;
NTSTATUS lStatus = STATUS_SUCCESS;
USHORT i = 0;
// search TA1 parameters
do {
if ( TA1 == cfg_ta1[i].TA1 )
{
break;
}
i++;
} while ( cfg_ta1[i].TA1 != 0 );
if(cfg_ta1[i].TA1 != 0)
{
Card_TA1 = cfg_ta1[i].TA1;
Card_ETU1 = cfg_ta1[i].ETU1;
Card_ETU2 = cfg_ta1[i].ETU2;
Card_ETU1P= cfg_ta1[i].ETU1P;
}
else
{
// Default value 9600
Card_TA1 = 0x11;
Card_ETU1 = 0x3B;
Card_ETU2 = 0x1E;
Card_ETU1P= 0x37;
}
// Verify each update to be done
//Set the TA1
lStatus = Update(pSmartcardExtension,0x32,Card_TA1);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
//Set the Card ETU1
lStatus = Update(pSmartcardExtension,0x35,Card_ETU1);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
//Set the Card ETU2
lStatus = Update(pSmartcardExtension,0x36,Card_ETU2);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
//Set the Card ETU1 P
lStatus = Update(pSmartcardExtension,0x39,Card_ETU1P);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
//Set the Save TA1
lStatus = Update(pSmartcardExtension,0x3A,Card_TA1);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
//Set the Save ETU1
lStatus = Update(pSmartcardExtension,0x3D,Card_ETU1);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
//Set the Save ETU2
lStatus = Update(pSmartcardExtension,0x3E,Card_ETU2);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
//Set the Save ETU1 P
lStatus = Update(pSmartcardExtension,0x41,Card_ETU1P);
if (lStatus != STATUS_SUCCESS)
{
return (lStatus);
}
// Give the reader the time to process the change
GprllWait(100);
return (STATUS_SUCCESS);
}
NTSTATUS IfdCheck(
PSMARTCARD_EXTENSION pSmartcardExtension
)
/*++
Routine Description : This function performs a software reset of the GPR400 using
the Handshake register and TEST if hardware okay.
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
--*/
{
// Local variables:
// - pReaderExt holds the pointer to the current ReaderExtension structure
// - HandShakeRegister
//
READER_EXTENSION *pReaderExt = pSmartcardExtension->ReaderExtension;
UCHAR HandShakeRegister;
#if DBG
SmartcardDebug(
DEBUG_ERROR,
( "%s!IfdCheck: Enter\n",
SC_DRIVER_NAME)
);
#endif
// In the case that system reboot for Hibernate in
// Power management. The GPR400 signal a device was been remove
// but we have to request a second time to have the actual
// state of the reader.
HandShakeRegister = GprllReadRegister(pReaderExt,REGISTER_HANDSHAKE);
SmartcardDebug(
DEBUG_DRIVER,
("%s!IfdCheck: Read HandShakeRegister value:%x\n",
SC_DRIVER_NAME, HandShakeRegister)
);
//Set to 1 the Master Reset bit from Handshake register
GprllMaskHandshakeRegister(pReaderExt,0x01,1);
//Wait 10 ms
GprllWait(10);
//Reset the Master Reset bit from Handshake register
GprllMaskHandshakeRegister(pReaderExt,0x01,0);
//Wait 80 ms
GprllWait(80);
HandShakeRegister = GprllReadRegister(pReaderExt,REGISTER_HANDSHAKE);
SmartcardDebug(
DEBUG_DRIVER,
("%s!IfdCheck: Read HandShakeRegister 2nd time value:%x\n",
SC_DRIVER_NAME, HandShakeRegister)
);
if(HandShakeRegister != 0x80)
{
// Return reader IO problem
return (STATUS_IO_DEVICE_ERROR);
}
return (STATUS_SUCCESS);
}
NTSTATUS IfdReset(
PSMARTCARD_EXTENSION pSmartcardExtension
)
/*++
Routine Description : This function performs a software reset of the GPR400 using
the Handshake register.
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
--*/
{
// Local variables:
// - sResponse holds the called function responses.
// - pReaderExt holds the pointer to the current ReaderExtension structure
// - lStatus holds the status to return.
// - Vi Holds the input buffer of the TLV commnand.
// - To holds the Tag of the returned TLV.
// - Lo holds the Length of the buffer of the returned TLV.
// - Vo holds the Buffer of the returned TLV.
READER_EXTENSION *pReaderExt = pSmartcardExtension->ReaderExtension;
NTSTATUS lStatus = STATUS_SUCCESS;
UCHAR Vi[GPR_BUFFER_SIZE];
UCHAR To;
USHORT Lo;
UCHAR Vo[GPR_BUFFER_SIZE];
#if DBG
SmartcardDebug(
DEBUG_TRACE,
( "%s!IfdReset: Enter\n",
SC_DRIVER_NAME)
);
#endif
// In the case that system reboot for Hibernate in
// Power management. The GPR400 signal a device was been remove
// but we have to request a second time to have the actual
// state of the reader.
//Set to 1 the Master Reset bit from Handshake register
GprllMaskHandshakeRegister(pReaderExt,0x01,1);
//Wait 10 ms
GprllWait(10);
//Reset the Master Reset bit from Handshake register
GprllMaskHandshakeRegister(pReaderExt,0x01,0);
//Wait 80 ms
GprllWait(80);
//Read the GPR status
Vi[0] = 0x00;
Lo = GPR_BUFFER_SIZE;
lStatus = GprllTLVExchange (
pReaderExt,
CHECK_AND_STATUS_CMD,
0x01,
Vi,
&To,
&Lo,
Vo
);
#if DBG
SmartcardDebug(
DEBUG_TRACE,
( "%s!IfdReset: GprllTLVExchange status= %x\n",
SC_DRIVER_NAME, lStatus)
);
#endif
if (lStatus != STATUS_SUCCESS)
{
SmartcardDebug(
DEBUG_TRACE,
( "%s!IfdReset: GprllTLVExchange() failed! Leaving.....\n",
SC_DRIVER_NAME)
);
return (lStatus);
}
//Memorize the GPR400 version
pReaderExt->OsVersion = Vo[1];
pSmartcardExtension->VendorAttr.IfdVersion.VersionMinor =
pReaderExt->OsVersion & 0x0f;
pSmartcardExtension->VendorAttr.IfdVersion.VersionMajor =
(pReaderExt->OsVersion & 0xf0) >> 4;
SmartcardDebug(
DEBUG_TRACE,
( "%s!IfdReset: Loading Master driver...\n",
SC_DRIVER_NAME)
);
//Load the Master Driver in RAM at @2100h
Vi[0] = 0x02; // DIR
Vi[1] = 0x01 ; // ADR MSB
Vi[2] = 0x00 ; // ADR LSB
memcpy(&Vi[3], MASTER_DRIVER, sizeof(MASTER_DRIVER));
// Output variable initialisation
Lo = GPR_BUFFER_SIZE;
To = 0x00;
Vo[0] = 0x00;
lStatus = GprllTLVExchange (
pReaderExt,
LOAD_MEMORY_CMD,
sizeof(MASTER_DRIVER) + 3,
Vi,
&To,
&Lo,
Vo
);
if (lStatus != STATUS_SUCCESS)
{
SmartcardDebug(
DEBUG_TRACE,
( "%s!IfdReset: GprllTLVExchange() failed! Leaving.....\n",
SC_DRIVER_NAME)
);
return (lStatus);
}
lStatus = ValidateDriver(pSmartcardExtension);
if (lStatus != STATUS_SUCCESS)
{
SmartcardDebug(
DEBUG_TRACE,
( "%s!IfdReset: ValidateDriver() failed! Leaving.....\n",
SC_DRIVER_NAME)
);
return (lStatus);
}
return (STATUS_SUCCESS);
}
NTSTATUS IfdPowerDown(
PSMARTCARD_EXTENSION pSmartcardExtension
)
/*++
Routine Description :
This function powers down the IFD
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
--*/
{
// Local variables:
// - sResponse holds the called function responses.
// - pReaderExt holds the pointer to the current ReaderExtension structure
// - lStatus holds the status to return.
// - Vi Holds the input buffer of the TLV commnand.
// - To holds the Tag of the returned TLV.
// - Lo holds the Length of the buffer of the returned TLV.
// - Vo holds the Buffer of the returned TLV.
READER_EXTENSION *pReaderExt = pSmartcardExtension->ReaderExtension;
NTSTATUS lStatus = STATUS_SUCCESS;
UCHAR Vi[GPR_BUFFER_SIZE];
UCHAR To;
USHORT Lo;
UCHAR Vo[GPR_BUFFER_SIZE];
// Put the GPR in Power-down mode (GprllTLVExchange T=0x40, L=1 and V=0x00)
// <== response of the GprllTLVExchange
Vi[0] = 0x00;
// Output variable initialisation
Lo = GPR_BUFFER_SIZE;
To = 0x00;
Vo[0] = 0x00;
lStatus = GprllTLVExchange(
pReaderExt,
POWER_DOWN_GPR_CMD,
0x01,
Vi,
&To,
&Lo,
Vo
);
return (lStatus);
}
NTSTATUS GprCbReaderPower(
PSMARTCARD_EXTENSION SmartcardExtension
)
/*++
Routine Description :
This function is called by the Smart card library when a
IOCTL_SMARTCARD_POWER occurs.
This function provides 3 differents functionnality, depending of the minor
IOCTL value
- Cold reset (SCARD_COLD_RESET),
- Warm reset (SCARD_WARM_RESET),
- Power down (SCARD_POWER_DOWN).
Arguments
- SmartcardExtension is a pointer on the SmartCardExtension structure of
the current device.
--*/
{
NTSTATUS lStatus = STATUS_SUCCESS;
PREADER_EXTENSION pReader;
ASSERT(SmartcardExtension != NULL);
pReader = SmartcardExtension->ReaderExtension;
waitForIdleAndBlock(pReader);
switch(SmartcardExtension->MinorIoControlCode)
{
case SCARD_POWER_DOWN:
//Power down the ICC
lStatus = IccPowerDown(SmartcardExtension);
break;
case SCARD_COLD_RESET:
// Power up the ICC after a power down and a PowerTimeout waiting time.
lStatus = IccPowerDown(SmartcardExtension);
if(lStatus != STATUS_SUCCESS)
{
break;
}
// Waits for the Power Timeout to be elapsed before the reset command.
GprllWait(SmartcardExtension->ReaderExtension->PowerTimeOut);
case SCARD_WARM_RESET:
lStatus = IccColdReset(SmartcardExtension);
break;
default:
lStatus = STATUS_NOT_SUPPORTED;
}
setIdle(pReader);
return lStatus;
}
NTSTATUS GprCbTransmit(
PSMARTCARD_EXTENSION SmartcardExtension
)
/*++
Routine Description :
This function is called by the Smart card library when a
IOCTL_SMARTCARD_TRANSMIT occurs.
This function is used to transmit a command to the card.
Arguments
- SmartcardExtension is a pointer on the SmartCardExtension structure of
the current device.
--*/
{
NTSTATUS lStatus=STATUS_SUCCESS;
PUCHAR requestBuffer = SmartcardExtension->SmartcardRequest.Buffer;
PUCHAR replyBuffer = SmartcardExtension->SmartcardReply.Buffer;
PULONG requestLength = &SmartcardExtension->SmartcardRequest.BufferLength;
PULONG replyLength = &SmartcardExtension->SmartcardReply.BufferLength;
USHORT sRespLen;
UCHAR pRespBuff[GPR_BUFFER_SIZE];
PREADER_EXTENSION pReader;
PAGED_CODE();
ASSERT(SmartcardExtension != NULL);
*requestLength = 0;
sRespLen = 0;
pRespBuff[0] = 0x0;
pReader = SmartcardExtension->ReaderExtension;
waitForIdleAndBlock(pReader);
switch (SmartcardExtension->CardCapabilities.Protocol.Selected)
{
// Raw
case SCARD_PROTOCOL_RAW:
lStatus = STATUS_INVALID_DEVICE_STATE;
break;
// T=0
case SCARD_PROTOCOL_T0:
lStatus = SmartcardT0Request(SmartcardExtension);
if (lStatus != STATUS_SUCCESS)
{
setIdle(pReader);
return lStatus;
}
sRespLen = GPR_BUFFER_SIZE;
pRespBuff[0] = 0x0;
if (SmartcardExtension->T0.Le > 0)
{
// ISO OUT command if BufferLength = 5
lStatus = IccIsoOutput(
SmartcardExtension,
( UCHAR *) SmartcardExtension->SmartcardRequest.Buffer,
&sRespLen,
pRespBuff
);
}
else
{
// ISO IN command if BufferLength >5 or BufferLength = 4
lStatus = IccIsoInput(
SmartcardExtension,
( UCHAR *) SmartcardExtension->SmartcardRequest.Buffer,
( UCHAR *) SmartcardExtension->SmartcardRequest.Buffer+5,
&sRespLen,
pRespBuff
);
}
if (lStatus != STATUS_SUCCESS)
{
setIdle(pReader);
return lStatus;
}
// Copy the response command without the reader status
// Verify if the buffer is large enough
if (SmartcardExtension->SmartcardReply.BufferSize >= (ULONG)(sRespLen - 1))
{
RtlCopyMemory(
SmartcardExtension->SmartcardReply.Buffer,
pRespBuff + 1,
sRespLen - 1);
SmartcardExtension->SmartcardReply.BufferLength =
(ULONG) (sRespLen - 1);
}
else
{
// SmartcardT0Reply must be called; prepare this call.
SmartcardExtension->SmartcardReply.BufferLength = 0;
}
lStatus = SmartcardT0Reply(SmartcardExtension);
break;
// T=1
case SCARD_PROTOCOL_T1:
do
{
SmartcardExtension->SmartcardRequest.BufferLength = 0;
lStatus = SmartcardT1Request(SmartcardExtension);
if(lStatus != STATUS_SUCCESS)
{
setIdle(pReader);
return lStatus;
}
sRespLen = GPR_BUFFER_SIZE;
pRespBuff[0] = 0x0;
lStatus = IccIsoT1(
SmartcardExtension,
(USHORT) SmartcardExtension->SmartcardRequest.BufferLength,
(UCHAR *) SmartcardExtension->SmartcardRequest.Buffer,
&sRespLen,
pRespBuff);
if(lStatus != STATUS_SUCCESS)
{
// do not try to access the reader anymore.
if(lStatus == STATUS_DEVICE_REMOVED)
{
setIdle(pReader);
return lStatus;
}
// Let the SmartcardT1Reply determine the status
sRespLen = 1;
}
// Copy the response of the reader in the reply buffer
// Remove the status of the reader
// Verify if the buffer is large enough
if (SmartcardExtension->SmartcardReply.BufferSize >= (ULONG)(sRespLen - 1))
{
RtlCopyMemory(
SmartcardExtension->SmartcardReply.Buffer,
pRespBuff + 1 ,
sRespLen - 1
);
SmartcardExtension->SmartcardReply.BufferLength =
(ULONG) sRespLen - 1;
}
else
{
// SmartcardT1Reply must be called; prepare this call.
SmartcardExtension->SmartcardReply.BufferLength = 0;
}
lStatus = SmartcardT1Reply(SmartcardExtension);
} while(lStatus == STATUS_MORE_PROCESSING_REQUIRED);
break;
default:
lStatus = STATUS_INVALID_DEVICE_REQUEST;
break;
}
setIdle(pReader);
return lStatus;
}
NTSTATUS GprCbSetProtocol(
PSMARTCARD_EXTENSION SmartcardExtension
)
/*++
Routine Description :
This function is called by the Smart card library when a
IOCTL_SMARTCARD_SET_PROTOCOL occurs.
The minor IOCTL value holds the protocol to set.
Arguments
- SmartcardExtension is a pointer on the SmartCardExtension structure of
the current device.
--*/
{
NTSTATUS lStatus=STATUS_SUCCESS;
UCHAR Vi[GPR_BUFFER_SIZE];
UCHAR To;
USHORT Lo;
UCHAR Vo[GPR_BUFFER_SIZE];
READER_EXTENSION *pReaderExt = SmartcardExtension->ReaderExtension;
UCHAR PTS0=0;
UCHAR Value = 0;
PREADER_EXTENSION pReader;
PAGED_CODE();
ASSERT(SmartcardExtension != NULL);
pReader = SmartcardExtension->ReaderExtension;
waitForIdleAndBlock(pReader);
// Check if the card is already in specific state
// and if the caller wants to have the already selected protocol.
// We return success if this is the case.
//
*SmartcardExtension->IoRequest.Information = 0x00;
if ( SmartcardExtension->ReaderCapabilities.CurrentState == SCARD_SPECIFIC &&
( SmartcardExtension->CardCapabilities.Protocol.Selected &
SmartcardExtension->MinorIoControlCode
)
)
{
lStatus = STATUS_SUCCESS;
}
else
{
__try
{
if (SmartcardExtension->CardCapabilities.Protocol.Supported &
SmartcardExtension->MinorIoControlCode &
SCARD_PROTOCOL_T1)
{
// select T=1
SmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_T1;
PTS0= 0x11;
}
else if (SmartcardExtension->CardCapabilities.Protocol.Supported &
SmartcardExtension->MinorIoControlCode &
SCARD_PROTOCOL_T0)
{
// select T=0
SmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_T0;
PTS0 = 0x10;
}
else
{
lStatus = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
// Send the PTS function
Vi[0] = 0xFF;
Vi[1] = PTS0;
Vi[2] = SmartcardExtension->CardCapabilities.PtsData.Fl <<4 |
SmartcardExtension->CardCapabilities.PtsData.Dl;
Vi[3] = (0xFF ^ PTS0) ^ Vi[2];
Lo = GPR_BUFFER_SIZE;
To = 0x00;
Vo[0] = 0x00;
// Status of the PTS could be STATUS SUCCESS
// or STATUS_DEVICE_PROTOCOL_ERROR if failed.
lStatus = GprllTLVExchange(
pReaderExt,
EXEC_MEMORY_CMD,
0x04,
Vi,
&To,
&Lo,
Vo
);
#if DBG
SmartcardDebug(
DEBUG_TRACE,
( "%s!IfdReset: GprCbSetProtocol status= %x\n",
SC_DRIVER_NAME, lStatus)
);
#endif
if (lStatus != STATUS_SUCCESS)
{
__leave;
}
// reader should reply status byte of 00 or 12
// the rest is other problem with no relation with
// the PTS negociation
lStatus = STATUS_SUCCESS;
// Put the reader in the right protocol
if (SmartcardExtension->CardCapabilities.Protocol.Selected == SCARD_PROTOCOL_T1)
{
lStatus = T0toT1(SmartcardExtension);
}
else
{
lStatus = T1toT0(SmartcardExtension);
}
if (lStatus != STATUS_SUCCESS)
{
__leave;
}
lStatus = IfdConfig(SmartcardExtension, 0x11);
if (lStatus != STATUS_SUCCESS)
{
__leave;
}
}
// we change the error code to a protocol error.
__finally
{
if (lStatus != STATUS_SUCCESS &&
lStatus != STATUS_INVALID_DEVICE_REQUEST
)
{
lStatus = STATUS_DEVICE_PROTOCOL_ERROR;
}
}
}
//
// Set the reply buffer length to sizeof(ULONG).
// Check if status SUCCESS, store the selected protocol.
//
if (lStatus == STATUS_SUCCESS)
{
*SmartcardExtension->IoRequest.Information =
sizeof(SmartcardExtension->CardCapabilities.Protocol.Selected);
*( PULONG) SmartcardExtension->IoRequest.ReplyBuffer =
SmartcardExtension->CardCapabilities.Protocol.Selected;
SmartcardExtension->ReaderCapabilities.CurrentState = SCARD_SPECIFIC;
}
else
{
SmartcardExtension->CardCapabilities.Protocol.Selected =
SCARD_PROTOCOL_UNDEFINED;
*SmartcardExtension->IoRequest.Information = 0;
}
setIdle(pReader);
return lStatus;
}
NTSTATUS AskForCardPresence(
PSMARTCARD_EXTENSION pSmartcardExtension
)
/*++
Routine Description :
This functions send a TLV command to the reader to know if there
is a card inserted.
The function does not wait to the answer. The treatment of the
answer is done in the interrupt routine.
Arguments
pSmartcardExtension: Pointer to the SmartcardExtension structure.
--*/
{
// Local variables:
// - pReaderExt holds the pointer to the current ReaderExtension structure
// - V holds the value for the TLV comand.
READER_EXTENSION *pReaderExt = pSmartcardExtension->ReaderExtension;
UCHAR V=0x02;
GprllSendCmd(pReaderExt,CHECK_AND_STATUS_CMD,1,&V);
return (STATUS_SUCCESS);
}
NTSTATUS SpecificTag(
PSMARTCARD_EXTENSION SmartcardExtension,
DWORD IoControlCode,
DWORD BufferInLen,
BYTE *BufferIn,
DWORD BufferOutLen,
BYTE *BufferOut,
DWORD *LengthOut
)
/*++
Routine Description :
This function is called when a specific Tag request occurs.
Arguments
- SmartcardExtension is a pointer on the SmartCardExtension structure of
the current device.
- IoControlCode holds the IOCTL value.
--*/
{
ULONG TagValue;
PREADER_EXTENSION pReaderExtension = SmartcardExtension->ReaderExtension;
//Set the reply buffer length to 0.
*LengthOut = 0;
//Verify the length of the Tag
//<== STATUS_BUFFER_TOO_SMALL
if (BufferInLen < (DWORD) sizeof(TagValue))
{
return(STATUS_BUFFER_TOO_SMALL);
}
TagValue = (ULONG) *((PULONG)BufferIn);
//Switch for the different IOCTL:
//Get the value of one tag (IOCTL_SMARTCARD_VENDOR_GET_ATTRIBUTE)
//Switch for the different Tags:
switch(IoControlCode)
{
case IOCTL_SMARTCARD_VENDOR_GET_ATTRIBUTE:
switch (TagValue)
{
// Power Timeout (SCARD_ATTR_SPEC_POWER_TIMEOUT)
// Verify the length of the output buffer.
// <== STATUS_BUFFER_TOO_SMALL
// Update the output buffer and the length.
// <== STATUS_SUCCESS
case SCARD_ATTR_SPEC_POWER_TIMEOUT:
if ( BufferOutLen < (DWORD) sizeof(pReaderExtension->PowerTimeOut))
{
return(STATUS_BUFFER_TOO_SMALL);
}
ASSERT(BufferOut != 0);
memcpy(
BufferOut,
&pReaderExtension->PowerTimeOut,
sizeof(pReaderExtension->PowerTimeOut)
);
*(LengthOut) =
(ULONG) sizeof(pReaderExtension->PowerTimeOut);
return STATUS_SUCCESS;
break;
// Command Timeout (SCARD_ATTR_SPEC_CMD_TIMEOUT)
// Verify the length of the output buffer.
// <== STATUS_BUFFER_TOO_SMALL
// Update the output buffer and the length.
// <== STATUS_SUCCESS
case SCARD_ATTR_SPEC_CMD_TIMEOUT:
if (BufferOutLen < (DWORD) sizeof(pReaderExtension->CmdTimeOut))
{
return(STATUS_BUFFER_TOO_SMALL);
}
ASSERT(BufferOut != 0);
memcpy(
BufferOut,
&pReaderExtension->CmdTimeOut,
sizeof(pReaderExtension->CmdTimeOut)
);
*(LengthOut) =
(ULONG) sizeof(pReaderExtension->CmdTimeOut);
return STATUS_SUCCESS;
break;
case SCARD_ATTR_MANUFACTURER_NAME:
if (BufferOutLen < ATTR_LENGTH)
{
return STATUS_BUFFER_TOO_SMALL;
}
// Copy the string of the Manufacturer Name
memcpy(
BufferOut,
ATTR_MANUFACTURER_NAME,
sizeof(ATTR_MANUFACTURER_NAME)
);
*(LengthOut) = (ULONG)sizeof(ATTR_MANUFACTURER_NAME);
return STATUS_SUCCESS;
break;
case SCARD_ATTR_ORIGINAL_FILENAME:
if (BufferOutLen < ATTR_LENGTH)
{
return STATUS_BUFFER_TOO_SMALL;
}
// Copy the string of the Original file name of the current driver
memcpy(
BufferOut,
ATTR_ORIGINAL_FILENAME,
sizeof(ATTR_ORIGINAL_FILENAME)
);
*(LengthOut) = (ULONG)sizeof(ATTR_ORIGINAL_FILENAME);
return STATUS_SUCCESS;
break;
// Unknown tag
// <== STATUS_NOT_SUPPORTED
default:
return STATUS_NOT_SUPPORTED;
break;
}
break;
// Set the value of one tag (IOCTL_SMARTCARD_VENDOR_SET_ATTRIBUTE)
// Switch for the different Tags:
case IOCTL_SMARTCARD_VENDOR_SET_ATTRIBUTE:
switch (TagValue)
{
// Power Timeout (SCARD_ATTR_SPEC_POWER_TIMEOUT)
// Verify the length of the input buffer.
// <== STATUS_BUFFER_TOO_SMALL
// Update the value.
// <== STATUS_SUCCESS
case SCARD_ATTR_SPEC_POWER_TIMEOUT:
if ( BufferInLen <
(DWORD) (sizeof(pReaderExtension->PowerTimeOut) +
sizeof(TagValue))
)
{
return(STATUS_BUFFER_TOO_SMALL);
}
ASSERT(BufferIn !=0);
memcpy(
&pReaderExtension->PowerTimeOut,
BufferIn + sizeof(TagValue),
sizeof(pReaderExtension->PowerTimeOut)
);
return STATUS_SUCCESS;
break;
// Command Timeout (SCARD_ATTR_SPEC_CMD_TIMEOUT)
// Verify the length of the input buffer.
// <== STATUS_BUFFER_TOO_SMALL
// Update the value.
// <== STATUS_SUCCESS
case SCARD_ATTR_SPEC_CMD_TIMEOUT:
if ( BufferInLen <
(DWORD) ( sizeof(pReaderExtension->CmdTimeOut) +
sizeof(TagValue))
)
{
return(STATUS_BUFFER_TOO_SMALL);
}
ASSERT(BufferIn != 0);
memcpy(
&pReaderExtension->CmdTimeOut,
BufferIn + sizeof(TagValue),
sizeof(pReaderExtension->CmdTimeOut)
);
return STATUS_SUCCESS;
break;
// Unknown tag
// <== STATUS_NOT_SUPPORTED
default:
return STATUS_NOT_SUPPORTED;
}
break;
default:
return STATUS_NOT_SUPPORTED;
}
}
NTSTATUS SwitchSpeed(
PSMARTCARD_EXTENSION SmartcardExtension,
ULONG BufferInLen,
PUCHAR BufferIn,
ULONG BufferOutLen,
PUCHAR BufferOut,
PULONG LengthOut
)
/*++
Routine Description:
This function is called when apps want to switch reader speed after a
proprietary switch speed (switch protocol) command has been sent to the
smart card.
Arguments:
SmartcardExtension - is a pointer on the SmartCardExtension structure of
the current device.
BufferInLen - holds the length of the input data.
BufferIn - holds the input data. TA1. If 0
BufferOutLen - holds the size of the output buffer.
BufferOut - the output buffer. Reader status code.
LengthOut - holds the length of the output data.
Return Value:
STATUS_SUCCESS - We could execute the request.
STATUS_BUFFER_TOO_SMALL - The output buffer is to small.
STATUS_NOT_SUPPORTED - We could not support the Ioctl specified.
--*/
{
NTSTATUS status;
BYTE NewTA1;
ULONG i;
ASSERT(SmartcardExtension != NULL);
*LengthOut = 0;
// Just checking if IOCTL exists.
if (BufferInLen == 0)
{
SmartcardDebug(
DEBUG_INFO,
("%s!SwitchSpeed: Just checking IOCTL.\n",
SC_DRIVER_NAME)
);
return(STATUS_SUCCESS);
}
else
{
NewTA1 = BufferIn[0];
i = 0;
// Verify if this TA1 is support by the GPR400
do {
if ( NewTA1 == cfg_ta1[i].TA1 )
{
// TA1 Found!
break;
}
i++;
} while ( cfg_ta1[i].TA1 != 0 );
}
// If 0 means TA1 not found
if(cfg_ta1[i].TA1 != 0)
{
SmartcardDebug(
DEBUG_INFO,
("%s!GDDK_0ASwitchSpeed: 0x%X\n",
SC_DRIVER_NAME, NewTA1)
);
status = IfdConfig(SmartcardExtension, NewTA1);
}
else
{
// TA1 not supported
return STATUS_NOT_SUPPORTED;
}
return status;
}
NTSTATUS GprCbVendorIoctl(
PSMARTCARD_EXTENSION SmartcardExtension
)
/*++
Routine Description :
This routine is called when a vendor IOCTL_SMARTCARD_ is send to the driver.
Arguments
- SmartcardExtension is a pointer on the SmartCardExtension structure of
the current device.
Return Value:
STATUS_SUCCESS - We could execute the request.
STATUS_BUFFER_TOO_SMALL - The output buffer is to small.
STATUS_NOT_SUPPORTED - We could not support the Ioctl specified.
--*/
{
PREADER_EXTENSION pReaderExtension = SmartcardExtension->ReaderExtension;
UCHAR To;
UCHAR Vo[GPR_BUFFER_SIZE];
USHORT Lo;
USHORT BufferInLen = 0;
NTSTATUS lStatus=STATUS_SUCCESS;
PREADER_EXTENSION pReader;
PAGED_CODE();
ASSERT(SmartcardExtension != NULL);
// Set the reply buffer length to 0.
*SmartcardExtension->IoRequest.Information = 0;
pReader = SmartcardExtension->ReaderExtension;
waitForIdleAndBlock(pReader);
//Switch for the different IOCTL:
switch(SmartcardExtension->MajorIoControlCode)
{
case IOCTL_SMARTCARD_VENDOR_GET_ATTRIBUTE:
case IOCTL_SMARTCARD_VENDOR_SET_ATTRIBUTE:
SpecificTag(
SmartcardExtension,
(ULONG) SmartcardExtension->MajorIoControlCode,
(ULONG) SmartcardExtension->IoRequest.RequestBufferLength,
(PUCHAR) SmartcardExtension->IoRequest.RequestBuffer,
(ULONG) SmartcardExtension->IoRequest.ReplyBufferLength,
(PUCHAR) SmartcardExtension->IoRequest.ReplyBuffer,
(PULONG) SmartcardExtension->IoRequest.Information
);
break;
// IOCTL_SMARTCARD_VENDOR_IFD_EXCHANGE:
// Translate the buffer to TLV and send it to the reader.
case IOCTL_SMARTCARD_VENDOR_IFD_EXCHANGE:
if(SmartcardExtension->IoRequest.ReplyBufferLength < 3)
{
setIdle(pReader);
return(STATUS_INVALID_BUFFER_SIZE);
}
BufferInLen = (SmartcardExtension->IoRequest.RequestBuffer[2]*0x100)
+ SmartcardExtension->IoRequest.RequestBuffer[1];
if( (ULONG) BufferInLen > (SmartcardExtension->IoRequest.ReplyBufferLength - 3))
{
setIdle(pReader);
return(STATUS_INVALID_BUFFER_SIZE);
}
Lo = GPR_BUFFER_SIZE;
To = 0x00;
Vo[0] = 0x00;
lStatus = GprllTLVExchange(
pReaderExtension,
(const BYTE) SmartcardExtension->IoRequest.RequestBuffer[0],
(const USHORT) BufferInLen,
(const BYTE *) &(SmartcardExtension->IoRequest.RequestBuffer[3]),
&To,
&Lo,
Vo
);
if (lStatus != STATUS_SUCCESS)
{
setIdle(pReader);
return (lStatus);
}
// Check if there is enough space in the reply buffer
if((ULONG)(Lo+3) > SmartcardExtension->IoRequest.ReplyBufferLength)
{
setIdle(pReader);
return(STATUS_INVALID_BUFFER_SIZE);
}
else
{
ASSERT(SmartcardExtension->IoRequest.ReplyBuffer != 0);
SmartcardExtension->IoRequest.ReplyBuffer[0] = To;
SmartcardExtension->IoRequest.ReplyBuffer[1] = LOBYTE(Lo);
SmartcardExtension->IoRequest.ReplyBuffer[2] = HIBYTE(Lo);
memcpy((SmartcardExtension->IoRequest.ReplyBuffer)+3,Vo,Lo);
*(SmartcardExtension->IoRequest.Information) = (DWORD) (Lo + 3);
setIdle(pReader);
return(STATUS_SUCCESS);
}
//
// For IOCTL_SMARTCARD_VENDOR_SWITCH_SPEED
// Call the SwitchSpeed function
//
case IOCTL_SMARTCARD_VENDOR_SWITCH_SPEED:
lStatus = SwitchSpeed(
SmartcardExtension,
(ULONG) SmartcardExtension->IoRequest.RequestBufferLength,
(PUCHAR) SmartcardExtension->IoRequest.RequestBuffer,
(ULONG) SmartcardExtension->IoRequest.ReplyBufferLength,
(PUCHAR) SmartcardExtension->IoRequest.ReplyBuffer,
(PULONG) SmartcardExtension->IoRequest.Information
);
break;
default:
setIdle(pReader);
return STATUS_NOT_SUPPORTED;
}
setIdle(pReader);
return lStatus;
}
NTSTATUS GprCbSetupCardTracking(
PSMARTCARD_EXTENSION SmartcardExtension
)
/*++
Routine Description:
This function is called by the Smart card library when an
IOCTL_SMARTCARD_IS_PRESENT or IOCTL_SMARTCARD_IS_ABSENT occurs.
Arguments:
SmartcardExtension - is a pointer on the SmartCardExtension structure of
the current device.
Return Value:
STATUS_PENDING - The request is in a pending mode.
--*/
{
NTSTATUS NTStatus = STATUS_PENDING;
POS_DEP_DATA pOS = NULL;
KIRQL oldIrql;
PAGED_CODE();
ASSERT(SmartcardExtension != NULL);
//
//Initialize
//
pOS = SmartcardExtension->OsData;
//
//Set cancel routine for the notification IRP.
//
IoAcquireCancelSpinLock(&oldIrql);
IoSetCancelRoutine(
pOS->NotificationIrp,
GprCancelEventWait
);
IoReleaseCancelSpinLock(oldIrql);
NTStatus = STATUS_PENDING;
return (NTStatus);
}
Reference in a new issue View git blame Copy permalink