archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/drivers/smartcrd/sccmn50m/sccmcb.c

6695 lines
192 KiB
Raw Permalink Blame History

/*****************************************************************************
@doc INT EXT
******************************************************************************
* $ProjectName: $
* $ProjectRevision: $
*-----------------------------------------------------------------------------
* $Source: z:/pr/cmbs0/sw/sccmn50m.ms/rcs/sccmcb.c $
* $Revision: 1.7 $
*-----------------------------------------------------------------------------
* $Author: WFrischauf $
*-----------------------------------------------------------------------------
* History: see EOF
*-----------------------------------------------------------------------------
*
* Copyright © 2000 OMNIKEY AG
******************************************************************************/
#include <stdio.h>
#include "sccmn50m.h"
static ULONG dataRatesSupported[] = {9600,38400};
static ULONG CLKFrequenciesSupported[] = {4000,5000};
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_CardPower(PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS status = STATUS_SUCCESS;
NTSTATUS DebugStatus = STATUS_SUCCESS;
UCHAR pbAtrBuffer[MAXIMUM_ATR_LENGTH];
UCHAR abSyncAtrBuffer[MAXIMUM_ATR_LENGTH];
ULONG ulAtrLength;
#if DBG
ULONG i;
#endif;
SmartcardDebug(
DEBUG_TRACE,
( "%s!CardPower: Enter\n",
DRIVER_NAME)
);
#if DBG
switch (pSmartcardExtension->MinorIoControlCode)
{
case SCARD_WARM_RESET:
SmartcardDebug(
DEBUG_ATR,
( "%s!SCARD_WARM_RESTART\n",
DRIVER_NAME)
);
break;
case SCARD_COLD_RESET:
SmartcardDebug(
DEBUG_ATR,
( "%s!SCARD_COLD_RESTART\n",
DRIVER_NAME)
);
break;
case SCARD_POWER_DOWN:
SmartcardDebug(
DEBUG_ATR,
( "%s!SCARD_POWER_DOWN\n",
DRIVER_NAME)
);
break;
}
#endif
//DbgBreakPoint();
switch (pSmartcardExtension->MinorIoControlCode)
{
case SCARD_WARM_RESET:
case SCARD_COLD_RESET:
status = SCCMN50M_PowerOn(pSmartcardExtension,
&ulAtrLength,
pbAtrBuffer,
sizeof(pbAtrBuffer));
if (status != STATUS_SUCCESS)
{
goto ExitReaderPower;
}
pSmartcardExtension->CardCapabilities.ATR.Length = (UCHAR)ulAtrLength;
if (pSmartcardExtension->ReaderExtension->fRawModeNecessary == FALSE)
{
// copy ATR to smart card structure
// the lib needs the ATR for evaluation of the card parameters
MemCpy(pSmartcardExtension->CardCapabilities.ATR.Buffer,
sizeof(pSmartcardExtension->CardCapabilities.ATR.Buffer),
pbAtrBuffer,
ulAtrLength);
pSmartcardExtension->CardCapabilities.ATR.Length = (UCHAR)ulAtrLength;
pSmartcardExtension->ReaderCapabilities.CurrentState = SCARD_NEGOTIABLE;
pSmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
status = SmartcardUpdateCardCapabilities(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
goto ExitReaderPower;
}
// add extra guard time value to card stop bits
pSmartcardExtension->ReaderExtension->CardManConfig.CardStopBits = (UCHAR)(pSmartcardExtension->CardCapabilities.N);
// copy ATR to user space
MemCpy(pSmartcardExtension->IoRequest.ReplyBuffer,
pSmartcardExtension->IoRequest.ReplyBufferLength,
pbAtrBuffer,
ulAtrLength);
*pSmartcardExtension->IoRequest.Information = ulAtrLength;
#if DBG
SmartcardDebug(DEBUG_ATR,
("%s!ATR : ",
DRIVER_NAME));
for (i = 0;i < ulAtrLength;i++)
{
SmartcardDebug(DEBUG_ATR,
("%2.2x ",
pSmartcardExtension->CardCapabilities.ATR.Buffer[i]));
}
SmartcardDebug(DEBUG_ATR,("\n"));
#endif
}
else
{
abSyncAtrBuffer[0] = 0x3B;
abSyncAtrBuffer[1] = 0x04;
MemCpy(&abSyncAtrBuffer[2],
sizeof(abSyncAtrBuffer)-2,
pbAtrBuffer,
ulAtrLength);
ulAtrLength += 2;
MemCpy(pSmartcardExtension->CardCapabilities.ATR.Buffer,
sizeof(pSmartcardExtension->CardCapabilities.ATR.Buffer),
abSyncAtrBuffer,
ulAtrLength);
pSmartcardExtension->CardCapabilities.ATR.Length = (UCHAR)(ulAtrLength);
pSmartcardExtension->ReaderCapabilities.CurrentState = SCARD_SPECIFIC;
pSmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_T0;
status = SmartcardUpdateCardCapabilities(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
goto ExitReaderPower;
}
SmartcardDebug(DEBUG_ATR,("ATR of synchronous smart card : %2.2x %2.2x %2.2x %2.2x\n",
pbAtrBuffer[0],pbAtrBuffer[1],pbAtrBuffer[2],pbAtrBuffer[3]));
pSmartcardExtension->ReaderExtension->SyncParameters.fCardResetRequested = TRUE;
// copy ATR to user space
MemCpy(pSmartcardExtension->IoRequest.ReplyBuffer,
pSmartcardExtension->IoRequest.ReplyBufferLength,
abSyncAtrBuffer,
ulAtrLength);
*pSmartcardExtension->IoRequest.Information = ulAtrLength;
}
break;
case SCARD_POWER_DOWN:
status = SCCMN50M_PowerOff(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
goto ExitReaderPower;
}
pSmartcardExtension->ReaderCapabilities.CurrentState = SCARD_SWALLOWED;
pSmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
break;
}
ExitReaderPower:
SmartcardDebug(
DEBUG_TRACE,
( "%s!CardPower: Exit %lx\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_PowerOn (
IN PSMARTCARD_EXTENSION pSmartcardExtension,
OUT PULONG pulAtrLength,
OUT PUCHAR pbAtrBuffer,
IN ULONG ulAtrBufferSize
)
{
NTSTATUS status;
NTSTATUS DebugStatus;
// We always use 0x80 for reset delay
pSmartcardExtension->ReaderExtension->CardManConfig.ResetDelay = 0x80;
if (SCCMN50M_IsAsynchronousSmartCard(pSmartcardExtension) == TRUE)
{
if (pSmartcardExtension->MinorIoControlCode == SCARD_COLD_RESET)
{
status = SCCMN50M_UseColdWarmResetStrategy(pSmartcardExtension,
pulAtrLength,
pbAtrBuffer,
ulAtrBufferSize,
FALSE);
// if cold reset was not succesfull ,it maybe a SAMOS card with the sensor bug
if (status != STATUS_SUCCESS)
{
status = SCCMN50M_UseColdWarmResetStrategy(pSmartcardExtension,
pulAtrLength,
pbAtrBuffer,
ulAtrBufferSize,
TRUE);
if (status != STATUS_SUCCESS)
{
status = SCCMN50M_UseParsingStrategy(pSmartcardExtension,
pulAtrLength,
pbAtrBuffer,
ulAtrBufferSize);
}
}
}
else
{
status = SCCMN50M_UseColdWarmResetStrategy(pSmartcardExtension,
pulAtrLength,
pbAtrBuffer,
ulAtrBufferSize,
TRUE);
if (status != STATUS_SUCCESS)
{
status = SCCMN50M_UseParsingStrategy(pSmartcardExtension,
pulAtrLength,
pbAtrBuffer,
ulAtrBufferSize);
}
}
}
else
{
SmartcardDebug(DEBUG_ATR,
("check if synchronous smart card is inserted\n"));
// try to find a synchronous smart card
status = SCCMN50M_UseSyncStrategy(pSmartcardExtension,
pulAtrLength,
pbAtrBuffer,
ulAtrBufferSize);
}
if (status != STATUS_SUCCESS)
{
// smart card not powered
status = STATUS_UNRECOGNIZED_MEDIA;
*pulAtrLength = 0;
DebugStatus = SCCMN50M_PowerOff(pSmartcardExtension);
return status;
}
else
{
// add extra guard time value to card stop bits
pSmartcardExtension->ReaderExtension->CardManConfig.CardStopBits = (UCHAR)(pSmartcardExtension->CardCapabilities.N);
return status;
}
}
/*****************************************************************************
Routine Description:
This routine inverts the buffer
Bit0 -> Bit 7
Bit1 -> Bit 6
Bit2 -> Bit 5
Bit3 -> Bit 4
Bit4 -> Bit 3
Bit5 -> Bit 2
Bit6 -> Bit 1
Bit7 -> Bit 0
Arguments: pbBuffer ... pointer to buffer
ulBufferSize ... size of buffer
Return Value: none
*****************************************************************************/
VOID SCCMN50M_InverseBuffer (
PUCHAR pbBuffer,
ULONG ulBufferSize
)
{
ULONG i;
ULONG j;
ULONG m;
ULONG n;
for (i=0; i<ulBufferSize; i++)
{
n = 0;
for (j=1; j<=8; j++)
{
m = (pbBuffer[i] << j);
m &= 0x00000100;
n |= (m >> (9-j));
}
pbBuffer[i] = (UCHAR)~n;
}
return;
}
/*****************************************************************************
Routine Description:
This function always permforms a cold reset of the smart card.
A SAMOS card with the sensor bug will not be powered by this function.
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_UseParsingStrategy (IN PSMARTCARD_EXTENSION pSmartcardExtension,
OUT PULONG pulAtrLength,
OUT PUCHAR pbAtrBuffer,
IN ULONG ulAtrBufferSize
)
{
NTSTATUS status;
NTSTATUS DebugStatus;
UCHAR ulCardType;
UCHAR ReadBuffer[SCARD_ATR_LENGTH];
UCHAR bAtrBytesRead[SCARD_ATR_LENGTH];
ULONG ulBytesRead;
BOOLEAN fInverseAtr = FALSE;
ULONG ulAtrBufferOffset = 0;
ULONG ulHistoricalBytes;
ULONG ulNextStepBytesToRead;
ULONG ulPrevStepBytesRead;
ULONG i;
BOOLEAN fTDxSent;
BOOLEAN fAtrParsed;
BOOLEAN fOnlyT0 = TRUE;
ULONG ulOldReadTotalTimeoutMultiplier;
// DBGBreakPoint();
// set ReadTotalTimeoutMultiplier to 250ms (9600 * 372/f = initial waiting time)
ulOldReadTotalTimeoutMultiplier = pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier;
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier = 250;
pSmartcardExtension->ReaderExtension->CardManConfig.CardStopBits = 0x02;
for (ulCardType = ASYNC3_CARD;ulCardType <= ASYNC5_CARD;ulCardType++)
{
// power off + resync
status = SCCMN50M_PowerOff(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
goto ExitUseParsingStrategy;
}
SCCMN50M_ClearCardControlFlags(pSmartcardExtension,ALL_FLAGS);
SCCMN50M_SetSCRControlFlags(pSmartcardExtension,CARD_POWER| IGNORE_PARITY);
if (ulCardType == ASYNC3_CARD)
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_3MHZ);
else
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_5MHZ);
SCCMN50M_SetCardManHeader(pSmartcardExtension,
0,
0,
0,
2); // TS and T0 expected
SmartcardDebug(DEBUG_ATR,
("%s!ResetDelay = %d\n",
DRIVER_NAME,
pSmartcardExtension->ReaderExtension->CardManConfig.ResetDelay));
// write config + header
status = SCCMN50M_WriteCardMan(pSmartcardExtension,0,NULL);
if (status != STATUS_SUCCESS)
{
goto ExitUseParsingStrategy;
}
// read state and length + TS + T0
status = SCCMN50M_ReadCardMan(pSmartcardExtension,4,&ulBytesRead,ReadBuffer,sizeof(ReadBuffer));
if (status != STATUS_SUCCESS)
{
continue; // try next card
}
// contents of read buffer
// [0] ... state
// [1] ... length
// [2] ... TS
// [3] ... T0
// TS
if (ReadBuffer[2] == CHAR_INV)
{
fInverseAtr = TRUE;
}
if (fInverseAtr)
SCCMN50M_InverseBuffer(&ReadBuffer[3],1);
ulHistoricalBytes = ReadBuffer[3] & 0x0F;
ulPrevStepBytesRead = 2;
// T0 codes following TA1 - TD1
fAtrParsed = TRUE;
SmartcardDebug(DEBUG_ATR,
("%s!Step : Bytes to read = 2\n",
DRIVER_NAME));
do
{
ulNextStepBytesToRead = ulPrevStepBytesRead;
fTDxSent = FALSE;
if (ReadBuffer[ulBytesRead - 1 ] & 0x10)
ulNextStepBytesToRead++;
if (ReadBuffer[ulBytesRead - 1 ] & 0x20)
ulNextStepBytesToRead++;
if (ReadBuffer[ulBytesRead - 1 ] & 0x40)
ulNextStepBytesToRead++;
if (ReadBuffer[ulBytesRead - 1 ] & 0x80)
{
ulNextStepBytesToRead++;
fTDxSent = TRUE;
}
if (ulPrevStepBytesRead != 2 &&
ReadBuffer[ulBytesRead -1 ] & 0x0f)
{
fOnlyT0 = FALSE;
}
// -----------------------
// POWER OFF
// -----------------------
// turn power off and get state
status = SCCMN50M_PowerOff(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
fAtrParsed = FALSE;
goto ExitUseParsingStrategy; // try next card
}
// -----------------------
// POWER ON
// -----------------------
// turn on power flag
SCCMN50M_SetSCRControlFlags(pSmartcardExtension,CARD_POWER| IGNORE_PARITY);
if (ulCardType == ASYNC3_CARD)
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_3MHZ);
else
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_5MHZ);
SCCMN50M_SetCardManHeader(pSmartcardExtension,
0,
0,
0,
(UCHAR)ulNextStepBytesToRead);
// write config + header
status = SCCMN50M_WriteCardMan(pSmartcardExtension,0,NULL);
if (status != STATUS_SUCCESS)
{
fAtrParsed = FALSE;
goto ExitUseParsingStrategy; // try next card
}
// read state and length + TAx,TBx,TCx,TDx
SmartcardDebug(DEBUG_ATR,
("%s!Step : Bytes to read = %ld\n",
DRIVER_NAME,
ulNextStepBytesToRead));
status = SCCMN50M_ReadCardMan(pSmartcardExtension,2 + ulNextStepBytesToRead,&ulBytesRead,ReadBuffer,sizeof(ReadBuffer));
if (status != STATUS_SUCCESS)
{
fAtrParsed = FALSE;
break; // try next card
}
if (fInverseAtr)
SCCMN50M_InverseBuffer(&ReadBuffer[2],ulBytesRead-2);
MemCpy(bAtrBytesRead,sizeof(bAtrBytesRead),&ReadBuffer[2],ulBytesRead -2);
#if DBG
SmartcardDebug(DEBUG_ATR,
("%s!read ATR bytes: ",
DRIVER_NAME));
for (i = 0;i < ulBytesRead-2;i++)
SmartcardDebug(DEBUG_ATR,
("%2.2x ",
bAtrBytesRead[i]));
SmartcardDebug(DEBUG_ATR,("\n"));
#endif
ulPrevStepBytesRead = ulBytesRead - 2;
} while (fTDxSent == TRUE);
// +++++++++++++++++++++++++++++++++++++++
// now we know how long the whole ATR is
// +++++++++++++++++++++++++++++++++++++++
// -----------------------
// POWER OFF
// -----------------------
// turn power off and get state
status = SCCMN50M_PowerOff(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
goto ExitUseParsingStrategy;
}
// -----------------------
// POWER ON
// -----------------------
// turn on power flag
SCCMN50M_SetSCRControlFlags(pSmartcardExtension,CARD_POWER| IGNORE_PARITY);
if (ulCardType == ASYNC3_CARD)
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_3MHZ);
else
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_5MHZ);
// bug fix : old SAMOS cards have a damaged ATR
if (bAtrBytesRead[0] == 0x3b &&
bAtrBytesRead[1] == 0xbf &&
bAtrBytesRead[2] == 0x11 &&
bAtrBytesRead[3] == 0x00 &&
bAtrBytesRead[4] == 0x81 &&
bAtrBytesRead[5] == 0x31 &&
bAtrBytesRead[6] == 0x90 &&
bAtrBytesRead[7] == 0x73 )
{
ulHistoricalBytes = 4;
}
ulNextStepBytesToRead = ulPrevStepBytesRead + ulHistoricalBytes;
if (fOnlyT0 == FALSE)
ulNextStepBytesToRead++; // TCK !
SCCMN50M_SetCardManHeader(pSmartcardExtension,
0,
0,
0,
(UCHAR)ulNextStepBytesToRead);
// write config + header
status = SCCMN50M_WriteCardMan(pSmartcardExtension,0,NULL);
if (status != STATUS_SUCCESS)
{
goto ExitUseParsingStrategy; // try next card
}
// read whole ATR
SmartcardDebug(DEBUG_ATR,
("%s!Step : Bytes to read = %ld\n",
DRIVER_NAME,
ulNextStepBytesToRead));
status = SCCMN50M_ReadCardMan(pSmartcardExtension,2+ulNextStepBytesToRead,&ulBytesRead,ReadBuffer,sizeof(ReadBuffer));
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ATR,
("%s!Reading of whole ATR failed\n !",
DRIVER_NAME));
continue; // try next card
}
// check ATR
if (ulBytesRead - 2 < MIN_ATR_LEN)
{
status = STATUS_UNRECOGNIZED_MEDIA;
DebugStatus = SCCMN50M_ReadCardMan(pSmartcardExtension,2+ulNextStepBytesToRead,&ulBytesRead,ReadBuffer,sizeof(ReadBuffer));
goto ExitUseParsingStrategy;
}
if (ulBytesRead -2 > ulAtrBufferSize)
{
// the ATR is larger then 33 bytes !!!
status = STATUS_BUFFER_OVERFLOW;
goto ExitUseParsingStrategy;
}
SCCMN50M_CheckAtrModified(pbAtrBuffer,*pulAtrLength);
// pass ATR and ATR length to calling function
MemCpy(pbAtrBuffer,ulAtrBufferSize,&ReadBuffer[2],ulBytesRead -2);
*pulAtrLength = ulBytesRead -2;
if (fInverseAtr)
{
SCCMN50M_SetCardControlFlags(pSmartcardExtension,INVERSE_DATA);
SCCMN50M_InverseBuffer(pbAtrBuffer,*pulAtrLength);
pSmartcardExtension->ReaderExtension->fInverseAtr = TRUE;
}
else
{
pSmartcardExtension->ReaderExtension->fInverseAtr = FALSE;
}
pSmartcardExtension->ReaderExtension->fRawModeNecessary = FALSE;
break;
}
ExitUseParsingStrategy:
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier
= ulOldReadTotalTimeoutMultiplier ;
SCCMN50M_ClearSCRControlFlags(pSmartcardExtension,IGNORE_PARITY);
SCCMN50M_ClearCardManHeader(pSmartcardExtension);
return status;
}
/*****************************************************************************
Routine Description:
This function performs either a cold or a warm reset depending on
the fWarmReset parameter .
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_UseColdWarmResetStrategy (IN PSMARTCARD_EXTENSION pSmartcardExtension,
OUT PULONG pulAtrLength,
OUT PUCHAR pbAtrBuffer,
IN ULONG ulAtrBufferSize,
IN BOOLEAN fWarmReset
)
{
NTSTATUS status;
NTSTATUS DebugStatus;
ULONG ulCardType;
UCHAR bReadBuffer[SCARD_ATR_LENGTH];
ULONG ulBytesRead;
ULONG ulOldReadTotalTimeoutMultiplier;
//DBGBreakPoint();
// set ReadTotalTimeoutMultiplier to 250ms (9600 * 372/f = initial waiting time)
ulOldReadTotalTimeoutMultiplier = pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier;
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier = 250;
if (fWarmReset == FALSE)
{
SCCMN50M_SetCardManHeader(pSmartcardExtension,0,0,COLD_RESET,ATR_LEN_ASYNC);
}
else
{
SCCMN50M_SetCardManHeader(pSmartcardExtension,0,0,0,ATR_LEN_ASYNC);
}
pSmartcardExtension->ReaderExtension->CardManConfig.CardStopBits = 0x02;
for (ulCardType = ASYNC3_CARD;ulCardType <= ASYNC5_CARD;ulCardType++)
{
SCCMN50M_ClearCardControlFlags(pSmartcardExtension,ALL_FLAGS);
SCCMN50M_SetSCRControlFlags(pSmartcardExtension,CARD_POWER| IGNORE_PARITY | CM2_GET_ATR);
if (ulCardType == ASYNC3_CARD)
{
SmartcardDebug(
DEBUG_ATR,
("%s!ASYNC_3\n",
DRIVER_NAME));
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_3MHZ);
}
else
{
SmartcardDebug(
DEBUG_ATR,
("%s!ASYN_5\n",
DRIVER_NAME));
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_5MHZ);
}
status = SCCMN50M_ResyncCardManII(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
goto ExitUseColdWarmResetStrategy;
}
// write config + header
status = SCCMN50M_WriteCardMan(pSmartcardExtension,0,NULL);
if (status != STATUS_SUCCESS)
{
goto ExitUseColdWarmResetStrategy;
}
pSmartcardExtension->ReaderExtension->ToRHConfig = FALSE;
// read state and length
status = SCCMN50M_ReadCardMan(pSmartcardExtension,2,&ulBytesRead,bReadBuffer,sizeof(bReadBuffer));
if (status != STATUS_SUCCESS)
{
continue; // try next card
}
if (bReadBuffer[1] < MIN_ATR_LEN)
{
// read all remaining bytes from the CardMan
DebugStatus = SCCMN50M_ReadCardMan(pSmartcardExtension,bReadBuffer[1],&ulBytesRead,bReadBuffer,sizeof(bReadBuffer));
status = STATUS_UNRECOGNIZED_MEDIA;
goto ExitUseColdWarmResetStrategy;
}
if (bReadBuffer[1] > ulAtrBufferSize)
{
status = STATUS_BUFFER_OVERFLOW;
goto ExitUseColdWarmResetStrategy;
}
// read ATR
status = SCCMN50M_ReadCardMan(pSmartcardExtension,bReadBuffer[1],pulAtrLength,pbAtrBuffer,ulAtrBufferSize);
if (status != STATUS_SUCCESS)
{
continue;
}
switch (pbAtrBuffer[0])
{
case CHAR_INV:
pSmartcardExtension->ReaderExtension->fRawModeNecessary = FALSE;
SCCMN50M_SetCardControlFlags(pSmartcardExtension,INVERSE_DATA);
SCCMN50M_InverseBuffer(pbAtrBuffer,*pulAtrLength);
pSmartcardExtension->ReaderExtension->fInverseAtr = TRUE;
break;
case CHAR_NORM:
pSmartcardExtension->ReaderExtension->fRawModeNecessary = FALSE;
pSmartcardExtension->ReaderExtension->fInverseAtr = FALSE;
break;
default :
status = STATUS_UNRECOGNIZED_MEDIA;
goto ExitUseColdWarmResetStrategy;
break;
}
// the smart card has been powered
SCCMN50M_CheckAtrModified(pbAtrBuffer,*pulAtrLength);
MemCpy(pSmartcardExtension->CardCapabilities.ATR.Buffer,
sizeof(pSmartcardExtension->CardCapabilities.ATR.Buffer),
pbAtrBuffer,
*pulAtrLength);
pSmartcardExtension->CardCapabilities.ATR.Length = (UCHAR)*pulAtrLength;
status = SmartcardUpdateCardCapabilities(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
SmartcardDebug(DEBUG_ATR,
("%s!Invalid ATR received\n",
DRIVER_NAME));
goto ExitUseColdWarmResetStrategy;
}
if (SCCMN50M_IsAtrValid(pbAtrBuffer,*pulAtrLength) == FALSE)
{
SmartcardDebug(
DEBUG_ATR,
("%s!Invalid ATR received\n",
DRIVER_NAME));
status = STATUS_UNRECOGNIZED_MEDIA;
goto ExitUseColdWarmResetStrategy;
}
break;
} // end for
ExitUseColdWarmResetStrategy:
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier
= ulOldReadTotalTimeoutMultiplier ;
SCCMN50M_ClearSCRControlFlags(pSmartcardExtension,CM2_GET_ATR | IGNORE_PARITY);
SCCMN50M_ClearCardManHeader(pSmartcardExtension);
return status;
}
/*****************************************************************************
Routine Description:
This function checks if the received ATR is valid.
Arguments:
Return Value:
*****************************************************************************/
BOOLEAN
SCCMN50M_IsAtrValid(
PUCHAR pbAtrBuffer,
ULONG ulAtrLength
)
{
BOOLEAN fAtrValid = TRUE;
ULONG ulTD1Offset = 0;
BOOLEAN fTD1Transmitted = FALSE;
BOOLEAN fOnlyT0 = FALSE;
BYTE bXor;
ULONG ulHistoricalBytes;
ULONG ulTx2Characters = 0;
ULONG i;
//DBGBreakPoint();
SmartcardDebug(
DEBUG_TRACE,
( "%s!IsAtrValid : Enter\n",
DRIVER_NAME)
);
// basic checks
if (ulAtrLength < 2 ||
(pbAtrBuffer[0] != 0x3F &&
pbAtrBuffer[0] != 0x3B ) ||
(pbAtrBuffer[1] & 0xF0) == 0x00 )
{
return FALSE;
}
if (pbAtrBuffer[1] & 0x10)
ulTD1Offset++;
if (pbAtrBuffer[1] & 0x20)
ulTD1Offset++;
if (pbAtrBuffer[1] & 0x40)
ulTD1Offset++;
ulHistoricalBytes = pbAtrBuffer[1] & 0x0F;
if (pbAtrBuffer[1] & 0x80) // TD1 in ATR ?
{
fTD1Transmitted = TRUE;
if ((pbAtrBuffer[2 + ulTD1Offset] & 0x0F) == 0x00) // T0 indicated ?
fOnlyT0 = TRUE;
}
else
{
fOnlyT0 = TRUE;
}
if (fOnlyT0 == FALSE)
{
bXor = pbAtrBuffer[1];
for (i=2;i<ulAtrLength;i++)
bXor ^= pbAtrBuffer[i];
if (bXor != 0x00)
fAtrValid = FALSE;
}
else
{
// only T0 protocol is indicated
if (fTD1Transmitted == TRUE)
{
if (pbAtrBuffer[2 + ulTD1Offset] & 0x10)
ulTx2Characters++;
if (pbAtrBuffer[2 + ulTD1Offset] & 0x20)
ulTx2Characters++;
if (pbAtrBuffer[2 + ulTD1Offset] & 0x40)
ulTx2Characters++;
if (ulAtrLength != 2 + ulTD1Offset + 1 + ulTx2Characters + ulHistoricalBytes)
fAtrValid = FALSE;
}
else
{
if (ulAtrLength != 2 + ulTD1Offset + ulHistoricalBytes)
fAtrValid = FALSE;
}
}
SmartcardDebug(
DEBUG_TRACE,
( "%s!IsAtrValid : Exit %d\n",
DRIVER_NAME,fAtrValid)
);
return fAtrValid;
}
/*****************************************************************************
Routine Description:
This function checks if the received ATR is valid.
Arguments:
Return Value:
*****************************************************************************/
VOID SCCMN50M_CheckAtrModified (
PUCHAR pbBuffer,
ULONG ulBufferSize
)
{
UCHAR bNumberHistoricalBytes;
UCHAR bXorChecksum;
ULONG i;
if (ulBufferSize < 0x09) // mininmum length of a modified ATR
return ; // ATR is ok
// variant 2
if (pbBuffer[0] == 0x3b &&
pbBuffer[1] == 0xbf &&
pbBuffer[2] == 0x11 &&
pbBuffer[3] == 0x00 &&
pbBuffer[4] == 0x81 &&
pbBuffer[5] == 0x31 &&
pbBuffer[6] == 0x90 &&
pbBuffer[7] == 0x73 &&
ulBufferSize == 13 )
{
// correct number of historical bytes
bNumberHistoricalBytes = 4;
pbBuffer[1] &= 0xf0;
pbBuffer[1] |= bNumberHistoricalBytes;
// correct checksum byte
bXorChecksum = pbBuffer[1];
for (i=2;i<ulBufferSize-1;i++)
bXorChecksum ^= pbBuffer[i];
pbBuffer[ulBufferSize -1 ] = bXorChecksum;
SmartcardDebug(DEBUG_ATR,
("%s!correcting SAMOS ATR (variant 2)\n",
DRIVER_NAME));
}
// variant 1
if (pbBuffer[0] == 0x3b &&
pbBuffer[1] == 0xb4 &&
pbBuffer[2] == 0x11 &&
pbBuffer[3] == 0x00 &&
pbBuffer[4] == 0x81 &&
pbBuffer[5] == 0x31 &&
pbBuffer[6] == 0x90 &&
pbBuffer[7] == 0x73 &&
ulBufferSize == 13 )
{
// correct checksum byte
bXorChecksum = pbBuffer[1];
for (i=2;i<ulBufferSize-1;i++)
bXorChecksum ^= pbBuffer[i];
if (pbBuffer[ulBufferSize -1 ] != bXorChecksum )
{
pbBuffer[ulBufferSize -1 ] = bXorChecksum;
SmartcardDebug(DEBUG_ATR,
("%s!correcting SAMOS ATR (variant 1)\n",
DRIVER_NAME));
}
}
// variant 3
if (pbBuffer[0] == 0x3b &&
pbBuffer[1] == 0xbf &&
pbBuffer[2] == 0x11 &&
pbBuffer[3] == 0x00 &&
pbBuffer[4] == 0x81 &&
pbBuffer[5] == 0x31 &&
pbBuffer[6] == 0x90 &&
pbBuffer[7] == 0x73 &&
ulBufferSize == 9 )
{
// correct number of historical bytes
bNumberHistoricalBytes = 0;
pbBuffer[1] &= 0xf0;
pbBuffer[1] |= bNumberHistoricalBytes;
// correct checksum byte
bXorChecksum = pbBuffer[1];
for (i=2;i<ulBufferSize-1;i++)
bXorChecksum ^= pbBuffer[i];
pbBuffer[ulBufferSize -1 ] = bXorChecksum;
SmartcardDebug(DEBUG_ATR,
("%s!correcting SAMOS ATR (variant 3)\n",
DRIVER_NAME));
}
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_PowerOff (IN PSMARTCARD_EXTENSION pSmartcardExtension )
{
NTSTATUS status;
NTSTATUS DebugStatus = STATUS_SUCCESS;
UCHAR pReadBuffer[2];
ULONG ulBytesRead;
SmartcardDebug(
DEBUG_TRACE,
( "%s!PowerOff: Enter\n",
DRIVER_NAME)
);
// SCR control bytes
SCCMN50M_ClearSCRControlFlags(pSmartcardExtension,CARD_POWER);
// card control bytes
SCCMN50M_ClearCardControlFlags(pSmartcardExtension,ALL_FLAGS);
// header
SCCMN50M_SetCardManHeader(pSmartcardExtension,0,0,0,1);
// rx length = 1 because we don't want to receive a status
// write config + header
status = SCCMN50M_WriteCardMan(pSmartcardExtension,0,NULL);
if (status != STATUS_SUCCESS)
{
goto ExitSCCMN50M_PowerOff;
}
// CardMan echoes a BRK which is recevied in the read functions
DebugStatus = SCCMN50M_ReadCardMan(pSmartcardExtension,2,&ulBytesRead,pReadBuffer,sizeof(pReadBuffer));
#if 0
if (DebugStatus != STATUS_SUCCESS)
SmartcardDebug(
DEBUG_ERROR,
( "%s!PowerOffBRK received\n",
DRIVER_NAME)
);
#endif
ExitSCCMN50M_PowerOff:
if (pSmartcardExtension->ReaderExtension->ulOldCardState == POWERED)
pSmartcardExtension->ReaderExtension->ulOldCardState = INSERTED;
SmartcardDebug(
DEBUG_TRACE,
( "%s!PowerOff: Exit %lx\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_Transmit(PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS status;
NTSTATUS DebugStatus;
switch (pSmartcardExtension->CardCapabilities.Protocol.Selected)
{
case SCARD_PROTOCOL_RAW:
status = STATUS_INVALID_DEVICE_REQUEST;
break;
case SCARD_PROTOCOL_T0:
status = SCCMN50M_TransmitT0(pSmartcardExtension);
break;
case SCARD_PROTOCOL_T1:
status = SCCMN50M_TransmitT1(pSmartcardExtension);
break;
default:
status = STATUS_INVALID_DEVICE_REQUEST;
break;
}
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_TransmitT0(PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS status;
NTSTATUS DebugStatus;
UCHAR bWriteBuffer[MIN_BUFFER_SIZE];
UCHAR bReadBuffer [MIN_BUFFER_SIZE];
ULONG ulWriteBufferOffset;
ULONG ulReadBufferOffset;
ULONG ulBytesToWrite;
ULONG ulBytesToRead;
ULONG ulBytesToWriteThisStep;
ULONG ulBytesToReadThisStep;
ULONG ulBytesStillToWrite;
ULONG ulBytesRead;
ULONG ulBytesStillToRead;
BOOLEAN fDataDirectionFromCard;
BYTE bProcedureByte;
BYTE bINS;
BOOLEAN fT0TransferToCard = FALSE;
BOOLEAN fT0TransferFromCard = FALSE;
BOOLEAN fSW1SW2Sent = FALSE;
ULONG ulReadTotalTimeoutMultiplier;
ULONG ulStatBytesRead;
BYTE abStatReadBuffer[2];
//SmartcardDebug(DEBUG_TRACE,("TransmitT0 : Enter\n"));
//
// Let the lib build a T=0 packet
//
pSmartcardExtension->SmartcardRequest.BufferLength = 0; // no bytes additionally needed
status = SmartcardT0Request(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
//
// This lib detected an error in the data to send.
//
// ------------------------------------------
// ITSEC E2 requirements: clear write buffers
// ------------------------------------------
MemSet(bWriteBuffer,
sizeof(bWriteBuffer),
'\0',
sizeof(bWriteBuffer));
MemSet(pSmartcardExtension->SmartcardRequest.Buffer,
pSmartcardExtension->SmartcardRequest.BufferSize,
'\0',
pSmartcardExtension->SmartcardRequest.BufferSize);
return status;
}
// increase timeout for T0 Transmission
ulReadTotalTimeoutMultiplier = pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier;
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier =
pSmartcardExtension->CardCapabilities.T0.WT/1000 + 1500;
// ##################################
// TRANSPARENT MODE
// ##################################
ulBytesStillToWrite = ulBytesToWrite = T0_HEADER_LEN + pSmartcardExtension->T0.Lc;
ulBytesStillToRead = ulBytesToRead = pSmartcardExtension->T0.Le;
if (pSmartcardExtension->T0.Lc)
fT0TransferToCard = TRUE;
if (pSmartcardExtension->T0.Le)
fT0TransferFromCard = TRUE;
// copy data to the write buffer
/*
SmartcardDebug(DEBUG_TRACE,("CLA = %x INS = %x P1 = %x P2 = %X L = %x\n",
pSmartcardExtension->SmartcardRequest.Buffer[0],
pSmartcardExtension->SmartcardRequest.Buffer[1],
pSmartcardExtension->SmartcardRequest.Buffer[2],
pSmartcardExtension->SmartcardRequest.Buffer[3],
pSmartcardExtension->SmartcardRequest.Buffer[4]));
*/
MemCpy(bWriteBuffer,
sizeof(bWriteBuffer),
pSmartcardExtension->SmartcardRequest.Buffer,
ulBytesToWrite);
bINS = bWriteBuffer[1];
if (pSmartcardExtension->ReaderExtension->fInverseAtr == TRUE)
{
SCCMN50M_InverseBuffer(bWriteBuffer,ulBytesToWrite);
}
status = SCCMN50M_EnterTransparentMode(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
goto ExitTransparentTransmitT0;
}
// STEP 1 : write config + header to enter transparent mode
SCCMN50M_SetCardManHeader(pSmartcardExtension,
0, // Tx control
0, // Tx length
0, // Rx control
0); // Rx length
status = SCCMN50M_WriteCardMan (pSmartcardExtension,
0,
NULL);
if (NT_ERROR(status))
{
goto ExitTransparentTransmitT0;
}
pSmartcardExtension->ReaderExtension->fTransparentMode = TRUE;
// if the inserted card uses inverse convention , we must now switch the COM port
// to odd parity
if (pSmartcardExtension->ReaderExtension->fInverseAtr == TRUE)
{
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.StopBits = STOP_BITS_2;
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.Parity = ODD_PARITY;
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.WordLength = SERIAL_DATABITS_8;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_LINE_CONTROL;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl,
sizeof(SERIAL_LINE_CONTROL));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_LINE_CONTROL);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
goto ExitTransparentTransmitT0;
}
}
ulWriteBufferOffset = 0;
ulReadBufferOffset = 0;
// STEP 2 : write CLA INS P1 P2 Lc
ulBytesToWriteThisStep = 5;
status = SCCMN50M_WriteCardMan (pSmartcardExtension,
ulBytesToWriteThisStep,
bWriteBuffer+ulWriteBufferOffset);
if (NT_ERROR(status))
{
goto ExitTransparentTransmitT0;
}
ulWriteBufferOffset += ulBytesToWriteThisStep;
ulBytesStillToWrite -= ulBytesToWriteThisStep;
// STEP 2 : read procedure byte
do
{
do
{
pSmartcardExtension->ReaderExtension->ToRHConfig= FALSE;
status = SCCMN50M_ReadCardMan(pSmartcardExtension,1,&ulBytesRead,&bProcedureByte,sizeof(bProcedureByte));
if (NT_ERROR(status))
{
goto ExitTransparentTransmitT0;
}
if (pSmartcardExtension->ReaderExtension->fInverseAtr == TRUE)
{
SCCMN50M_InverseBuffer(&bProcedureByte,ulBytesRead);
}
//SmartcardDebug(DEBUG_TRACE,("Procedure byte = %x\n",bProcedureByte));
//SmartcardDebug(DEBUG_TRACE,("waiting time = %x\n",pSmartcardExtension->CardCapabilities.T0.WT));
if (bProcedureByte == 0x60)
{
// ISO 7816-3 :
// This byte is sent by the card to reset the work waiting time and to anticipate
// a subsequent procedure byte
// => we do nothing here
}
} while (bProcedureByte == 0x60);
// check for ACK
if ((bProcedureByte & 0xFE) == (bINS & 0xFE) )
{
if (fT0TransferToCard)
{
ulBytesToWriteThisStep = ulBytesStillToWrite;
status = SCCMN50M_WriteCardMan (pSmartcardExtension,
ulBytesToWriteThisStep,
bWriteBuffer+ulWriteBufferOffset);
if (NT_ERROR(status))
{
goto ExitTransparentTransmitT0;
}
ulWriteBufferOffset += ulBytesToWriteThisStep;
ulBytesStillToWrite -= ulBytesToWriteThisStep;
}
if (fT0TransferFromCard)
{
ulBytesToReadThisStep = ulBytesStillToRead;
pSmartcardExtension->ReaderExtension->ToRHConfig= FALSE;
status = SCCMN50M_ReadCardMan(pSmartcardExtension,ulBytesToReadThisStep,&ulBytesRead,bReadBuffer + ulReadBufferOffset,sizeof(bReadBuffer)-ulReadBufferOffset);
if (NT_ERROR(status))
{
goto ExitTransparentTransmitT0;
}
if (pSmartcardExtension->ReaderExtension->fInverseAtr == TRUE)
{
SCCMN50M_InverseBuffer(bReadBuffer+ulReadBufferOffset,ulBytesRead);
}
ulReadBufferOffset += ulBytesRead;
ulBytesStillToRead -= ulBytesRead;
}
}
// check for NAK
else if ( (~bProcedureByte & 0xFE) == (bINS & 0xFE))
{
if (fT0TransferToCard)
{
ulBytesToWriteThisStep = 1;
status = SCCMN50M_WriteCardMan (pSmartcardExtension,
ulBytesToWriteThisStep,
bWriteBuffer+ulWriteBufferOffset);
if (NT_ERROR(status))
{
goto ExitTransparentTransmitT0;
}
ulWriteBufferOffset += ulBytesToWriteThisStep;
ulBytesStillToWrite -= ulBytesToWriteThisStep;
}
if (fT0TransferFromCard)
{
ulBytesToReadThisStep = 1;
pSmartcardExtension->ReaderExtension->ToRHConfig= FALSE;
status = SCCMN50M_ReadCardMan(pSmartcardExtension,ulBytesToReadThisStep,&ulBytesRead,bReadBuffer + ulReadBufferOffset,sizeof(bReadBuffer)-ulReadBufferOffset);
if (NT_ERROR(status))
{
goto ExitTransparentTransmitT0;
}
if (pSmartcardExtension->ReaderExtension->fInverseAtr == TRUE)
{
SCCMN50M_InverseBuffer(bReadBuffer+ulReadBufferOffset,ulBytesRead);
}
ulReadBufferOffset += ulBytesRead;
ulBytesStillToRead -= ulBytesRead;
}
}
// check for SW1
else if ( (bProcedureByte > 0x60 && bProcedureByte <= 0x6F) ||
(bProcedureByte >= 0x90 && bProcedureByte <= 0x9F) )
{
pSmartcardExtension->ReaderExtension->ToRHConfig= FALSE;
bReadBuffer[ulReadBufferOffset] = bProcedureByte;
ulReadBufferOffset++;
status = SCCMN50M_ReadCardMan(pSmartcardExtension,1,&ulBytesRead,bReadBuffer+ulReadBufferOffset,sizeof(bReadBuffer)-ulReadBufferOffset);
if (NT_ERROR(status))
{
goto ExitTransparentTransmitT0;
}
if (pSmartcardExtension->ReaderExtension->fInverseAtr == TRUE)
{
SCCMN50M_InverseBuffer(bReadBuffer+ulReadBufferOffset,ulBytesRead);
}
ulReadBufferOffset += ulBytesRead;
fSW1SW2Sent = TRUE;
}
else
{
status = STATUS_UNSUCCESSFUL;
goto ExitTransparentTransmitT0;
}
}while (!fSW1SW2Sent);
// copy received bytes
MemCpy(pSmartcardExtension->SmartcardReply.Buffer,
pSmartcardExtension->SmartcardReply.BufferSize,
bReadBuffer,
ulReadBufferOffset);
pSmartcardExtension->SmartcardReply.BufferLength = ulReadBufferOffset;
// let the lib copy the received bytes to the user buffer
status = SmartcardT0Reply(pSmartcardExtension);
if (NT_ERROR(status))
{
goto ExitTransparentTransmitT0;
}
ExitTransparentTransmitT0:
// ------------------------------------------
// ITSEC E2 requirements: clear write buffers
// ------------------------------------------
MemSet(bWriteBuffer,
sizeof(bWriteBuffer),
'\0',
sizeof(bWriteBuffer));
MemSet(pSmartcardExtension->SmartcardRequest.Buffer,
pSmartcardExtension->SmartcardRequest.BufferSize,
'\0',
pSmartcardExtension->SmartcardRequest.BufferSize);
DebugStatus = SCCMN50M_ExitTransparentMode(pSmartcardExtension);
pSmartcardExtension->ReaderExtension->fTransparentMode = FALSE;
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier = ulReadTotalTimeoutMultiplier;
// to be sure that the new settings take effect
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant = 250;
DebugStatus = SCCMN50M_WriteCardMan(pSmartcardExtension,0,NULL);
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant = DEFAULT_READ_TOTAL_TIMEOUT_CONSTANT;
if (NT_SUCCESS(DebugStatus))
{
DebugStatus = SCCMN50M_ReadCardMan(pSmartcardExtension,2,&ulStatBytesRead,abStatReadBuffer,sizeof(abStatReadBuffer));
}
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_TransmitT1(PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS status;
ULONG ulBytesToWrite;
UCHAR bWriteBuffer [256 + T1_HEADER_LEN + MAX_EDC_LEN];
UCHAR bReadBuffer [256 + T1_HEADER_LEN + MAX_EDC_LEN];
ULONG ulBytesRead;
ULONG ulBytesStillToRead;
/*
SmartcardDebug(
DEBUG_TRACE,
("%s!CWT = %ld(ms)\n",
DRIVER_NAME,
pSmartcardExtension->CardCapabilities.T1.CWT/1000)
);
SmartcardDebug(
DEBUG_TRACE,
("%s!BWT = %ld(ms)\n",
DRIVER_NAME,
pSmartcardExtension->CardCapabilities.T1.BWT/1000);
);
*/
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant =
pSmartcardExtension->CardCapabilities.T1.BWT/1000;
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier =
pSmartcardExtension->CardCapabilities.T1.CWT/1000;
/*
SmartcardDebug(DEBUG_TRACE,("%s!ReadTotalTimeoutConstant = %ld(ms)\n",
DRIVER_NAME,
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant));
SmartcardDebug(DEBUG_TRACE,("%s!ReadTotalTimeoutMultiplier = %ld(ms)\n",
DRIVER_NAME,
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier));
*/
// set T1 protocol flag for CardMan
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_T1);
if (pSmartcardExtension->CardCapabilities.T1.EDC == T1_CRC_CHECK)
{
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_CRC);
}
do
{
pSmartcardExtension->SmartcardRequest.BufferLength = 0; // no bytes additionally needed
status = SmartcardT1Request(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
goto ExitTransmitT1;
}
ulBytesToWrite = pSmartcardExtension->SmartcardRequest.BufferLength;
SCCMN50M_SetCardManHeader(pSmartcardExtension,
0, // Tx conrol
(UCHAR)ulBytesToWrite, // Tx length
0, // Rx control
T1_HEADER_LEN); // Rx length
if (sizeof(bWriteBuffer) < ulBytesToWrite)
{
status = STATUS_BUFFER_OVERFLOW;
goto ExitTransmitT1;
}
// copy data to the write buffer
MemCpy(bWriteBuffer,
sizeof(bWriteBuffer),
pSmartcardExtension->SmartcardRequest.Buffer,
ulBytesToWrite);
// write data to card
status = SCCMN50M_WriteCardMan (pSmartcardExtension,
ulBytesToWrite,
bWriteBuffer);
if (status == STATUS_SUCCESS)
{
// read CardMan Header
pSmartcardExtension->ReaderExtension->ToRHConfig = FALSE;
status = SCCMN50M_ReadCardMan(pSmartcardExtension,2,&ulBytesRead,bReadBuffer,sizeof(bReadBuffer));
if (status == STATUS_SUCCESS)
{
ulBytesStillToRead = bReadBuffer[1];
status = SCCMN50M_ReadCardMan(pSmartcardExtension,
ulBytesStillToRead,
&ulBytesRead,
bReadBuffer,
sizeof(bReadBuffer));
if (status == STATUS_SUCCESS)
{
if (bReadBuffer[1] == T1_WTX_REQUEST)
{
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant =
(ULONG)(1000 +((pSmartcardExtension->CardCapabilities.T1.BWT*bReadBuffer[3])/1000));
SmartcardDebug(DEBUG_PROTOCOL,("%s!ReadTotalTimeoutConstant = %ld(ms)\n",
DRIVER_NAME,
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant));
}
else
{
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant =
pSmartcardExtension->CardCapabilities.T1.BWT/1000;
SmartcardDebug(DEBUG_PROTOCOL,("%s!ReadTotalTimeoutConstant = %ld(ms)\n",
DRIVER_NAME,
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant));
}
// copy received bytes
MemCpy(pSmartcardExtension->SmartcardReply.Buffer,
pSmartcardExtension->SmartcardReply.BufferSize,
bReadBuffer,
ulBytesRead);
pSmartcardExtension->SmartcardReply.BufferLength = ulBytesRead;
}
}
}
if (status != STATUS_SUCCESS)
{
// reset serial timeout
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!reseting timeout constant\n",
DRIVER_NAME)
);
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant =
pSmartcardExtension->CardCapabilities.T1.BWT/1000;
SmartcardDebug(DEBUG_PROTOCOL,("%s!ReadTotalTimeoutConstant = %ld(ms)\n",
DRIVER_NAME,
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant));
pSmartcardExtension->SmartcardReply.BufferLength = 0L;
}
// bug fix for smclib
if (pSmartcardExtension->T1.State == T1_IFS_RESPONSE &&
pSmartcardExtension->T1.OriginalState == T1_I_BLOCK)
{
pSmartcardExtension->T1.State = T1_I_BLOCK;
}
status = SmartcardT1Reply(pSmartcardExtension);
}
while (status == STATUS_MORE_PROCESSING_REQUIRED);
ExitTransmitT1:
// ------------------------------------------
// ITSEC E2 requirements: clear write buffers
// ------------------------------------------
MemSet(bWriteBuffer,
sizeof(bWriteBuffer),
'\0',
sizeof(bWriteBuffer));
MemSet(pSmartcardExtension->SmartcardRequest.Buffer,
pSmartcardExtension->SmartcardRequest.BufferSize,
'\0',
pSmartcardExtension->SmartcardRequest.BufferSize);
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier =
DEFAULT_READ_TOTAL_TIMEOUT_MULTIPLIER;
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant =
DEFAULT_READ_TOTAL_TIMEOUT_CONSTANT;
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
SCCMN50M_InitializeSmartcardExtension(
IN PSMARTCARD_EXTENSION pSmartcardExtension,
IN ULONG ulDeviceInstance
)
{
// ==================================
// Fill the Vendor_Attr structure
// ==================================
MemCpy(pSmartcardExtension->VendorAttr.VendorName.Buffer,
sizeof(pSmartcardExtension->VendorAttr.VendorName.Buffer),
ATTR_VENDOR_NAME,
sizeof(ATTR_VENDOR_NAME)
);
//
// Length of vendor name
//
pSmartcardExtension->VendorAttr.VendorName.Length = sizeof(ATTR_VENDOR_NAME);
//
// Version number
//
pSmartcardExtension->VendorAttr.IfdVersion.BuildNumber = IFD_NT_BUILDNUMBER_CARDMAN;
pSmartcardExtension->VendorAttr.IfdVersion.VersionMinor = IFD_NT_VERSIONMINOR_CARDMAN;
pSmartcardExtension->VendorAttr.IfdVersion.VersionMajor = IFD_NT_VERSIONMAJOR_CARDMAN;
MemCpy(pSmartcardExtension->VendorAttr.IfdType.Buffer,
sizeof(pSmartcardExtension->VendorAttr.IfdType.Buffer),
ATTR_IFD_TYPE_CM,
sizeof(ATTR_IFD_TYPE_CM));
//
// Length of reader name
//
pSmartcardExtension->VendorAttr.IfdType.Length = sizeof(ATTR_IFD_TYPE_CM);
//
// Unit number which is zero based
//
pSmartcardExtension->VendorAttr.UnitNo = ulDeviceInstance;
// ================================================
// Fill the SCARD_READER_CAPABILITIES structure
// ===============================================
//
// Supported protoclols by the reader
//
pSmartcardExtension->ReaderCapabilities.SupportedProtocols = SCARD_PROTOCOL_T1 | SCARD_PROTOCOL_T0;
//
// Reader type serial, keyboard, ....
//
pSmartcardExtension->ReaderCapabilities.ReaderType = SCARD_READER_TYPE_SERIAL;
//
// Mechanical characteristics like swallows etc.
//
pSmartcardExtension->ReaderCapabilities.MechProperties = 0;
//
// Current state of the reader
//
pSmartcardExtension->ReaderCapabilities.CurrentState = SCARD_UNKNOWN;
//
// Data Rate
//
pSmartcardExtension->ReaderCapabilities.DataRate.Default =
pSmartcardExtension->ReaderCapabilities.DataRate.Max =
dataRatesSupported[0];
// reader could support higher data rates
pSmartcardExtension->ReaderCapabilities.DataRatesSupported.List =
dataRatesSupported;
pSmartcardExtension->ReaderCapabilities.DataRatesSupported.Entries =
sizeof(dataRatesSupported) / sizeof(dataRatesSupported[0]);
//
// CLKFrequency
//
pSmartcardExtension->ReaderCapabilities.CLKFrequency.Default =
pSmartcardExtension->ReaderCapabilities.CLKFrequency.Max =
CLKFrequenciesSupported[0];
pSmartcardExtension->ReaderCapabilities.CLKFrequenciesSupported.List =
CLKFrequenciesSupported;
pSmartcardExtension->ReaderCapabilities.CLKFrequenciesSupported.Entries =
sizeof(CLKFrequenciesSupported) / sizeof(CLKFrequenciesSupported[0]);
//pSmartcardExtension->ReaderCapabilities.CLKFrequency.Default = 3571; //3.571 MHz
//pSmartcardExtension->ReaderCapabilities.CLKFrequency.Max = 3571; //3.571 MHz
//
// MaxIFSD
//
pSmartcardExtension->ReaderCapabilities.MaxIFSD = ATTR_MAX_IFSD_CARDMAN_II;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
StrSet(PUCHAR Buffer,ULONG BufferSize,UCHAR Pattern)
{
ULONG i;
for (i=0;i < BufferSize;i++)
Buffer[i] = Pattern;
return;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
StrCpy(PUCHAR pszDestination,ULONG DestinationLen,PUCHAR pszSrc)
{
ULONG Len;
ULONG SrcLen;
ULONG i;
StrSet(pszDestination, DestinationLen,'\0');
SrcLen = StrLen(pszSrc);
if (DestinationLen - 1 < SrcLen)
{
Len = DestinationLen - 1;
}
else
{
Len = SrcLen;
}
for (i = 0; i < Len; i++)
{
pszDestination[i] = pszSrc[i];
if (pszSrc[i] == '\0')
break;
}
return;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
ULONG
StrLen (PUCHAR pszString)
{
ULONG Len = 0;
while ( *(pszString+Len) != '\0')
Len++;
return(Len);
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
StrCat(PUCHAR pszDestination,ULONG DestinationLen,PUCHAR pszSrc)
{
ULONG Len;
ULONG i;
ULONG SrcLen;
ULONG DestLen;
SrcLen = StrLen(pszSrc);
DestLen = StrLen(pszDestination);
if (StrLen(pszDestination)>=DestinationLen)
return;
if ((DestinationLen-DestLen-1) < SrcLen)
{
Len = DestinationLen-DestLen-1;
}
else
{
Len = SrcLen;
}
for (i=0; i < Len; i++)
{
pszDestination[DestLen+i] = pszSrc[i];
if (pszSrc[i] == '\0')
break;
}
return;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
MemSet(PUCHAR pBuffer,
ULONG ulBufferSize,
UCHAR ucPattern,
ULONG ulCount)
{
ULONG i;
for (i=0; i<ulCount;i++)
{
if (i >= ulBufferSize)
break;
pBuffer[i] = ucPattern;
}
return ;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
MemCpy(PUCHAR pDestination,
ULONG ulDestinationLen,
PUCHAR pSource,
ULONG ulCount)
{
ULONG i = 0;
while ( ulCount-- && ulDestinationLen-- )
{
pDestination[i] = pSource[i];
i++;
}
return;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
SCCMN50M_UpdateCurrentStateThread(
IN PVOID Context
)
{
PDEVICE_EXTENSION deviceExtension = Context;
PSMARTCARD_EXTENSION smartcardExtension;
NTSTATUS status;
LONG lRetry;
KIRQL oldIrql;
LONG ulFailures;
BOOLEAN fPriorityIncreased;
LONG lOldPriority;
SmartcardDebug(DEBUG_DRIVER,
("%s!UpdateCurrentStateThread started\n",DRIVER_NAME));
ulFailures = 0;
smartcardExtension = &deviceExtension->SmartcardExtension;
//
// Increase priority for first loop,
// because state of card must be known for resource manager
//
fPriorityIncreased=TRUE;
lOldPriority=KeSetPriorityThread(KeGetCurrentThread(),HIGH_PRIORITY);
do
{
KeWaitForSingleObject(&smartcardExtension->ReaderExtension->CardManIOMutex,
Executive,
KernelMode,
FALSE,
NULL);
if ( smartcardExtension->ReaderExtension->TimeToTerminateThread )
{
KeReleaseMutex(&smartcardExtension->ReaderExtension->CardManIOMutex,FALSE);
smartcardExtension->ReaderExtension->TimeToTerminateThread = FALSE;
PsTerminateSystemThread( STATUS_SUCCESS );
}
lRetry = 1;
do
{
//SmartcardDebug(DEBUG_TRACE,( "%s!*.",DRIVER_NAME));
status=SCCMN50M_UpdateCurrentState(smartcardExtension);
if (NT_SUCCESS(status))
{
break;
}
else
{
lRetry--;
}
}
while (lRetry >= 0);
if (lRetry < 0)
{
ulFailures++;
if (ulFailures == 1)
{
SmartcardDebug(
DEBUG_DRIVER,
( "%s!CardMan removed\n",
DRIVER_NAME)
);
// issue a card removal event if reader has been removed
if (smartcardExtension->ReaderExtension->ulOldCardState == INSERTED ||
smartcardExtension->ReaderExtension->ulOldCardState == POWERED )
{
SmartcardDebug(
DEBUG_DRIVER,
( "%s!issuing card removal event\n",
DRIVER_NAME)
);
SCCMN50M_CompleteCardTracking(smartcardExtension);
smartcardExtension->ReaderExtension->SyncParameters.fCardPowerRequested = TRUE;
smartcardExtension->ReaderExtension->ulNewCardState = REMOVED;
smartcardExtension->ReaderExtension->ulOldCardState = smartcardExtension->ReaderExtension->ulNewCardState;
smartcardExtension->ReaderCapabilities.CurrentState = SCARD_ABSENT;
smartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
smartcardExtension->CardCapabilities.ATR.Length = 0;
SCCMN50M_ClearCardControlFlags(smartcardExtension,ALL_FLAGS);
smartcardExtension->ReaderExtension->CardManConfig.CardStopBits = 0;
smartcardExtension->ReaderExtension->CardManConfig.ResetDelay = 0;
}
}
if (ulFailures == 3)
{
// remove the device and terminate this thread
if (KeReadStateEvent(&deviceExtension->SerialCloseDone) == 0l)
{
SmartcardDebug(
DEBUG_DRIVER,
( "%s!closing serial driver\n",
DRIVER_NAME)
);
SCCMN50M_CloseSerialDriver(smartcardExtension->OsData->DeviceObject);
KeReleaseMutex(&smartcardExtension->ReaderExtension->CardManIOMutex,FALSE);
smartcardExtension->ReaderExtension->TimeToTerminateThread = FALSE;
smartcardExtension->ReaderExtension->ThreadObjectPointer = NULL;
PsTerminateSystemThread( STATUS_SUCCESS );
}
}
}
else
{
ulFailures = 0;
}
KeReleaseMutex(&smartcardExtension->ReaderExtension->CardManIOMutex,FALSE);
if (fPriorityIncreased)
{
fPriorityIncreased=FALSE;
KeSetPriorityThread(KeGetCurrentThread(),lOldPriority);
//
// Lower ourselves down just at tad so that we compete a
// little less.
//
KeSetBasePriorityThread(KeGetCurrentThread(),-1);
}
//SmartcardDebug(DEBUG_TRACE,( "...#\n"));
Wait (smartcardExtension,500 * ms_);
}
while (TRUE);
}
NTSTATUS SCCMN50M_UpdateCurrentState(
IN PSMARTCARD_EXTENSION smartcardExtension
)
{
NTSTATUS NTStatus;
UCHAR pbReadBuffer[2];
ULONG ulBytesRead;
BOOLEAN fCardStateChanged;
fCardStateChanged = FALSE;
SCCMN50M_ClearCardManHeader(smartcardExtension);
smartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant = 250;
NTStatus = SCCMN50M_WriteCardMan(smartcardExtension,0,NULL);
smartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant = DEFAULT_READ_TOTAL_TIMEOUT_CONSTANT;
if (NT_SUCCESS(NTStatus))
{
NTStatus = SCCMN50M_ReadCardMan(smartcardExtension,2,&ulBytesRead,pbReadBuffer,sizeof(pbReadBuffer));
if (ulBytesRead == 0x02 && // two bytes must have benn received
(pbReadBuffer[0] & 0x0F) && // at least one version bit must be set
((pbReadBuffer[0] & 0x09) == 0x00)) // Bit 0 and Bit 3 must be 0
{
if ((pbReadBuffer[0] & 0x04) == 0x04 &&
(pbReadBuffer[0] & 0x02) == 0x02)
smartcardExtension->ReaderExtension->ulNewCardState = INSERTED;
if ((pbReadBuffer[0] & 0x04) == 0x00 &&
(pbReadBuffer[0] & 0x02) == 0x02)
smartcardExtension->ReaderExtension->ulNewCardState = REMOVED;
if ((pbReadBuffer[0] & 0x04) == 0x04 &&
(pbReadBuffer[0] & 0x02) == 0x00)
smartcardExtension->ReaderExtension->ulNewCardState = POWERED;
//SmartcardDebug(DEBUG_TRACE,("old %x ",smartcardExtension->ReaderExtension->ulOldCardState ));
//SmartcardDebug(DEBUG_TRACE,("new %x\n",smartcardExtension->ReaderExtension->ulNewCardState ));
if (smartcardExtension->ReaderExtension->ulNewCardState == INSERTED &&
smartcardExtension->ReaderExtension->ulOldCardState == POWERED )
{
// card has been removed and reinserted within 500ms
fCardStateChanged = TRUE;
SmartcardDebug(DEBUG_DRIVER,( "%s!Smartcard removed and reinserted\n",DRIVER_NAME));
smartcardExtension->ReaderExtension->ulOldCardState = REMOVED;
smartcardExtension->ReaderCapabilities.CurrentState = SCARD_ABSENT;
smartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
// clear any cardspecific data
smartcardExtension->CardCapabilities.ATR.Length = 0;
SCCMN50M_ClearCardControlFlags(smartcardExtension,ALL_FLAGS);
smartcardExtension->ReaderExtension->CardManConfig.CardStopBits = 0;
smartcardExtension->ReaderExtension->CardManConfig.ResetDelay = 0;
}
if (smartcardExtension->ReaderExtension->ulNewCardState == REMOVED &&
(smartcardExtension->ReaderExtension->ulOldCardState == UNKNOWN ||
smartcardExtension->ReaderExtension->ulOldCardState == INSERTED ||
smartcardExtension->ReaderExtension->ulOldCardState == POWERED ) )
{
// card has been removed
fCardStateChanged = TRUE;
SmartcardDebug(DEBUG_DRIVER,( "%s!Smartcard removed\n",DRIVER_NAME));
smartcardExtension->ReaderExtension->ulOldCardState = smartcardExtension->ReaderExtension->ulNewCardState;
smartcardExtension->ReaderCapabilities.CurrentState = SCARD_ABSENT;
smartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
// clear any cardspecific data
smartcardExtension->CardCapabilities.ATR.Length = 0;
SCCMN50M_ClearCardControlFlags(smartcardExtension,ALL_FLAGS);
smartcardExtension->ReaderExtension->CardManConfig.CardStopBits = 0;
smartcardExtension->ReaderExtension->CardManConfig.ResetDelay = 0;
}
if (smartcardExtension->ReaderExtension->ulNewCardState == INSERTED &&
(smartcardExtension->ReaderExtension->ulOldCardState == UNKNOWN ||
smartcardExtension->ReaderExtension->ulOldCardState == REMOVED ) )
{
// card has been inserted
fCardStateChanged = TRUE;
SmartcardDebug(DEBUG_DRIVER,( "%s!Smartcard inserted\n",DRIVER_NAME));
smartcardExtension->ReaderExtension->ulOldCardState = smartcardExtension->ReaderExtension->ulNewCardState;
smartcardExtension->ReaderCapabilities.CurrentState = SCARD_SWALLOWED;
smartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
}
// state after reset of the PC (only for CardMan Power+ possible)
if (smartcardExtension->ReaderExtension->ulNewCardState == POWERED &&
smartcardExtension->ReaderExtension->ulOldCardState == UNKNOWN )
{
// card has been inserted
fCardStateChanged = TRUE;
SmartcardDebug(DEBUG_DRIVER,( "%s!Smartcard inserted (and powered)\n",DRIVER_NAME));
smartcardExtension->ReaderExtension->ulOldCardState = smartcardExtension->ReaderExtension->ulNewCardState;
smartcardExtension->ReaderCapabilities.CurrentState = SCARD_SWALLOWED;
smartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
}
if (smartcardExtension->ReaderExtension->ulNewCardState == POWERED &&
smartcardExtension->ReaderExtension->ulOldCardState == INSERTED )
{
smartcardExtension->ReaderExtension->ulOldCardState = smartcardExtension->ReaderExtension->ulNewCardState;
}
// complete IOCTL_SMARTCARD_IS_ABSENT or IOCTL_SMARTCARD_IS_PRESENT
if (fCardStateChanged == TRUE &&
smartcardExtension->OsData->NotificationIrp )
{
SCCMN50M_CompleteCardTracking(smartcardExtension);
}
}
}
return NTStatus;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS Wait (PSMARTCARD_EXTENSION pSmartcardExtension,ULONG ulMilliseconds)
{
NTSTATUS status = STATUS_SUCCESS;
LARGE_INTEGER WaitTime;
WaitTime = RtlConvertLongToLargeInteger(ulMilliseconds * WAIT_MS);
KeDelayExecutionThread(KernelMode,FALSE,&WaitTime);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
SCCMN50M_SetSCRControlFlags(
IN PSMARTCARD_EXTENSION pSmartcardExtension,
IN UCHAR Flags
)
{
pSmartcardExtension->ReaderExtension->CardManConfig.SCRControl |= Flags;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
SCCMN50M_ClearSCRControlFlags(
IN PSMARTCARD_EXTENSION pSmartcardExtension,
IN UCHAR Flags
)
{
pSmartcardExtension->ReaderExtension->CardManConfig.SCRControl &= ~Flags;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
SCCMN50M_SetCardControlFlags(
IN PSMARTCARD_EXTENSION pSmartcardExtension,
IN UCHAR Flags
)
{
pSmartcardExtension->ReaderExtension->CardManConfig.CardControl |= Flags;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
SCCMN50M_ClearCardControlFlags(
IN PSMARTCARD_EXTENSION pSmartcardExtension,
IN UCHAR Flags
)
{
pSmartcardExtension->ReaderExtension->CardManConfig.CardControl &= ~Flags;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
SCCMN50M_ClearCardManHeader(
IN PSMARTCARD_EXTENSION pSmartcardExtension
)
{
pSmartcardExtension->ReaderExtension->CardManHeader.TxControl = 0x00;
pSmartcardExtension->ReaderExtension->CardManHeader.TxLength = 0x00;
pSmartcardExtension->ReaderExtension->CardManHeader.RxControl = 0x00;
pSmartcardExtension->ReaderExtension->CardManHeader.RxLength = 0x00;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
SCCMN50M_SetCardManHeader(
IN PSMARTCARD_EXTENSION pSmartcardExtension,
IN UCHAR TxControl,
IN UCHAR TxLength,
IN UCHAR RxControl,
IN UCHAR RxLength
)
{
pSmartcardExtension->ReaderExtension->CardManHeader.TxControl = TxControl;
pSmartcardExtension->ReaderExtension->CardManHeader.TxLength = TxLength;
pSmartcardExtension->ReaderExtension->CardManHeader.RxControl = RxControl;
pSmartcardExtension->ReaderExtension->CardManHeader.RxLength = RxLength;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_WriteCardMan (
IN PSMARTCARD_EXTENSION pSmartcardExtension,
IN ULONG ulBytesToWrite,
IN PUCHAR pbWriteBuffer
)
{
NTSTATUS status;
NTSTATUS DebugStatus;
PSERIAL_STATUS pSerialStatus;
// ===============================================
// Set up timeouts for following read operation
// ===============================================
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_TIMEOUTS;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts,
sizeof(SERIAL_TIMEOUTS));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_TIMEOUTS);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
/*
SmartcardDebug(DEBUG_TRACE,("ReadTotalTimeoutMultiplier = %ld\n",
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier));
SmartcardDebug(DEBUG_TRACE,("ReadTotalTimeoutConstant = %ld\n",
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant));
*/
status = SCCMN50M_SerialIo(pSmartcardExtension);
// ===============================================
// write to the CardMan
// ===============================================
DebugStatus = SCCMN50M_SetWrite(pSmartcardExtension,ulBytesToWrite,pbWriteBuffer);
// add pseudoboost (0x00) to write buffer for CardManII
if (pSmartcardExtension->ReaderExtension->fTransparentMode == FALSE )
{
pSmartcardExtension->SmartcardRequest.Buffer[pSmartcardExtension->SmartcardRequest.BufferLength] = 0x00;
pSmartcardExtension->SmartcardRequest.BufferLength++;
}
status = SCCMN50M_SerialIo(pSmartcardExtension);
// overwrite write buffer with '@'
RtlFillMemory(pSmartcardExtension->SmartcardRequest.Buffer,
pSmartcardExtension->SmartcardRequest.BufferLength,
'@');
// ===============================================
// error checking
// ===============================================
DebugStatus = SCCMN50M_GetCommStatus(pSmartcardExtension);
pSerialStatus = (PSERIAL_STATUS) pSmartcardExtension->SmartcardReply.Buffer;
if (pSerialStatus->Errors || NT_ERROR(status))
{
pSmartcardExtension->ReaderExtension->SerialErrors = pSerialStatus->Errors;
if (!pSmartcardExtension->ReaderExtension->fTransparentMode )
DebugStatus = SCCMN50M_ResyncCardManII(pSmartcardExtension);
goto ExitSCCMN50M_WriteCardMan;
}
ExitSCCMN50M_WriteCardMan:
if (status != STATUS_SUCCESS)
{
SmartcardDebug(
DEBUG_TRACE,
( "%s!WriteCardMan: Failed, exit %lx\n",
DRIVER_NAME,status)
);
}
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS SCCMN50M_ResyncCardManI (IN PSMARTCARD_EXTENSION pSmartcardExtension )
{
NTSTATUS status;
// SmartcardDebug(DEBUG_TRACE,("%s!ResyncCardManI: Enter\n",DRIVER_NAME))
// clear error flags
pSmartcardExtension->ReaderExtension->SerialErrors = 0;
// clear any pending errors
status = SCCMN50M_GetCommStatus(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_GetCommStatus failed ! status = %x\n",status))
goto ExitSCCMN50M_ResyncCardManI;
}
// clear COM buffers
status = SCCMN50M_PurgeComm(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_PurgeComm failed ! status = %x\n",status))
goto ExitSCCMN50M_ResyncCardManI;
}
// ####################################################################
// set break
if (!pSmartcardExtension->ReaderExtension->fTransparentMode)
{
status = SCCMN50M_SetBRK(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("SetBreak failed ! status = %x\n",status))
goto ExitSCCMN50M_ResyncCardManI;
}
}
// wait 1ms
Wait(pSmartcardExtension,1 * ms_);
// clear RTS
status = SCCMN50M_ClearRTS(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_ClearRTS failed ! status = %x\n",status))
goto ExitSCCMN50M_ResyncCardManI;
}
// wait 2ms
Wait(pSmartcardExtension,2 * ms_);
// set RTS
status = SCCMN50M_SetRTS(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_SetRTS failed ! status = %x\n",status))
goto ExitSCCMN50M_ResyncCardManI;
}
// wait 1ms
Wait(pSmartcardExtension,1 * ms_);
// clear break
if (!pSmartcardExtension->ReaderExtension->fTransparentMode)
{
pSmartcardExtension->ReaderExtension->BreakSet = FALSE;
status = SCCMN50M_ClearBRK(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("ClearBreak failed ! status = %x\n",status))
goto ExitSCCMN50M_ResyncCardManI;
}
}
// ####################################################################
// next write operation must send config data
pSmartcardExtension->ReaderExtension->NoConfig = FALSE;
// clear COM buffers
status = SCCMN50M_PurgeComm(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
goto ExitSCCMN50M_ResyncCardManI;
}
// clear any pending errors
status = SCCMN50M_GetCommStatus(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
goto ExitSCCMN50M_ResyncCardManI;
}
ExitSCCMN50M_ResyncCardManI:
//SmartcardDebug(DEBUG_TRACE,("%s!ResyncCardManI: Exit %lx\n",DRIVER_NAME,status))
return status;
}
NTSTATUS SCCMN50M_ResyncCardManII (IN PSMARTCARD_EXTENSION pSmartcardExtension )
{
NTSTATUS status;
SmartcardDebug(
DEBUG_TRACE,
( "%s!ResyncCardManII: Enter\n",
DRIVER_NAME)
);
// clear error flags
pSmartcardExtension->ReaderExtension->SerialErrors = 0;
// clear any pending errors
status = SCCMN50M_GetCommStatus(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_GetCommStatus failed ! status = %x\n",status))
goto ExitSCCMN50M_ResyncCardManII;
}
// clear COM buffers
status = SCCMN50M_PurgeComm(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_PurgeComm failed ! status = %x\n",status))
goto ExitSCCMN50M_ResyncCardManII;
}
// 150 * 0xFE
RtlFillMemory(pSmartcardExtension->SmartcardRequest.Buffer,150,0xFE);
pSmartcardExtension->SmartcardRequest.Buffer[150] = 0x00;
pSmartcardExtension->SmartcardRequest.BufferLength = 151;
pSmartcardExtension->SmartcardReply.BufferLength = 0;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = SMARTCARD_WRITE;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
Wait(pSmartcardExtension,2 * ms_);
// try resync once more
// clear error flags
pSmartcardExtension->ReaderExtension->SerialErrors = 0;
// clear any pending errors
status = SCCMN50M_GetCommStatus(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_GetCommStatus failed ! status = %x\n",status))
goto ExitSCCMN50M_ResyncCardManII;
}
// clear COM buffers
status = SCCMN50M_PurgeComm(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_PurgeComm failed ! status = %x\n",status))
goto ExitSCCMN50M_ResyncCardManII;
}
// 150 * 0xFE
RtlFillMemory(pSmartcardExtension->SmartcardRequest.Buffer,150,0xFE);
pSmartcardExtension->SmartcardRequest.Buffer[150] = 0x00;
pSmartcardExtension->SmartcardRequest.BufferLength = 151;
pSmartcardExtension->SmartcardReply.BufferLength = 0;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = SMARTCARD_WRITE;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_SerialIo failed ! status = %x\n",status))
goto ExitSCCMN50M_ResyncCardManII;
}
// normally the second resync command is always successful
}
// clear COM buffers
status = SCCMN50M_PurgeComm(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
goto ExitSCCMN50M_ResyncCardManII;
}
// clear any pending errors
status = SCCMN50M_GetCommStatus(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
goto ExitSCCMN50M_ResyncCardManII;
}
ExitSCCMN50M_ResyncCardManII:
SmartcardDebug(
DEBUG_TRACE,
( "%s!ResyncCardManII: Exit %lx\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_SerialIo(IN PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS status;
IO_STATUS_BLOCK ioStatus;
KEVENT event;
PIRP irp;
PIO_STACK_LOCATION irpNextStack;
PUCHAR pbRequestBuffer;
PUCHAR pbReplyBuffer;
ULONG ulRequestBufferLength;
ULONG ulReplyBufferLength ;
//
// Check if the buffers are large enough
//
ASSERT(pSmartcardExtension->SmartcardReply.BufferLength <=
pSmartcardExtension->SmartcardReply.BufferSize);
ASSERT(pSmartcardExtension->SmartcardRequest.BufferLength <=
pSmartcardExtension->SmartcardRequest.BufferSize);
if (pSmartcardExtension->SmartcardReply.BufferLength >
pSmartcardExtension->SmartcardReply.BufferSize ||
pSmartcardExtension->SmartcardRequest.BufferLength >
pSmartcardExtension->SmartcardRequest.BufferSize)
{
SmartcardLogError(pSmartcardExtension->OsData->DeviceObject,
SCCMN50M_BUFFER_TOO_SMALL,
NULL,
0);
return STATUS_BUFFER_TOO_SMALL;
}
// set pointer and length of request and reply buffer
ulRequestBufferLength = pSmartcardExtension->SmartcardRequest.BufferLength;
pbRequestBuffer = (ulRequestBufferLength ? pSmartcardExtension->SmartcardRequest.Buffer : NULL);
pbReplyBuffer = pSmartcardExtension->SmartcardReply.Buffer;
ulReplyBufferLength = pSmartcardExtension->SmartcardReply.BufferLength;
KeInitializeEvent(&event,
NotificationEvent,
FALSE);
//
// Build irp to be sent to serial driver
//
irp = IoBuildDeviceIoControlRequest(pSmartcardExtension->ReaderExtension->SerialIoControlCode,
pSmartcardExtension->ReaderExtension->AttachedDeviceObject,
pbRequestBuffer,
ulRequestBufferLength,
pbReplyBuffer,
ulReplyBufferLength,
FALSE,
&event,
&ioStatus);
ASSERT(irp != NULL);
if (irp == NULL)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
irpNextStack = IoGetNextIrpStackLocation(irp);
switch (pSmartcardExtension->ReaderExtension->SerialIoControlCode)
{
//
// The serial driver transfers data from/to irp->AssociatedIrp.SystemBuffer
//
case SMARTCARD_WRITE:
irpNextStack->MajorFunction = IRP_MJ_WRITE;
irpNextStack->Parameters.Write.Length = pSmartcardExtension->SmartcardRequest.BufferLength;
break;
case SMARTCARD_READ:
irpNextStack->MajorFunction = IRP_MJ_READ;
irpNextStack->Parameters.Read.Length = pSmartcardExtension->SmartcardReply.BufferLength;
break;
}
status = IoCallDriver(pSmartcardExtension->ReaderExtension->AttachedDeviceObject,irp);
if (status == STATUS_PENDING)
{
KeWaitForSingleObject(&event,
Suspended,
KernelMode,
FALSE,
NULL);
status = ioStatus.Status;
}
switch (pSmartcardExtension->ReaderExtension->SerialIoControlCode)
{
case SMARTCARD_READ:
if (status == STATUS_TIMEOUT)
{
SmartcardDebug(DEBUG_ERROR,
("%s!Timeout while reading from CardMan\n",
DRIVER_NAME));
//
// STATUS_TIMEOUT isn't correctly mapped
// to a WIN32 error, that's why we change it here
// to STATUS_IO_TIMEOUT
//
status = STATUS_IO_TIMEOUT;
pSmartcardExtension->SmartcardReply.BufferLength = 0;
}
break;
}
#if 0
if (status != STATUS_SUCCESS)
{
SmartcardDebug(DEBUG_DRIVER,
("%s!SerialIo = %lx\n",
DRIVER_NAME,
status));
}
#endif
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_ReadCardMan (
IN PSMARTCARD_EXTENSION pSmartcardExtension,
IN ULONG BytesToRead,
OUT PULONG pBytesRead,
IN PUCHAR pReadBuffer,
IN ULONG ReadBufferSize
)
{
NTSTATUS status;
NTSTATUS DebugStatus;
BOOLEAN fRc;
// check if read buffer is large enough
ASSERT(BytesToRead <= ReadBufferSize);
*pBytesRead = 0; // default setting
DebugStatus = SCCMN50M_SetRead(pSmartcardExtension,BytesToRead);
//
// read operation
//
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (status == STATUS_SUCCESS)
{
*pBytesRead = pSmartcardExtension->SmartcardReply.BufferLength;
MemCpy(pReadBuffer,
ReadBufferSize,
pSmartcardExtension->SmartcardReply.Buffer,
pSmartcardExtension->SmartcardReply.BufferLength);
// overwrite read buffer with '@'
MemSet(pSmartcardExtension->SmartcardReply.Buffer,
pSmartcardExtension->SmartcardReply.BufferSize,
'@',
pSmartcardExtension->SmartcardReply.BufferLength);
}
if (status != STATUS_SUCCESS || SCCMN50M_IOOperationFailed(pSmartcardExtension))
{
if (!pSmartcardExtension->ReaderExtension->fTransparentMode)
{
DebugStatus = SCCMN50M_ResyncCardManII(pSmartcardExtension);
}
goto ExitSCCMN50M_ReadCardMan;
}
// *****************************************
// set CardManII to state RH Config
// *****************************************
// don't set CardMan to RH config if there are still bytes to be read
if (pSmartcardExtension->ReaderExtension->ToRHConfig == TRUE)
{
pSmartcardExtension->SmartcardReply.BufferLength = 0;
pSmartcardExtension->SmartcardRequest.Buffer [0] = 0x00;
pSmartcardExtension->SmartcardRequest.Buffer [1] = 0x00;
pSmartcardExtension->SmartcardRequest.Buffer [2] = 0x00;
pSmartcardExtension->SmartcardRequest.Buffer [3] = 0x00;
pSmartcardExtension->SmartcardRequest.Buffer [4] = 0x89;
pSmartcardExtension->SmartcardRequest.BufferLength = 5;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = SMARTCARD_WRITE;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (status != STATUS_SUCCESS || SCCMN50M_IOOperationFailed(pSmartcardExtension))
{
DebugStatus = SCCMN50M_ResyncCardManII(pSmartcardExtension);
goto ExitSCCMN50M_ReadCardMan;
}
}
ExitSCCMN50M_ReadCardMan:
// set default value;
pSmartcardExtension->ReaderExtension->ToRHConfig = TRUE;
if (status != STATUS_SUCCESS)
{
SmartcardDebug(
DEBUG_TRACE,
( "%s!ReadCardMan: Failed, exit %lx\n",
DRIVER_NAME,status)
);
}
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_GetCommStatus (
IN PSMARTCARD_EXTENSION SmartcardExtension
)
{
PSERIAL_READER_CONFIG configData = &SmartcardExtension->ReaderExtension->SerialConfigData;
NTSTATUS status;
PUCHAR request = SmartcardExtension->SmartcardRequest.Buffer;
SmartcardExtension->SmartcardReply.BufferLength = SmartcardExtension->SmartcardReply.BufferSize;
SmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_GET_COMMSTATUS;
SmartcardExtension->SmartcardRequest.Buffer = (PUCHAR) &configData->SerialStatus;
SmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_STATUS);
status = SCCMN50M_SerialIo(SmartcardExtension);
//
// restore pointer to original request buffer
//
SmartcardExtension->SmartcardRequest.Buffer = request;
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
BOOLEAN
SCCMN50M_IOOperationFailed(PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS DebugStatus;
PSERIAL_STATUS pSerialStatus;
DebugStatus = SCCMN50M_GetCommStatus(pSmartcardExtension);
pSerialStatus = (PSERIAL_STATUS)pSmartcardExtension->SmartcardReply.Buffer;
if (pSerialStatus->Errors)
return TRUE;
else
return FALSE;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS SCCMN50M_PurgeComm (IN PSMARTCARD_EXTENSION pSmartcardExtension )
{
PSERIAL_READER_CONFIG configData = &pSmartcardExtension->ReaderExtension->SerialConfigData;
NTSTATUS status;
PUCHAR request = pSmartcardExtension->SmartcardRequest.Buffer;
pSmartcardExtension->SmartcardReply.BufferLength = pSmartcardExtension->SmartcardReply.BufferSize;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_PURGE;
pSmartcardExtension->SmartcardRequest.Buffer = (PUCHAR) &configData->PurgeMask;
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(ULONG);
status = SCCMN50M_SerialIo(pSmartcardExtension);
//
// restore pointer to original request buffer
//
pSmartcardExtension->SmartcardRequest.Buffer = request;
// under W2000 & CardMan P+ STATUS_CANCELLED may be returned
if (status == STATUS_CANCELLED)
status = STATUS_SUCCESS;
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_SetRead(IN PSMARTCARD_EXTENSION pSmartcardExtension,
IN ULONG ulBytesToRead
)
{
pSmartcardExtension->ReaderExtension->SerialIoControlCode = SMARTCARD_READ;
pSmartcardExtension->SmartcardRequest.BufferLength = 0;
pSmartcardExtension->SmartcardReply.BufferLength = ulBytesToRead;
return STATUS_SUCCESS;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_SetWrite(IN PSMARTCARD_EXTENSION pSmartcardExtension,
IN ULONG BytesToWrite,
IN PUCHAR WriteBuffer
)
{
ULONG Offset = 0;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = SMARTCARD_WRITE;
pSmartcardExtension->SmartcardReply.BufferLength = 0;
if (pSmartcardExtension->ReaderExtension->fTransparentMode == FALSE)
{
// send always config string for CardManII, expect we set it manualy
// to NoConfig = TRUE. (note: only one time)
if (pSmartcardExtension->ReaderExtension->NoConfig == FALSE)
{
MemCpy(pSmartcardExtension->SmartcardRequest.Buffer,
pSmartcardExtension->SmartcardRequest.BufferSize,
(PUCHAR)&pSmartcardExtension->ReaderExtension->CardManConfig,
sizeof(CARDMAN_CONFIG));
Offset = 4;
}
else
{
pSmartcardExtension->ReaderExtension->NoConfig = FALSE;
}
MemCpy(pSmartcardExtension->SmartcardRequest.Buffer + Offset,
pSmartcardExtension->SmartcardRequest.BufferSize,
(PUCHAR)&pSmartcardExtension->ReaderExtension->CardManHeader,
sizeof(CARDMAN_HEADER));
Offset+=4;
}
if (BytesToWrite != 0)
{
MemCpy(pSmartcardExtension->SmartcardRequest.Buffer + Offset,
pSmartcardExtension->SmartcardRequest.BufferSize,
WriteBuffer,
BytesToWrite);
}
pSmartcardExtension->SmartcardRequest.BufferLength = Offset + BytesToWrite;
return STATUS_SUCCESS;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_StartCardTracking(
PDEVICE_EXTENSION pDeviceExtension
)
{
NTSTATUS status;
HANDLE hThread;
PSMARTCARD_EXTENSION pSmartcardExtension = &pDeviceExtension->SmartcardExtension;
SmartcardDebug(DEBUG_TRACE,
("%s!StartCardTracking: Enter\n",DRIVER_NAME));
KeWaitForSingleObject(&pSmartcardExtension->ReaderExtension->CardManIOMutex,
Executive,
KernelMode,
FALSE,
NULL);
// create thread for updating current state
status = PsCreateSystemThread(&hThread,
THREAD_ALL_ACCESS,
NULL,
NULL,
NULL,
SCCMN50M_UpdateCurrentStateThread,
pDeviceExtension);
if (!NT_ERROR(status))
{
//
// We've got the thread. Now get a pointer to it.
//
status = ObReferenceObjectByHandle(hThread,
THREAD_ALL_ACCESS,
NULL,
KernelMode,
&pSmartcardExtension->ReaderExtension->ThreadObjectPointer,
NULL);
if (NT_ERROR(status))
{
pSmartcardExtension->ReaderExtension->TimeToTerminateThread = TRUE;
}
else
{
//
// Now that we have a reference to the thread
// we can simply close the handle.
//
ZwClose(hThread);
}
}
else
{
}
// Release the mutex
KeReleaseMutex(&pSmartcardExtension->ReaderExtension->CardManIOMutex,
FALSE);
SmartcardDebug(DEBUG_TRACE,
("%s!StartCardTracking: Exit %lx\n",DRIVER_NAME,status));
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_InitCommPort (PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS status;
SmartcardDebug(
DEBUG_TRACE,
( "%s!InitCommPort: Enter\n",
DRIVER_NAME)
);
// ===============================
// clear any pending errors
// ===============================
status = SCCMN50M_GetCommStatus(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_GetCommStatus failed ! status = %ld\n",status))
goto ExitInitCommPort;
}
// ==============================
// set baudrate for CardMan
// ==============================
pSmartcardExtension->ReaderExtension->SerialConfigData.BaudRate.BaudRate = 38400;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_BAUD_RATE;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.BaudRate.BaudRate,
sizeof(SERIAL_BAUD_RATE));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_BAUD_RATE);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_BAUDRATE failed ! status = %ld\n",status))
goto ExitInitCommPort;
}
// ===============================
// set comm timeouts
// ===============================
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadIntervalTimeout = DEFAULT_READ_INTERVAL_TIMEOUT;
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant = DEFAULT_READ_TOTAL_TIMEOUT_CONSTANT;
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier = DEFAULT_READ_TOTAL_TIMEOUT_MULTIPLIER;
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.WriteTotalTimeoutConstant = DEFAULT_WRITE_TOTAL_TIMEOUT_CONSTANT;
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.WriteTotalTimeoutMultiplier = DEFAULT_WRITE_TOTAL_TIMEOUT_MULTIPLIER;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_TIMEOUTS;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts,
sizeof(SERIAL_TIMEOUTS));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_TIMEOUTS);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_TIMEOUTS failed ! status = %x\n",status))
goto ExitInitCommPort;
}
// ===============================
// set line control
// ===============================
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.StopBits = STOP_BITS_2;
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.Parity = EVEN_PARITY;
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.WordLength = 8;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_LINE_CONTROL;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl,
sizeof(SERIAL_LINE_CONTROL));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_LINE_CONTROL);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_LINE_CONTROL failed ! status = %x\n",status))
goto ExitInitCommPort;
}
// ===============================
// Set handflow
// ===============================
pSmartcardExtension->ReaderExtension->SerialConfigData.HandFlow.XonLimit = 0;
pSmartcardExtension->ReaderExtension->SerialConfigData.HandFlow.XoffLimit = 0;
pSmartcardExtension->ReaderExtension->SerialConfigData.HandFlow.FlowReplace = 0;
pSmartcardExtension->ReaderExtension->SerialConfigData.HandFlow.ControlHandShake = SERIAL_ERROR_ABORT | SERIAL_DTR_CONTROL;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_HANDFLOW;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.HandFlow,
sizeof(SERIAL_HANDFLOW));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_HANDFLOW);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_HANDFLOW failed ! status = %x\n",status))
goto ExitInitCommPort;
}
// ===============================
// set purge mask
// ===============================
pSmartcardExtension->ReaderExtension->SerialConfigData.PurgeMask =
SERIAL_PURGE_TXABORT | SERIAL_PURGE_RXABORT |
SERIAL_PURGE_TXCLEAR | SERIAL_PURGE_RXCLEAR;
// ===============================
// set DTR
// ===============================
status = SCCMN50M_SetDTR(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_DRT failed ! status = %x\n",status))
goto ExitInitCommPort;
}
// ===============================
// set RTS
// ===============================
status = SCCMN50M_SetRTS(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_RTS failed ! status = %x\n",status))
goto ExitInitCommPort;
}
ExitInitCommPort:
SmartcardDebug(
DEBUG_TRACE,
( "%s!InitCommPort: Exit %lx\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_SetDTR(IN PSMARTCARD_EXTENSION pSmartcardExtension )
{
NTSTATUS status;
pSmartcardExtension->SmartcardReply.BufferLength = 0;
pSmartcardExtension->SmartcardRequest.BufferLength = 0;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_DTR;
status = SCCMN50M_SerialIo(pSmartcardExtension);
// under W2000 & CardMan P+ STATUS_CANCELLED may be returned
if (status == STATUS_CANCELLED)
status = STATUS_SUCCESS;
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_SetRTS(IN PSMARTCARD_EXTENSION pSmartcardExtension )
{
NTSTATUS status;
pSmartcardExtension->SmartcardReply.BufferLength = pSmartcardExtension->SmartcardReply.BufferSize;
pSmartcardExtension->SmartcardRequest.BufferLength = 0;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_RTS;
status = SCCMN50M_SerialIo(pSmartcardExtension);
// under W2000 & CardMan P+ STATUS_CANCELLED may be returned
if (status == STATUS_CANCELLED)
status = STATUS_SUCCESS;
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_InitializeCardMan(IN PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS status;
UCHAR pReadBuffer[2];
ULONG ulBytesRead;
BOOLEAN fCardManFound = FALSE;
PREADER_EXTENSION readerExtension = pSmartcardExtension->ReaderExtension;
ULONG ulRetries;
SmartcardDebug(
DEBUG_TRACE,
( "%s!InitializeCardMan: Enter\n",
DRIVER_NAME)
);
pSmartcardExtension->ReaderExtension->ulOldCardState = UNKNOWN;
// ==============================================
// CardManII
// ==============================================
pSmartcardExtension->ReaderExtension->NoConfig = FALSE;
pSmartcardExtension->ReaderExtension->ToRHConfig = TRUE;
// This waiting time if necessary for CardMan Power+, because
// the pnP string may be dumped
Wait(pSmartcardExtension,200);
status = SCCMN50M_InitCommPort(pSmartcardExtension);
if (status != STATUS_SUCCESS)
goto ExitInitializeCardMan;
//
// init CommPort was O.K.
// now try to find a reader
//
// To be sure wait make an additional wait
Wait(pSmartcardExtension,100);
status = SCCMN50M_ResyncCardManII(pSmartcardExtension);
status = SCCMN50M_ResyncCardManII(pSmartcardExtension);
// no data except config + header
pSmartcardExtension->ReaderExtension->CardManConfig.SCRControl = XMIT_HANDSHAKE_OFF;
pSmartcardExtension->ReaderExtension->CardManConfig.CardControl = 0x00;
pSmartcardExtension->ReaderExtension->CardManConfig.CardStopBits = 0x00;
pSmartcardExtension->ReaderExtension->CardManConfig.ResetDelay = 0x00;
pSmartcardExtension->ReaderExtension->CardManHeader.TxControl = 0x00;
pSmartcardExtension->ReaderExtension->CardManHeader.TxLength = 0x00;
pSmartcardExtension->ReaderExtension->CardManHeader.RxControl = 0x00;
pSmartcardExtension->ReaderExtension->CardManHeader.RxLength = 0x00;
status = SCCMN50M_WriteCardMan(pSmartcardExtension,0,NULL);
if (status == STATUS_SUCCESS)
{
status = SCCMN50M_ReadCardMan(pSmartcardExtension,2,&ulBytesRead,pReadBuffer,sizeof(pReadBuffer));
if (status == STATUS_SUCCESS &&
ulBytesRead == 0x02 && // two bytes received
pReadBuffer[0] >= 0x40 && // at least one version bit must be set
pReadBuffer[1] == 0x00 &&
((pReadBuffer[0] & 0x09) == 0) ) // bit 0 and 3 must be cleared
{
pSmartcardExtension->ReaderExtension->ulFWVersion = (pReadBuffer[0] >> 4) * 30 + 120;
pSmartcardExtension->ReaderExtension->fSPESupported = FALSE;
SmartcardDebug(
DEBUG_DRIVER,
( "%s!CardMan (FW %ld) found\n",
DRIVER_NAME,pSmartcardExtension->ReaderExtension->ulFWVersion)
);
fCardManFound = TRUE;
}
}
ExitInitializeCardMan:
if (fCardManFound == TRUE)
status = STATUS_SUCCESS;
else
status = STATUS_UNSUCCESSFUL;
SmartcardDebug(
DEBUG_TRACE,
( "%s!InitializeCardMan: Exit %lx\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_EnterTransparentMode (IN PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS status;
SmartcardDebug(DEBUG_TRACE,("EnterTransparentMode : enter\n"));
// Step 1 : Resync CardMan by RTS usage
status = SCCMN50M_ResyncCardManI(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_ResyncCardManI failed ! status = %ld\n",status))
goto ExitEnterTransparentMode;
}
// Step 2 : set baud rate to 9600
pSmartcardExtension->ReaderExtension->SerialConfigData.BaudRate.BaudRate = 9600;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_BAUD_RATE;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.BaudRate.BaudRate,
sizeof(SERIAL_BAUD_RATE));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_BAUD_RATE);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_BAUDRATE failed ! status = %ld\n",status))
goto ExitEnterTransparentMode;
}
ExitEnterTransparentMode:
// Step 3 : set ATR and DUMP_BUFFER flags
// During normal operation these two flags can never be set at the same time
SCCMN50M_SetSCRControlFlags(pSmartcardExtension,CM2_GET_ATR | TO_STATE_XH);
SmartcardDebug(DEBUG_TRACE,("EnterTransparentMode : exit\n"));
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_ExitTransparentMode (IN PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS status;
SmartcardDebug(DEBUG_TRACE,("ExitTransparentMode : enter\n"));
// ===============================
// clear any pending errors
// ===============================
status = SCCMN50M_GetCommStatus(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_GetCommStatus failed ! status = %ld\n",status))
goto ExitExitTransparentMode;
}
// Step 1 : Resync CardMan by RTS usage
status = SCCMN50M_ResyncCardManI(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_ResyncCardManI failed ! status = %ld\n",status))
goto ExitExitTransparentMode;
}
// Step 2 : set baud rate to 38400
pSmartcardExtension->ReaderExtension->SerialConfigData.BaudRate.BaudRate = 38400;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_BAUD_RATE;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.BaudRate.BaudRate,
sizeof(SERIAL_BAUD_RATE));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_BAUD_RATE);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_BAUDRATE failed ! status = %ld\n",status))
goto ExitExitTransparentMode;
}
// if the inserted card uses inverse convention , we must now switch the COM port
// back to even parity
if (pSmartcardExtension->ReaderExtension->fInverseAtr == TRUE)
{
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.StopBits = STOP_BITS_2;
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.Parity = EVEN_PARITY;
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.WordLength = SERIAL_DATABITS_8;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_LINE_CONTROL;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl,
sizeof(SERIAL_LINE_CONTROL));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_LINE_CONTROL);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_LINE_CONTROL failed ! status = %x\n",status))
goto ExitExitTransparentMode;
}
}
ExitExitTransparentMode:
// Step 3 : set ATR and DUMP_BUFFER flags
// During normal operation these two flags can never be set at the same time
SCCMN50M_ClearSCRControlFlags(pSmartcardExtension,CM2_GET_ATR | TO_STATE_XH);
status = SCCMN50M_ResyncCardManII(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_ResyncCardManII failed ! status = %x\n",status))
goto ExitExitTransparentMode;
}
SmartcardDebug(DEBUG_TRACE,("ExitTransparentMode : exit\n"));
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_ClearRTS(IN PSMARTCARD_EXTENSION SmartcardExtension )
{
NTSTATUS status;
SmartcardExtension->SmartcardReply.BufferLength = SmartcardExtension->SmartcardReply.BufferSize;
SmartcardExtension->SmartcardRequest.BufferLength = 0;
SmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_CLR_RTS;
status = SCCMN50M_SerialIo(SmartcardExtension);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_IoCtlVendor(PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS status = STATUS_SUCCESS;
NTSTATUS DebugStatus;
UCHAR pbAttrBuffer[MAXIMUM_ATR_LENGTH];
ULONG ulAtrLength;
SmartcardDebug(
DEBUG_TRACE,
( "%s!IoCtlVendor : Enter\n",
DRIVER_NAME)
);
switch (pSmartcardExtension->MajorIoControlCode)
{
case CM_IOCTL_SET_READER_9600_BAUD:
status = SCCMN50M_SetFl_1Dl_1(pSmartcardExtension);
break;
case CM_IOCTL_SET_READER_38400_BAUD:
status = SCCMN50M_SetFl_1Dl_3(pSmartcardExtension);
break;
case CM_IOCTL_CR80S_SAMOS_SET_HIGH_SPEED:
status = SCCMN50M_SetHighSpeed_CR80S_SAMOS(pSmartcardExtension);
break;
case CM_IOCTL_GET_FW_VERSION:
status = SCCMN50M_GetFWVersion(pSmartcardExtension);
break;
case CM_IOCTL_READ_DEVICE_DESCRIPTION:
status = SCCMN50M_ReadDeviceDescription(pSmartcardExtension);
break;
case CM_IOCTL_SET_SYNC_PARAMETERS :
status = SCCMN50M_SetSyncParameters(pSmartcardExtension);
break;
case CM_IOCTL_3WBP_TRANSFER : // for SLE4428
status = SCCMN50M_Transmit3WBP(pSmartcardExtension);
break;
case CM_IOCTL_2WBP_TRANSFER : // for SLE4442
status = SCCMN50M_Transmit2WBP(pSmartcardExtension);
break;
case CM_IOCTL_2WBP_RESET_CARD: // SLE4442 Reset Card
status = SCCMN50M_ResetCard2WBP(pSmartcardExtension);
break;
case CM_IOCTL_SYNC_CARD_POWERON:
status = SCCMN50M_SyncCardPowerOn(pSmartcardExtension);
break;
default:
status = STATUS_INVALID_DEVICE_REQUEST;
break;
}
SmartcardDebug(
DEBUG_TRACE,
( "%s!IoCtlVendor : Exit %lx\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_SetFl_1Dl_3(IN PSMARTCARD_EXTENSION pSmartcardExtension )
{
NTSTATUS status = STATUS_SUCCESS;
NTSTATUS DebugStatus;
SmartcardDebug(DEBUG_TRACE,
("%s!SetFl_1Dl_3 Enter\n",
DRIVER_NAME));
// check if T=1 active
if (pSmartcardExtension->CardCapabilities.Protocol.Selected !=
SCARD_PROTOCOL_T1)
{
status = STATUS_CTL_FILE_NOT_SUPPORTED;
goto ExitSetFl_1Dl_3;
}
// Fl=1
// Dl=3
// => 38400 Baud for 3.72 MHz
SCCMN50M_ClearCardControlFlags(pSmartcardExtension,ENABLE_3MHZ | ENABLE_5MHZ |
ENABLE_3MHZ_FAST | ENABLE_5MHZ_FAST );
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_3MHZ_FAST);
ExitSetFl_1Dl_3:
*pSmartcardExtension->IoRequest.Information = 0L;
SmartcardDebug(DEBUG_TRACE,
("%s!SetFl_1Dl_3 Exit\n",
DRIVER_NAME));
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_SetFl_1Dl_1(IN PSMARTCARD_EXTENSION pSmartcardExtension )
{
NTSTATUS status = STATUS_SUCCESS;
SmartcardDebug(DEBUG_TRACE,
("%s!SetFl_1Dl_1 Enter\n",
DRIVER_NAME));
// Fl=1
// Dl=1
// => 9600 for 3.72 MHz
SCCMN50M_ClearCardControlFlags(pSmartcardExtension,ENABLE_3MHZ | ENABLE_5MHZ |
ENABLE_3MHZ_FAST | ENABLE_5MHZ_FAST );
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_3MHZ);
*pSmartcardExtension->IoRequest.Information = 0L;
SmartcardDebug(DEBUG_TRACE,
("%s!SetFl_1Dl_1 Exit\n",
DRIVER_NAME));
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_GetFWVersion (IN PSMARTCARD_EXTENSION pSmartcardExtension )
{
NTSTATUS status = STATUS_SUCCESS;
SmartcardDebug(
DEBUG_TRACE,
( "%s!GetFWVersion : Enter\n",
DRIVER_NAME)
);
if (pSmartcardExtension->IoRequest.ReplyBufferLength < sizeof (ULONG))
{
status = STATUS_BUFFER_OVERFLOW;
goto ExitGetFWVersion;
}
else
{
*(PULONG)(pSmartcardExtension->IoRequest.ReplyBuffer) =
pSmartcardExtension->ReaderExtension->ulFWVersion;
}
ExitGetFWVersion:
*pSmartcardExtension->IoRequest.Information = sizeof(ULONG);
SmartcardDebug(
DEBUG_TRACE,
( "%s!GetFWVersion : Exit %lx\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_ReadDeviceDescription(IN PSMARTCARD_EXTENSION pSmartcardExtension )
{
NTSTATUS status = STATUS_SUCCESS;
SmartcardDebug(
DEBUG_TRACE,
( "%s!ReadDeviceDescription : Enter\n",
DRIVER_NAME)
);
if (pSmartcardExtension->IoRequest.ReplyBufferLength < sizeof(pSmartcardExtension->ReaderExtension->abDeviceDescription))
{
status = STATUS_BUFFER_OVERFLOW;
*pSmartcardExtension->IoRequest.Information = 0L;
goto ExitReadDeviceDescription;
}
else
{
if (pSmartcardExtension->ReaderExtension->abDeviceDescription[0] == 0x00 &&
pSmartcardExtension->ReaderExtension->abDeviceDescription[1] == 0x00 )
{
status = SCCMN50M_GetDeviceDescription(pSmartcardExtension);
}
if (status == STATUS_SUCCESS)
{
StrCpy(pSmartcardExtension->IoRequest.ReplyBuffer,
pSmartcardExtension->IoRequest.ReplyBufferLength,
pSmartcardExtension->ReaderExtension->abDeviceDescription);
*pSmartcardExtension->IoRequest.Information = StrLen(pSmartcardExtension->ReaderExtension->abDeviceDescription) +1;
}
else
{
MemSet(pSmartcardExtension->ReaderExtension->abDeviceDescription,
sizeof(pSmartcardExtension->ReaderExtension->abDeviceDescription),
0x00,
sizeof(pSmartcardExtension->ReaderExtension->abDeviceDescription));
*pSmartcardExtension->IoRequest.Information = 0;
}
}
ExitReadDeviceDescription:
SmartcardDebug(
DEBUG_TRACE,
( "%s!ReadDeviceDescription : Exit %lx\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_SetHighSpeed_CR80S_SAMOS (IN PSMARTCARD_EXTENSION pSmartcardExtension )
{
NTSTATUS status;
NTSTATUS DebugStatus;
UCHAR bReadBuffer[16];
ULONG ulBytesRead;
BYTE bCR80S_SAMOS_SET_HIGH_SPEED[4] = {0xFF,0x11,0x94,0x7A};
ULONG ulAtrLength;
BYTE bAtr[MAXIMUM_ATR_LENGTH];
SmartcardDebug(
DEBUG_TRACE,
( "%s!SetHighSpeed_CR80S_SAMOS : Enter\n",
DRIVER_NAME)
);
SCCMN50M_ClearCardControlFlags(pSmartcardExtension,ENABLE_SYN | ENABLE_T0 |
ENABLE_T1 );
SCCMN50M_SetCardManHeader(pSmartcardExtension,
0, // Tx control
sizeof(bCR80S_SAMOS_SET_HIGH_SPEED), // Tx length
0, // Rx control
sizeof(bCR80S_SAMOS_SET_HIGH_SPEED)); // Rx length
status = SCCMN50M_WriteCardMan(pSmartcardExtension,
sizeof(bCR80S_SAMOS_SET_HIGH_SPEED),
bCR80S_SAMOS_SET_HIGH_SPEED);
if (status != STATUS_SUCCESS)
goto ExitSetHighSpeed;
pSmartcardExtension->ReaderExtension->ToRHConfig = FALSE;
status = SCCMN50M_ReadCardMan(pSmartcardExtension,2,&ulBytesRead,bReadBuffer,sizeof(bReadBuffer));
if (status != STATUS_SUCCESS)
goto ExitSetHighSpeed;
if (bReadBuffer[1] > sizeof(bReadBuffer))
{
status = STATUS_BUFFER_OVERFLOW;
goto ExitSetHighSpeed;
}
status = SCCMN50M_ReadCardMan(pSmartcardExtension,bReadBuffer[1],&ulBytesRead,bReadBuffer,sizeof(bReadBuffer));
if (status != STATUS_SUCCESS)
goto ExitSetHighSpeed;
// if the card has accepted this string , the string is echoed
if (bReadBuffer[0] == bCR80S_SAMOS_SET_HIGH_SPEED[0] &&
bReadBuffer[1] == bCR80S_SAMOS_SET_HIGH_SPEED[1] &&
bReadBuffer[2] == bCR80S_SAMOS_SET_HIGH_SPEED[2] &&
bReadBuffer[3] == bCR80S_SAMOS_SET_HIGH_SPEED[3] )
{
SCCMN50M_ClearCardControlFlags(pSmartcardExtension,ENABLE_3MHZ | ENABLE_5MHZ |
ENABLE_3MHZ_FAST | ENABLE_5MHZ_FAST );
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_5MHZ_FAST);
}
else
{
DebugStatus = SCCMN50M_PowerOff(pSmartcardExtension);
DebugStatus = SCCMN50M_PowerOn(pSmartcardExtension,&ulAtrLength,bAtr,sizeof(bAtr));
status = STATUS_UNSUCCESSFUL;
}
ExitSetHighSpeed:
*pSmartcardExtension->IoRequest.Information = 0L;
SmartcardDebug(
DEBUG_TRACE,
( "%s!SetHighSpeed_CR80S_SAMOS : Exit %lx\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_SetBRK(IN PSMARTCARD_EXTENSION pSmartcardExtension )
{
NTSTATUS status;
pSmartcardExtension->SmartcardReply.BufferLength = pSmartcardExtension->SmartcardReply.BufferSize;
pSmartcardExtension->SmartcardRequest.BufferLength = 0;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_BREAK_ON;
status = SCCMN50M_SerialIo(pSmartcardExtension);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_ClearBRK(IN PSMARTCARD_EXTENSION SmartcardExtension )
{
NTSTATUS status;
SmartcardExtension->SmartcardReply.BufferLength = SmartcardExtension->SmartcardReply.BufferSize;
SmartcardExtension->SmartcardRequest.BufferLength = 0;
SmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_BREAK_OFF;
status = SCCMN50M_SerialIo(SmartcardExtension);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_SetProtocol(PSMARTCARD_EXTENSION pSmartcardExtension )
{
NTSTATUS status;
NTSTATUS DebugStatus;
ULONG ulNewProtocol;
UCHAR abPTSRequest[4];
UCHAR abReadBuffer[6];
UCHAR abPTSReply [4];
ULONG ulBytesRead;
UCHAR bTemp;
ULONG ulPtsType;
ULONG ulPTSReplyLength=0;
ULONG ulStatBytesRead;
BYTE abStatReadBuffer[2];
SmartcardDebug(
DEBUG_TRACE,
( "%s!SetProtocol : Enter\n",
DRIVER_NAME)
);
//
// 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.
//
if ((pSmartcardExtension->CardCapabilities.Protocol.Selected & pSmartcardExtension->MinorIoControlCode))
{
status = STATUS_SUCCESS;
goto ExitSetProtocol;
}
ulNewProtocol = pSmartcardExtension->MinorIoControlCode;
ulPtsType = PTS_TYPE_OPTIMAL;
// we are not sure if we need this at all
pSmartcardExtension->CardCapabilities.PtsData.Type = PTS_TYPE_OPTIMAL;
while (TRUE)
{
// set initial character of PTS
abPTSRequest[0] = 0xFF;
// set the format character
if (pSmartcardExtension->CardCapabilities.Protocol.Supported &
ulNewProtocol &
SCARD_PROTOCOL_T1)
{
// select T=1 and indicate that PTS1 follows
abPTSRequest[1] = 0x11;
pSmartcardExtension->CardCapabilities.Protocol.Selected =
SCARD_PROTOCOL_T1;
}
else if (pSmartcardExtension->CardCapabilities.Protocol.Supported &
ulNewProtocol &
SCARD_PROTOCOL_T0)
{
// select T=1 and indicate that PTS1 follows
abPTSRequest[1] = 0x10;
pSmartcardExtension->CardCapabilities.Protocol.Selected =
SCARD_PROTOCOL_T0;
}
else
{
status = STATUS_INVALID_DEVICE_REQUEST;
goto ExitSetProtocol;
}
// bug fix :
// don 't use the suggestion from smclib
pSmartcardExtension->CardCapabilities.PtsData.Fl =
pSmartcardExtension->CardCapabilities.Fl;
pSmartcardExtension->CardCapabilities.PtsData.Dl =
pSmartcardExtension->CardCapabilities.Dl;
// CardMan support higher baudrates only for T=1
// ==> Dl=1
if (abPTSRequest[1] == 0x10)
{
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!overwriting PTS1 for T=0\n",
DRIVER_NAME)
);
pSmartcardExtension->CardCapabilities.PtsData.Fl = 0x01;
pSmartcardExtension->CardCapabilities.PtsData.Dl = 0x01;
}
if (ulPtsType == PTS_TYPE_DEFAULT)
{
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!overwriting PTS1 with default values\n",
DRIVER_NAME)
);
pSmartcardExtension->CardCapabilities.PtsData.Fl = 0x01;
pSmartcardExtension->CardCapabilities.PtsData.Dl = 0x01;
}
// set pts1 which codes Fl and Dl
bTemp = (BYTE) (pSmartcardExtension->CardCapabilities.PtsData.Fl << 4 |
pSmartcardExtension->CardCapabilities.PtsData.Dl);
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!PTS1 = %x (suggestion)\n",
DRIVER_NAME,bTemp)
);
switch (bTemp)
{
case 0x11:
// do nothing
// we support these Fl/Dl parameters
break;
case 0x13:
case 0x94:
break ;
case 0x14:
// let's try it with 38400 baud
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!trying 57600 baud\n",DRIVER_NAME)
);
// we must correct Fl/Dl
pSmartcardExtension->CardCapabilities.PtsData.Dl = 0x03;
pSmartcardExtension->CardCapabilities.PtsData.Fl = 0x01;
bTemp = (BYTE) (pSmartcardExtension->CardCapabilities.PtsData.Fl << 4 |
pSmartcardExtension->CardCapabilities.PtsData.Dl);
break;
default:
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!overwriting PTS1(0x%x)\n",
DRIVER_NAME,bTemp)
);
// we must correct Fl/Dl
pSmartcardExtension->CardCapabilities.PtsData.Dl = 0x01;
pSmartcardExtension->CardCapabilities.PtsData.Fl = 0x01;
bTemp = (BYTE) (pSmartcardExtension->CardCapabilities.PtsData.Fl << 4 |
pSmartcardExtension->CardCapabilities.PtsData.Dl);
break;
}
abPTSRequest[2] = bTemp;
// set pck (check character)
abPTSRequest[3] = (BYTE)(abPTSRequest[0] ^ abPTSRequest[1] ^ abPTSRequest[2]);
SmartcardDebug(DEBUG_PROTOCOL,("%s!PTS request: 0x%x 0x%x 0x%x 0x%x\n",
DRIVER_NAME,
abPTSRequest[0],
abPTSRequest[1],
abPTSRequest[2],
abPTSRequest[3]));
MemSet(abPTSReply,sizeof(abPTSReply),0x00,sizeof(abPTSReply));
DebugStatus = SCCMN50M_EnterTransparentMode(pSmartcardExtension);
// STEP 1 : write config + header to enter transparent mode
SCCMN50M_SetCardManHeader(pSmartcardExtension,
0, // Tx control
0, // Tx length
0, // Rx control
0); // Rx length
status = SCCMN50M_WriteCardMan (pSmartcardExtension,
0,
NULL);
if (NT_ERROR(status))
{
goto ExitSetProtocol;
}
pSmartcardExtension->ReaderExtension->fTransparentMode = TRUE;
// if the inserted card uses inverse convention , we must now switch the COM port
// to odd parity
/*
if (pSmartcardExtension->ReaderExtension->fInverseAtr == TRUE)
{
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.StopBits = STOP_BITS_2;
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.Parity = ODD_PARITY;
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.WordLength = SERIAL_DATABITS_8;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_LINE_CONTROL;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl,
sizeof(SERIAL_LINE_CONTROL));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_LINE_CONTROL);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
goto ExitTransparentTransmitT0;
}
}
*/
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!writing PTS request\n",
DRIVER_NAME)
);
status = SCCMN50M_WriteCardMan(pSmartcardExtension,
4,
abPTSRequest);
if (status != STATUS_SUCCESS)
{
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!writing PTS request failed\n",
DRIVER_NAME)
);
goto ExitSetProtocol;
}
// read back pts data
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!trying to read PTS reply\n",
DRIVER_NAME)
);
// first read CardMan header
pSmartcardExtension->ReaderExtension->ToRHConfig= FALSE;
status = SCCMN50M_ReadCardMan(pSmartcardExtension,3,&ulBytesRead,abReadBuffer,sizeof(abReadBuffer));
if (status != STATUS_SUCCESS &&
status != STATUS_IO_TIMEOUT )
{
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!reading status failed\n",
DRIVER_NAME)
);
goto ExitSetProtocol;
}
ulPTSReplyLength = 3;
MemCpy(abPTSReply,sizeof(abPTSReply),abReadBuffer,3);
// check if bit 5 is set
if (abPTSReply[1] & 0x10)
{
pSmartcardExtension->ReaderExtension->ToRHConfig= FALSE;
status = SCCMN50M_ReadCardMan(pSmartcardExtension,1,&ulBytesRead,abReadBuffer,sizeof(abReadBuffer));
if (status != STATUS_SUCCESS &&
status != STATUS_IO_TIMEOUT )
{
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!reading status failed\n",
DRIVER_NAME)
);
goto ExitSetProtocol;
}
ulPTSReplyLength += 1;
MemCpy(&abPTSReply[3],sizeof(abPTSReply)-3,abReadBuffer,1);
}
DebugStatus = SCCMN50M_ExitTransparentMode(pSmartcardExtension);
pSmartcardExtension->ReaderExtension->fTransparentMode = FALSE;
// to be sure that the new settings take effect
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant = 250;
DebugStatus = SCCMN50M_WriteCardMan(pSmartcardExtension,0,NULL);
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant = DEFAULT_READ_TOTAL_TIMEOUT_CONSTANT;
if (NT_SUCCESS(DebugStatus))
{
DebugStatus = SCCMN50M_ReadCardMan(pSmartcardExtension,2,&ulStatBytesRead,abStatReadBuffer,sizeof(abStatReadBuffer));
}
#if DBG
if (ulPTSReplyLength == 3)
{
SmartcardDebug(DEBUG_PROTOCOL,("PTS reply: 0x%x 0x%x 0x%x\n",
abPTSReply[0],
abPTSReply[1],
abPTSReply[2]));
}
if (ulPTSReplyLength == 4)
{
SmartcardDebug(DEBUG_PROTOCOL,("PTS reply: 0x%x 0x%x 0x%x 0x%x\n",
abPTSReply[0],
abPTSReply[1],
abPTSReply[2],
abPTSReply[3]));
}
#endif
if (ulPTSReplyLength == 3 &&
abPTSReply[0] == abPTSRequest[0] &&
(abPTSReply[1] & 0x7F) == (abPTSRequest[1] & 0x0F) &&
abPTSReply[2] == (BYTE)(abPTSReply[0] ^ abPTSReply[1]) )
{
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!short PTS reply received\n",
DRIVER_NAME)
);
break;
}
if (ulPTSReplyLength == 4 &&
abPTSReply[0] == abPTSRequest[0] &&
abPTSReply[1] == abPTSRequest[1] &&
abPTSReply[2] == abPTSRequest[2] &&
abPTSReply[3] == abPTSRequest[3])
{
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!PTS request and reply match\n",
DRIVER_NAME)
);
switch (bTemp)
{
case 0x11:
break;
case 0x13:
SCCMN50M_ClearCardControlFlags(pSmartcardExtension,ENABLE_3MHZ | ENABLE_5MHZ |
ENABLE_3MHZ_FAST | ENABLE_5MHZ_FAST );
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_3MHZ_FAST);
break ;
case 0x94:
SCCMN50M_ClearCardControlFlags(pSmartcardExtension,ENABLE_3MHZ | ENABLE_5MHZ |
ENABLE_3MHZ_FAST | ENABLE_5MHZ_FAST );
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_5MHZ_FAST);
break;
}
break;
}
if (pSmartcardExtension->CardCapabilities.PtsData.Type !=
PTS_TYPE_DEFAULT)
{
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!PTS failed : Trying default parameters\n",
DRIVER_NAME)
);
// the card did either not reply or it replied incorrectly
// so try default valies
ulPtsType = pSmartcardExtension->CardCapabilities.PtsData.Type = PTS_TYPE_DEFAULT;
pSmartcardExtension->MinorIoControlCode = SCARD_COLD_RESET;
status = SCCMN50M_CardPower(pSmartcardExtension);
continue;
}
// the card failed the pts request
status = STATUS_DEVICE_PROTOCOL_ERROR;
goto ExitSetProtocol;
}
ExitSetProtocol:
switch (status)
{
case STATUS_IO_TIMEOUT:
pSmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
*pSmartcardExtension->IoRequest.Information = 0;
break;
case STATUS_SUCCESS:
// now indicate that we're in specific mode
pSmartcardExtension->ReaderCapabilities.CurrentState = SCARD_SPECIFIC;
// return the selected protocol to the caller
*(PULONG) pSmartcardExtension->IoRequest.ReplyBuffer =
pSmartcardExtension->CardCapabilities.Protocol.Selected;
*pSmartcardExtension->IoRequest.Information =
sizeof(pSmartcardExtension->CardCapabilities.Protocol.Selected);
SmartcardDebug(
DEBUG_PROTOCOL,
( "%s!Selected protocol: T=%ld\n",
DRIVER_NAME,pSmartcardExtension->CardCapabilities.Protocol.Selected-1)
);
break;
default :
pSmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_UNDEFINED;
*pSmartcardExtension->IoRequest.Information = 0;
break;
}
SmartcardDebug(
DEBUG_TRACE,
( "%s!SetProtocol : Exit %lx\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
The smart card lib requires to have this function. It is called
to setup event tracking for card insertion and removal events.
Arguments:
pSmartcardExtension - pointer to the smart card data struct.
Return Value:
NTSTATUS
*****************************************************************************/
NTSTATUS
SCCMN50M_CardTracking(PSMARTCARD_EXTENSION pSmartcardExtension)
{
KIRQL oldIrql;
SmartcardDebug(
DEBUG_TRACE,
( "%s!CardTracking: Enter\n",
DRIVER_NAME)
);
//
// Set cancel routine for the notification irp
//
IoAcquireCancelSpinLock(&oldIrql);
IoSetCancelRoutine(pSmartcardExtension->OsData->NotificationIrp,SCCMN50M_Cancel);
IoReleaseCancelSpinLock(oldIrql);
//
// Mark notification irp pending
//
IoMarkIrpPending(pSmartcardExtension->OsData->NotificationIrp);
SmartcardDebug(
DEBUG_TRACE,
( "%s!CardTracking: Exit\n",
DRIVER_NAME)
);
return STATUS_PENDING;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
SCCMN50M_StopCardTracking(
IN PDEVICE_EXTENSION pDeviceExtension
)
{
PSMARTCARD_EXTENSION pSmartcardExtension = &pDeviceExtension->SmartcardExtension;
NTSTATUS status;
SmartcardDebug(
DEBUG_TRACE,
( "%s!StopCardTracking: Enter\n",
DRIVER_NAME)
);
if (pSmartcardExtension->ReaderExtension->ThreadObjectPointer != NULL)
{
// kill thread
KeWaitForSingleObject(&pSmartcardExtension->ReaderExtension->CardManIOMutex,
Executive,
KernelMode,
FALSE,
NULL
);
pSmartcardExtension->ReaderExtension->TimeToTerminateThread = TRUE;
KeReleaseMutex(&pSmartcardExtension->ReaderExtension->CardManIOMutex,FALSE);
//
// Wait on the thread handle, when the wait is satisfied, the
// thread has gone away.
//
status = KeWaitForSingleObject(
pSmartcardExtension->ReaderExtension->ThreadObjectPointer,
Executive,
KernelMode,
FALSE,
NULL
);
pSmartcardExtension->ReaderExtension->ThreadObjectPointer = NULL;
}
SmartcardDebug(
DEBUG_TRACE,
( "%s!StopCardTracking: Exit %lx\n",
DRIVER_NAME,
status)
);
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_GetDeviceDescription (PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS status;
NTSTATUS DebugStatus;
ULONG ulBytesRead;
BYTE bByteRead;
ULONG i,j;
BYTE abReadBuffer[256];
ULONG ulPnPStringLength = 0;
ULONG ulExtend;
SmartcardDebug(
DEBUG_TRACE,
( "%s!GetDeviceDescriptiong: Enter\n",
DRIVER_NAME)
);
// ===============================
// clear any pending errors
// ===============================
status = SCCMN50M_GetCommStatus(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("SCCMN50M_GetCommStatus failed ! status = %ld\n",status))
goto ExitGetDeviceDescription;
}
// =================================
// set baudrate for CardMan to 1200
// =================================
pSmartcardExtension->ReaderExtension->SerialConfigData.BaudRate.BaudRate = 1200;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_BAUD_RATE;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.BaudRate.BaudRate,
sizeof(SERIAL_BAUD_RATE));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_BAUD_RATE);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_BAUDRATE failed ! status = %ld\n",status))
goto ExitGetDeviceDescription;
}
// ===============================
// set comm timeouts
// ===============================
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadIntervalTimeout = DEFAULT_READ_INTERVAL_TIMEOUT;
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant = DEFAULT_READ_TOTAL_TIMEOUT_CONSTANT + 5000;
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutMultiplier = DEFAULT_READ_TOTAL_TIMEOUT_MULTIPLIER;
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.WriteTotalTimeoutConstant = DEFAULT_WRITE_TOTAL_TIMEOUT_CONSTANT;
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.WriteTotalTimeoutMultiplier = DEFAULT_WRITE_TOTAL_TIMEOUT_MULTIPLIER;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_TIMEOUTS;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts,
sizeof(SERIAL_TIMEOUTS));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_TIMEOUTS);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_TIMEOUTS failed ! status = %x\n",status))
goto ExitGetDeviceDescription;
}
// ===============================
// set line control
// ===============================
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.StopBits = STOP_BITS_2;
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.Parity = NO_PARITY;
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.WordLength = 7;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_LINE_CONTROL;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl,
sizeof(SERIAL_LINE_CONTROL));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_LINE_CONTROL);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_LINE_CONTROL failed ! status = %x\n",status))
goto ExitGetDeviceDescription;
}
// ===============================
// Set handflow
// ===============================
pSmartcardExtension->ReaderExtension->SerialConfigData.HandFlow.XonLimit = 0;
pSmartcardExtension->ReaderExtension->SerialConfigData.HandFlow.XoffLimit = 0;
pSmartcardExtension->ReaderExtension->SerialConfigData.HandFlow.FlowReplace = 0;
pSmartcardExtension->ReaderExtension->SerialConfigData.HandFlow.ControlHandShake = SERIAL_ERROR_ABORT | SERIAL_DTR_CONTROL;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_HANDFLOW;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.HandFlow,
sizeof(SERIAL_HANDFLOW));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_HANDFLOW);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_HANDFLOW failed ! status = %x\n",status))
goto ExitGetDeviceDescription;
}
// ===============================
// set purge mask
// ===============================
pSmartcardExtension->ReaderExtension->SerialConfigData.PurgeMask =
SERIAL_PURGE_TXABORT | SERIAL_PURGE_RXABORT |
SERIAL_PURGE_TXCLEAR | SERIAL_PURGE_RXCLEAR;
// ===============================
// clear RTS
// ===============================
status = SCCMN50M_ClearRTS(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_RTS failed ! status = %x\n",status))
goto ExitGetDeviceDescription;
}
Wait(pSmartcardExtension,1);
// ===============================
// set DTR
// ===============================
status = SCCMN50M_SetDTR(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_DRT failed ! status = %x\n",status))
goto ExitGetDeviceDescription;
}
Wait(pSmartcardExtension,1);
// ===============================
// set RTS
// ===============================
status = SCCMN50M_SetRTS(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_RTS failed ! status = %x\n",status))
goto ExitGetDeviceDescription;
}
i=0;
while (1)
{
pSmartcardExtension->ReaderExtension->ToRHConfig = FALSE;
status = SCCMN50M_ReadCardMan(pSmartcardExtension,1,&ulBytesRead,&bByteRead,sizeof(bByteRead));
if (status == STATUS_SUCCESS)
{
abReadBuffer[i++] = bByteRead;
if (bByteRead == 0x29)
{
ulPnPStringLength = i;
break;
}
}
else
{
break;
}
}
if (ulPnPStringLength > 11 )
{
ulExtend = 0;
for (i=0;i<ulPnPStringLength;i++)
{
if (abReadBuffer[i] == 0x5C)
ulExtend++;
if (ulExtend == 4)
{
j = 0;
i++;
while (i < ulPnPStringLength - 3)
{
pSmartcardExtension->ReaderExtension->abDeviceDescription[j] = abReadBuffer[i];
i++;
j++;
}
SmartcardDebug(
DEBUG_DRIVER,
( "%s!Device=%s\n",
pSmartcardExtension->ReaderExtension->abDeviceDescription)
);
break;
}
}
}
// ===================
// restore baud rate
// ===================
pSmartcardExtension->ReaderExtension->SerialConfigData.BaudRate.BaudRate = 38400;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_BAUD_RATE;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.BaudRate.BaudRate,
sizeof(SERIAL_BAUD_RATE));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_BAUD_RATE);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_BAUDRATE failed ! status = %ld\n",status))
goto ExitGetDeviceDescription;
}
// ====================
// retore line control
// ====================
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.StopBits = STOP_BITS_2;
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.Parity = EVEN_PARITY;
pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl.WordLength = 8;
pSmartcardExtension->ReaderExtension->SerialIoControlCode = IOCTL_SERIAL_SET_LINE_CONTROL;
RtlCopyMemory(pSmartcardExtension->SmartcardRequest.Buffer,
&pSmartcardExtension->ReaderExtension->SerialConfigData.LineControl,
sizeof(SERIAL_LINE_CONTROL));
pSmartcardExtension->SmartcardRequest.BufferLength = sizeof(SERIAL_LINE_CONTROL);
pSmartcardExtension->SmartcardReply.BufferLength = 0;
status = SCCMN50M_SerialIo(pSmartcardExtension);
if (!NT_SUCCESS(status))
{
SmartcardDebug(DEBUG_ERROR,("IOCTL_SERIAL_SET_LINE_CONTROL failed ! status = %x\n",status))
goto ExitGetDeviceDescription;
}
ExitGetDeviceDescription:
DebugStatus = SCCMN50M_ResyncCardManII(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{ // map all errors to STATUS_UNSUCCESSFULL;
status = STATUS_UNSUCCESSFUL;
}
SmartcardDebug(
DEBUG_TRACE,
( "%s!GetDeviceDescriptiong: Exit %lx\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_SetSyncParameters(IN PSMARTCARD_EXTENSION pSmartcardExtension )
{
NTSTATUS status = STATUS_SUCCESS;
SmartcardDebug(
DEBUG_TRACE,
( "%s!SetSyncParameters: Enter\n",
DRIVER_NAME)
);
//DBGBreakPoint();
pSmartcardExtension->ReaderExtension->SyncParameters.ulProtocol =
((PSYNC_PARAMETERS)pSmartcardExtension->IoRequest.RequestBuffer)->ulProtocol;
pSmartcardExtension->ReaderExtension->SyncParameters.ulStateResetLineWhileReading =
((PSYNC_PARAMETERS)pSmartcardExtension->IoRequest.RequestBuffer)->ulStateResetLineWhileReading;
pSmartcardExtension->ReaderExtension->SyncParameters.ulStateResetLineWhileWriting =
((PSYNC_PARAMETERS)pSmartcardExtension->IoRequest.RequestBuffer)->ulStateResetLineWhileWriting;
pSmartcardExtension->ReaderExtension->SyncParameters.ulWriteDummyClocks =
((PSYNC_PARAMETERS)pSmartcardExtension->IoRequest.RequestBuffer)->ulWriteDummyClocks;
pSmartcardExtension->ReaderExtension->SyncParameters.ulHeaderLen =
((PSYNC_PARAMETERS)pSmartcardExtension->IoRequest.RequestBuffer)->ulHeaderLen;
// Used for the 2 Wire Protocol. We must make a Card reset after Power On
pSmartcardExtension->ReaderExtension->SyncParameters.fCardResetRequested = TRUE;
// return length of reply
*pSmartcardExtension->IoRequest.Information = 0L;
SmartcardDebug(
DEBUG_TRACE,
( "%s!SetSyncParameters: Exit\n",
DRIVER_NAME)
);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
UCHAR
SCCMN50M_CalcTxControlByte (IN PSMARTCARD_EXTENSION pSmartcardExtension,
IN ULONG ulBitsToWrite )
{
UCHAR bTxControlByte = 0;
if (pSmartcardExtension->ReaderExtension->SyncParameters.ulProtocol == SCARD_PROTOCOL_2WBP)
{
bTxControlByte = CLOCK_FORCED_2WBP;
}
else
{
if (ulBitsToWrite >= 255 * 8)
bTxControlByte |= TRANSMIT_A8;
if (pSmartcardExtension->ReaderExtension->SyncParameters.ulStateResetLineWhileWriting ==
SCARD_RESET_LINE_HIGH)
bTxControlByte |= SYNC_RESET_LINE_HIGH;
}
bTxControlByte |= (BYTE)((ulBitsToWrite-1) & 0x00000007);
return bTxControlByte;
}
//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
UCHAR
SCCMN50M_CalcTxLengthByte (IN PSMARTCARD_EXTENSION pSmartcardExtension,
IN ULONG ulBitsToWrite )
{
UCHAR bTxLengthByte = 0;
bTxLengthByte = (BYTE)( ((ulBitsToWrite - 1) >> 3) + 1);
return bTxLengthByte;
}
//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
UCHAR
SCCMN50M_CalcRxControlByte (IN PSMARTCARD_EXTENSION pSmartcardExtension,
IN ULONG ulBitsToRead )
{
UCHAR bRxControlByte = 0;
if (pSmartcardExtension->ReaderExtension->SyncParameters.ulStateResetLineWhileReading ==
SCARD_RESET_LINE_HIGH)
bRxControlByte |= SYNC_RESET_LINE_HIGH;
if (ulBitsToRead == 0)
{
ulBitsToRead = pSmartcardExtension->ReaderExtension->SyncParameters.ulWriteDummyClocks;
bRxControlByte |= SYNC_DUMMY_RECEIVE;
}
if (ulBitsToRead > 255 * 8)
bRxControlByte |= RECEIVE_A8;
bRxControlByte |= (BYTE)( (ulBitsToRead-1) & 0x00000007);
return bRxControlByte;
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
UCHAR
SCCMN50M_CalcRxLengthByte (IN PSMARTCARD_EXTENSION pSmartcardExtension,
IN ULONG ulBitsToRead )
{
UCHAR bRxLengthByte = 0;
// if (pSmartcardExtension->ReaderExtension->SyncParameters.ulProtocol == SCARD_PROTOCOL_3WBP)
// {
if (ulBitsToRead == 0)
ulBitsToRead = pSmartcardExtension->ReaderExtension->SyncParameters.ulWriteDummyClocks;
bRxLengthByte = (BYTE)( ((ulBitsToRead - 1) >> 3) + 1);
// }
return bRxLengthByte;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_SyncCardPowerOn (
IN PSMARTCARD_EXTENSION pSmartcardExtension
)
{
NTSTATUS status;
UCHAR pbAtrBuffer[MAXIMUM_ATR_LENGTH];
UCHAR abSyncAtrBuffer[MAXIMUM_ATR_LENGTH];
ULONG ulAtrLength = 0;
SmartcardDebug(
DEBUG_TRACE,
( "%s!SyncCardPowerOn: Enter\n",
DRIVER_NAME)
);
status = SCCMN50M_UseSyncStrategy(pSmartcardExtension,
&ulAtrLength,
pbAtrBuffer,
sizeof(pbAtrBuffer));
abSyncAtrBuffer[0] = 0x3B;
abSyncAtrBuffer[1] = 0x04;
MemCpy(&abSyncAtrBuffer[2],
sizeof(abSyncAtrBuffer)-2,
pbAtrBuffer,
ulAtrLength);
ulAtrLength += 2;
MemCpy(pSmartcardExtension->CardCapabilities.ATR.Buffer,
sizeof(pSmartcardExtension->CardCapabilities.ATR.Buffer),
abSyncAtrBuffer,
ulAtrLength);
pSmartcardExtension->CardCapabilities.ATR.Length = (UCHAR)(ulAtrLength);
pSmartcardExtension->ReaderCapabilities.CurrentState = SCARD_SPECIFIC;
pSmartcardExtension->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_T0;
pSmartcardExtension->ReaderExtension->SyncParameters.fCardResetRequested = TRUE;
pSmartcardExtension->ReaderExtension->SyncParameters.fCardPowerRequested = FALSE;
SmartcardDebug(DEBUG_ATR,("ATR of synchronous smart card : %2.2x %2.2x %2.2x %2.2x\n",
pbAtrBuffer[0],pbAtrBuffer[1],pbAtrBuffer[2],pbAtrBuffer[3]));
SmartcardDebug(
DEBUG_TRACE,
( "%s!SyncCardPowerOn: Exit %lx\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_Transmit2WBP(PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS status = STATUS_SUCCESS;
UCHAR bWriteBuffer [128];
UCHAR bReadBuffer [128];
UCHAR bTxControlByte;
UCHAR bTxLengthByte;
UCHAR bRxControlByte;
UCHAR bRxLengthByte;
ULONG ulBytesToWrite;
ULONG ulBytesToRead;
ULONG ulBitsToWrite;
ULONG ulBitsToRead;
ULONG ulBytesRead;
// ULONG ulBitsRead;
ULONG ulBytesStillToRead;
ULONG ulMaxIFSD;
PCHAR pbInData;
SmartcardDebug(
DEBUG_TRACE,
( "%s!Transmit2WBP: Enter\n",
DRIVER_NAME)
);
/*-----------------------------------------------------------------------*/
/** Power smartcard - if smartcard was removed and reinserted **/
/*-----------------------------------------------------------------------*/
if (pSmartcardExtension->ReaderExtension->SyncParameters.fCardPowerRequested == TRUE)
{
status = SCCMN50M_SyncCardPowerOn (pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
goto ExitTransmit2WBP;
}
}
pbInData = pSmartcardExtension->IoRequest.RequestBuffer + sizeof(SYNC_TRANSFER);
ulBitsToWrite = ((PSYNC_TRANSFER)(pSmartcardExtension->IoRequest.RequestBuffer))->ulSyncBitsToWrite;
ulBitsToRead = ((PSYNC_TRANSFER)(pSmartcardExtension->IoRequest.RequestBuffer))->ulSyncBitsToRead;
ulBytesToWrite = ulBitsToWrite/8;
ulBytesToRead = ulBitsToRead/8 + (ulBitsToRead % 8 ? 1 : 0);
/*-----------------------------------------------------------------------*/
// check buffer sizes
/*-----------------------------------------------------------------------*/
ulMaxIFSD = ATTR_MAX_IFSD_CARDMAN_II;
if (ulBytesToRead > ulMaxIFSD ||
ulBytesToRead > pSmartcardExtension->SmartcardReply.BufferSize)
{
status = STATUS_BUFFER_OVERFLOW;
goto ExitTransmit2WBP;
}
if (ulBytesToWrite > pSmartcardExtension->SmartcardRequest.BufferSize)
{
status = STATUS_BUFFER_OVERFLOW;
goto ExitTransmit2WBP;
}
pSmartcardExtension->SmartcardRequest.BufferLength = ulBytesToWrite+1;
/*-----------------------------------------------------------------------*/
// copy data to the Smartcard Request Buffer
/*-----------------------------------------------------------------------*/
(pSmartcardExtension->SmartcardRequest.Buffer)[0] = '\x0F';
MemCpy((pSmartcardExtension->SmartcardRequest.Buffer+1),
pSmartcardExtension->SmartcardRequest.BufferSize,
pbInData,
ulBytesToWrite);
/*-----------------------------------------------------------------------*/
// copy data to the write buffer
/*-----------------------------------------------------------------------*/
MemCpy((bWriteBuffer),
sizeof(bWriteBuffer),
pSmartcardExtension->SmartcardRequest.Buffer,
(ulBytesToWrite+1));
/*-----------------------------------------------------------------------*/
// set SYNC protocol flag for CardMan
/*-----------------------------------------------------------------------*/
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_SYN);
/*-----------------------------------------------------------------------*/
// Header
/*-----------------------------------------------------------------------*/
if (pSmartcardExtension->ReaderExtension->SyncParameters.fCardResetRequested == TRUE)
{
status = SCCMN50M_ResetCard2WBP(pSmartcardExtension);
if (NT_ERROR(status))
{
goto ExitTransmit2WBP;
}
pSmartcardExtension->ReaderExtension->SyncParameters.fCardResetRequested = FALSE;
}
/*-----------------------------------------------------------------------*/
// 1. Send Carman-Header 4-Byte
// 2. Send 0x0F, that builds a HIGH-LOW Edge for 4432 CC
// 3. Send the Data (CC command = 3 Byte)
/*-----------------------------------------------------------------------*/
bTxControlByte = SCCMN50M_CalcTxControlByte(pSmartcardExtension,ulBitsToWrite);
bTxLengthByte = (BYTE)(SCCMN50M_CalcTxLengthByte(pSmartcardExtension,ulBitsToWrite)+1);
bRxControlByte = 0;
bRxLengthByte = 0;
SCCMN50M_SetCardManHeader(pSmartcardExtension,
bTxControlByte,
bTxLengthByte,
bRxControlByte,
bRxLengthByte);
/*-----------------------------------------------------------------------*/
// write data to card
/*-----------------------------------------------------------------------*/
status = SCCMN50M_WriteCardMan (pSmartcardExtension,
(ulBytesToWrite+1),
bWriteBuffer);
if (NT_ERROR(status))
{
goto ExitTransmit2WBP;
}
/*-----------------------------------------------------------------------*/
// read CardMan Header
// no Data from CC received
/*-----------------------------------------------------------------------*/
pSmartcardExtension->ReaderExtension->ToRHConfig = FALSE;
status = SCCMN50M_ReadCardMan(pSmartcardExtension,
2,
&ulBytesRead,
bReadBuffer,
sizeof(bReadBuffer));
if (NT_ERROR(status))
{
goto ExitTransmit2WBP;
}
/*-----------------------------------------------------------------------*/
// 1. Send Carman-Header 4-Byte
// 2. Send 0xF0, that builds a LOW-HIGH Edge for 4432 CC
// 3. Now the receiviing of card-data begins
/*-----------------------------------------------------------------------*/
bTxControlByte = SCCMN50M_CalcTxControlByte(pSmartcardExtension, 8);
bTxLengthByte = SCCMN50M_CalcTxLengthByte(pSmartcardExtension, 8);
bRxControlByte = SCCMN50M_CalcRxControlByte(pSmartcardExtension,ulBitsToRead);
bRxLengthByte = SCCMN50M_CalcRxLengthByte(pSmartcardExtension,ulBitsToRead);
SCCMN50M_SetCardManHeader(pSmartcardExtension,
bTxControlByte,
bTxLengthByte,
bRxControlByte,
bRxLengthByte);
/*-----------------------------------------------------------------------*/
// in this sequnce SCCMN50M_WriteCardMan must not send the Config string.
// write 0xF0 -> is the trigger to read data from card or start the
// processing.
/*-----------------------------------------------------------------------*/
pSmartcardExtension->ReaderExtension->NoConfig = TRUE;
status = SCCMN50M_WriteCardMan (pSmartcardExtension,
1, // one byte to write
"\xF0"); // LOW-HIGH - Edge
if (NT_ERROR(status))
{
goto ExitTransmit2WBP;
}
/*-----------------------------------------------------------------------*/
// read CardMan Header
// Data from CC received will be received
/*-----------------------------------------------------------------------*/
pSmartcardExtension->ReaderExtension->ToRHConfig = FALSE;
status = SCCMN50M_ReadCardMan(pSmartcardExtension,
2,
&ulBytesRead,
bReadBuffer,
sizeof(bReadBuffer));
if (NT_ERROR(status))
{
goto ExitTransmit2WBP;
}
/*-----------------------------------------------------------------------*/
// Read the data string
/*-----------------------------------------------------------------------*/
ulBytesStillToRead = (ULONG)bReadBuffer[1];
if (bReadBuffer[0] & RECEIVE_A8)
ulBytesStillToRead += 256;
status = SCCMN50M_ReadCardMan(pSmartcardExtension,
ulBytesStillToRead,
&ulBytesRead,
bReadBuffer,
sizeof(bReadBuffer));
if (NT_ERROR(status))
{
goto ExitTransmit2WBP;
}
/*-----------------------------------------------------------------------*/
/** calculate data length in bits - this value is not used **/
/*-----------------------------------------------------------------------*/
// ulBitsRead = ((ulBytesRead-1) * 8) + ((ulBitsToRead-1 ) & 0x00000007) + 1;
/*-----------------------------------------------------------------------*/
/** shift the bits in the last byte to the correct position **/
/*-----------------------------------------------------------------------*/
bReadBuffer[ulBytesRead-1] >>= (7 - ((ulBitsToRead-1) & 0x00000007));
/*-----------------------------------------------------------------------*/
// the first bit of the returned string is lost
// so we must shift the whole data string one bit left
// the first bit of the first data byte is lost while reading
// this bit maybe incorrect
/*-----------------------------------------------------------------------*/
SCCMN50M_Shift_Msg(bReadBuffer, ulBytesRead);
/*-----------------------------------------------------------------------*/
// copy received bytes to Smartcard Reply Buffer
/*-----------------------------------------------------------------------*/
MemCpy(pSmartcardExtension->SmartcardReply.Buffer,
pSmartcardExtension->SmartcardReply.BufferSize,
bReadBuffer,
ulBytesRead);
pSmartcardExtension->SmartcardReply.BufferLength = ulBytesRead;
/*-----------------------------------------------------------------------*/
// copy received bytes to IoReply Buffer
/*-----------------------------------------------------------------------*/
MemCpy(pSmartcardExtension->IoRequest.ReplyBuffer,
pSmartcardExtension->IoRequest.ReplyBufferLength,
pSmartcardExtension->SmartcardReply.Buffer,
ulBytesRead);
*(pSmartcardExtension->IoRequest.Information) = ulBytesRead;
ExitTransmit2WBP:
SmartcardDebug(
DEBUG_TRACE,
( "%s!Transmit2WBP: Exit\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
VOID
SCCMN50M_Shift_Msg (PUCHAR pbBuffer,
ULONG ulMsgLen)
{
UCHAR bTmp1, bTmp2;
int i;
for (i=(int)ulMsgLen-1; i>=0; i--)
{
bTmp1=(BYTE)((pbBuffer[i] >> 7) & 0x01); /* bTmp1 = bit 7 naechstes byte */
if (i+1 != (int)ulMsgLen)
{
bTmp2=(BYTE)((pbBuffer[i+1] << 1) | bTmp1);
pbBuffer[i+1] = bTmp2;
}
}
pbBuffer[0] = (BYTE)(pbBuffer[0] << 1);
return;
}
/*****************************************************************************
Routine Description:
Reset Card 4442
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_ResetCard2WBP(IN PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS status = STATUS_SUCCESS;
BYTE bBuffer[10];
ULONG ulBytesRead;
/*-----------------------------------------------------------------------*/
// Enter Card Reset
/*-----------------------------------------------------------------------*/
SmartcardDebug(
DEBUG_TRACE,
( "%s!ResetCard2WBP: Enter\n",
DRIVER_NAME)
);
/*-----------------------------------------------------------------------*/
// bTxControlByte = 0;
// bTxLengthByte = 0;
// bRxControlByte = RESET_CARD;
// bRxLengthByte = 5;
/*-----------------------------------------------------------------------*/
SCCMN50M_SetCardManHeader(pSmartcardExtension,
0, // bTxControlByte
0, // bTxLengthByte
COLD_RESET, // bRxControlByte
5); // bRxLengthByte
/*-----------------------------------------------------------------------*/
// write data to card
/*-----------------------------------------------------------------------*/
status = SCCMN50M_WriteCardMan (pSmartcardExtension,
0,
NULL);
if (NT_ERROR(status))
{
goto ExitResetCard2WBP;
}
/*-----------------------------------------------------------------------*/
// read CardMan Header
/*-----------------------------------------------------------------------*/
pSmartcardExtension->ReaderExtension->ToRHConfig = FALSE;
status = SCCMN50M_ReadCardMan(pSmartcardExtension,
2, &ulBytesRead, bBuffer, sizeof(bBuffer));
if (NT_ERROR(status))
{
goto ExitResetCard2WBP;
}
if (bBuffer[1] != 5)
{
status = !STATUS_SUCCESS;
goto ExitResetCard2WBP;
}
/*-----------------------------------------------------------------------*/
// read ATR
/*-----------------------------------------------------------------------*/
status = SCCMN50M_ReadCardMan(pSmartcardExtension,
5, &ulBytesRead, bBuffer, sizeof(bBuffer));
if (NT_ERROR(status))
{
goto ExitResetCard2WBP;
}
SmartcardDebug(DEBUG_ATR,("%s!Card Reset ATR : %02x %02x %02x %02x\n",
DRIVER_NAME,bBuffer[0],bBuffer[1],bBuffer[2],bBuffer[3]));
ExitResetCard2WBP:
SmartcardDebug(
DEBUG_TRACE,
( "%s!ResetCard2WBP: Exit %lx\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_Transmit3WBP(PSMARTCARD_EXTENSION pSmartcardExtension)
{
NTSTATUS status = STATUS_SUCCESS;
UCHAR bWriteBuffer [128];
UCHAR bReadBuffer [128];
UCHAR bTxControlByte;
UCHAR bTxLengthByte;
UCHAR bRxControlByte;
UCHAR bRxLengthByte;
ULONG ulBytesToWrite;
ULONG ulBytesToRead;
ULONG ulBitsToWrite;
ULONG ulBitsToRead;
ULONG ulBytesRead;
// ULONG ulBitsRead;
ULONG ulBytesStillToRead;
ULONG ulMaxIFSD;
PCHAR pbInData;
SmartcardDebug(
DEBUG_TRACE,
( "%s!Transmit3WBP: Enter\n",
DRIVER_NAME)
);
// DBGBreakPoint();
/*-----------------------------------------------------------------------*/
/** Power smartcard - if smartcard was removed and reinserted **/
/*-----------------------------------------------------------------------*/
if (pSmartcardExtension->ReaderExtension->SyncParameters.fCardPowerRequested == TRUE)
{
status = SCCMN50M_SyncCardPowerOn (pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
goto ExitTransmit3WBP;
}
}
pbInData = pSmartcardExtension->IoRequest.RequestBuffer + sizeof(SYNC_TRANSFER);
ulBitsToWrite = ((PSYNC_TRANSFER)(pSmartcardExtension->IoRequest.RequestBuffer))->ulSyncBitsToWrite;
ulBitsToRead = ((PSYNC_TRANSFER)(pSmartcardExtension->IoRequest.RequestBuffer))->ulSyncBitsToRead;
ulBytesToWrite = ulBitsToWrite/8;
ulBytesToRead = ulBitsToRead/8 + (ulBitsToRead % 8 ? 1 : 0);
/*-----------------------------------------------------------------------*/
// check buffer sizes
/*-----------------------------------------------------------------------*/
ulMaxIFSD = ATTR_MAX_IFSD_CARDMAN_II;
if (ulBytesToRead > ulMaxIFSD ||
ulBytesToRead > pSmartcardExtension->SmartcardReply.BufferSize)
{
status = STATUS_BUFFER_OVERFLOW;
goto ExitTransmit3WBP;
}
if (ulBytesToWrite > pSmartcardExtension->SmartcardRequest.BufferSize)
{
status = STATUS_BUFFER_OVERFLOW;
goto ExitTransmit3WBP;
}
pSmartcardExtension->SmartcardRequest.BufferLength = ulBytesToWrite;
/*-----------------------------------------------------------------------*/
// copy data to the Smartcard Request Buffer
/*-----------------------------------------------------------------------*/
MemCpy(pSmartcardExtension->SmartcardRequest.Buffer,
pSmartcardExtension->SmartcardRequest.BufferSize,
pbInData,
ulBytesToWrite);
/*-----------------------------------------------------------------------*/
// copy data to the write buffer
/*-----------------------------------------------------------------------*/
MemCpy(bWriteBuffer,
sizeof(bWriteBuffer),
pSmartcardExtension->SmartcardRequest.Buffer,
ulBytesToWrite);
/*-----------------------------------------------------------------------*/
// set SYNC protocol flag for CardMan
/*-----------------------------------------------------------------------*/
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_SYN);
/*-----------------------------------------------------------------------*/
// build cardman header
/*-----------------------------------------------------------------------*/
bTxControlByte = SCCMN50M_CalcTxControlByte(pSmartcardExtension,ulBitsToWrite);
bTxLengthByte = SCCMN50M_CalcTxLengthByte(pSmartcardExtension,ulBitsToWrite);
bRxControlByte = SCCMN50M_CalcRxControlByte(pSmartcardExtension,ulBitsToRead);
bRxLengthByte = SCCMN50M_CalcRxLengthByte(pSmartcardExtension,ulBitsToRead);
SCCMN50M_SetCardManHeader(pSmartcardExtension,
bTxControlByte,
bTxLengthByte,
bRxControlByte,
bRxLengthByte);
/*-----------------------------------------------------------------------*/
/** write data to card **/
/*-----------------------------------------------------------------------*/
status = SCCMN50M_WriteCardMan (pSmartcardExtension,
ulBytesToWrite,
bWriteBuffer);
if (NT_ERROR(status))
{
goto ExitTransmit3WBP;
}
/*-----------------------------------------------------------------------*/
/** read CardMan Header **/
/*-----------------------------------------------------------------------*/
pSmartcardExtension->ReaderExtension->ToRHConfig = FALSE;
status = SCCMN50M_ReadCardMan(pSmartcardExtension,2,&ulBytesRead,bReadBuffer,sizeof(bReadBuffer));
if (NT_ERROR(status))
{
goto ExitTransmit3WBP;
}
/*-----------------------------------------------------------------------*/
// calc data length to receive
/*-----------------------------------------------------------------------*/
ulBytesStillToRead = (ULONG)(bReadBuffer[1]);
if (bReadBuffer[0] & RECEIVE_A8)
ulBytesStillToRead += 256;
// read data from card
status = SCCMN50M_ReadCardMan(pSmartcardExtension,
ulBytesStillToRead,
&ulBytesRead,
bReadBuffer,
sizeof(bReadBuffer));
if (NT_ERROR(status))
{
goto ExitTransmit3WBP;
}
/*-----------------------------------------------------------------------*/
// calculate data length in bits - this value is not used
/*-----------------------------------------------------------------------*/
// ulBitsRead = ((ulBytesRead-1) * 8) + ((ulBitsToRead-1 ) & 0x00000007) + 1;
/*-----------------------------------------------------------------------*/
// shift the bits in the last byte to the correct position
/*-----------------------------------------------------------------------*/
bReadBuffer[ulBytesRead-1] >>= (7 - ((ulBitsToRead-1) & 0x00000007));
/*-----------------------------------------------------------------------*/
// copy received bytes to Smartcard Reply Buffer
/*-----------------------------------------------------------------------*/
MemCpy(pSmartcardExtension->SmartcardReply.Buffer,
pSmartcardExtension->SmartcardReply.BufferSize,
bReadBuffer,
ulBytesRead);
pSmartcardExtension->SmartcardReply.BufferLength = ulBytesRead;
/*-----------------------------------------------------------------------*/
// copy received bytes to IoReply Buffer
// this Memcpy should respond to SmartcardRawReply function
/*-----------------------------------------------------------------------*/
MemCpy(pSmartcardExtension->IoRequest.ReplyBuffer,
pSmartcardExtension->IoRequest.ReplyBufferLength,
pSmartcardExtension->SmartcardReply.Buffer,
ulBytesRead);
*pSmartcardExtension->IoRequest.Information = ulBytesRead;
ExitTransmit3WBP:
SmartcardDebug(
DEBUG_TRACE,
( "%s!Transmit3WBP: Exit %lx\n",
DRIVER_NAME,status)
);
return status;
}
/*****************************************************************************
Routine Description:
This function powers a synchronous smart card.
Arguments:
Return Value:
*****************************************************************************/
NTSTATUS
SCCMN50M_UseSyncStrategy (
IN PSMARTCARD_EXTENSION pSmartcardExtension,
OUT PULONG pulAtrLength,
OUT PUCHAR pbAtrBuffer,
IN ULONG ulAtrBufferSize
)
{
NTSTATUS status;
NTSTATUS DebugStatus;
UCHAR bReadBuffer[SCARD_ATR_LENGTH];
ULONG ulBytesRead;
SmartcardDebug(
DEBUG_TRACE,
( "%s!UseSyncStrategy: Enter\n",
DRIVER_NAME)
);
//DBGBreakPoint();
SCCMN50M_SetCardManHeader(pSmartcardExtension,0,0,SYNC_ATR_RX_CONTROL,ATR_LEN_SYNC);
pSmartcardExtension->ReaderExtension->CardManConfig.ResetDelay = SYNC_RESET_DELAY;
pSmartcardExtension->ReaderExtension->CardManConfig.CardStopBits = 0x02;
SCCMN50M_ClearCardControlFlags(pSmartcardExtension,ALL_FLAGS);
SCCMN50M_SetSCRControlFlags(pSmartcardExtension,CARD_POWER| IGNORE_PARITY );
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_SYN);
status = SCCMN50M_ResyncCardManII(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
goto ExitPowerSynchronousCard;
}
// write config + header
status = SCCMN50M_WriteCardMan(pSmartcardExtension,0,NULL);
if (status != STATUS_SUCCESS)
{
goto ExitPowerSynchronousCard;
}
pSmartcardExtension->ReaderExtension->ToRHConfig = FALSE;
// read state and length
status = SCCMN50M_ReadCardMan(pSmartcardExtension,2,&ulBytesRead,bReadBuffer,sizeof(bReadBuffer));
if (status != STATUS_SUCCESS)
{
goto ExitPowerSynchronousCard;
}
if (bReadBuffer[1] < MIN_ATR_LEN )
{
// read all remaining bytes from the CardMan
DebugStatus = SCCMN50M_ReadCardMan(pSmartcardExtension,bReadBuffer[1],&ulBytesRead,bReadBuffer,sizeof(bReadBuffer));
status = STATUS_UNRECOGNIZED_MEDIA;
goto ExitPowerSynchronousCard;
}
if (bReadBuffer[1] > ulAtrBufferSize)
{
status = STATUS_BUFFER_OVERFLOW;
goto ExitPowerSynchronousCard;
}
// read ATR
status = SCCMN50M_ReadCardMan(pSmartcardExtension,bReadBuffer[1],pulAtrLength,pbAtrBuffer,ulAtrBufferSize);
if (status != STATUS_SUCCESS)
{
goto ExitPowerSynchronousCard;
}
if (pbAtrBuffer[0] == 0x00 ||
pbAtrBuffer[0] == 0xff )
{
status = STATUS_UNRECOGNIZED_MEDIA;
goto ExitPowerSynchronousCard;
}
pSmartcardExtension->ReaderExtension->fRawModeNecessary = TRUE;
ExitPowerSynchronousCard:
SmartcardDebug(
DEBUG_TRACE,
( "%s!UseSyncStrategy: Exit %lx\n",
DRIVER_NAME,status)
);
SCCMN50M_ClearSCRControlFlags(pSmartcardExtension,IGNORE_PARITY | CM2_GET_ATR);
SCCMN50M_ClearCardManHeader(pSmartcardExtension);
return status;
}
/*****************************************************************************
Routine Description:
This function checks if the inserted card is a synchronous one
Arguments:
Return Value:
*****************************************************************************/
BOOLEAN
SCCMN50M_IsAsynchronousSmartCard(
IN PSMARTCARD_EXTENSION pSmartcardExtension
)
{
NTSTATUS status;
UCHAR ReadBuffer[3];
ULONG ulBytesRead;
BOOLEAN fIsAsynchronousSmartCard = TRUE;
UCHAR abATR[33];
SmartcardDebug(
DEBUG_TRACE,
( "%s!IsAsynchronousSmartcard: Enter \n",
DRIVER_NAME)
);
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant = 200;
// 3MHz smart card ?
SCCMN50M_SetCardManHeader(pSmartcardExtension,0,0,0,1);
SCCMN50M_ClearCardControlFlags(pSmartcardExtension,ALL_FLAGS);
SCCMN50M_SetSCRControlFlags(pSmartcardExtension,CARD_POWER| IGNORE_PARITY | CM2_GET_ATR);
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_3MHZ);
// write config + header
status = SCCMN50M_WriteCardMan(pSmartcardExtension,0,NULL);
if (status != STATUS_SUCCESS)
{
goto ExitIsAsynchronousSmartCard;
}
pSmartcardExtension->ReaderExtension->ToRHConfig = FALSE;
// read state and length
status = SCCMN50M_ReadCardMan(pSmartcardExtension,2,&ulBytesRead,ReadBuffer,sizeof(ReadBuffer));
if (status == STATUS_SUCCESS &&
ReadBuffer[1] == 0x01 )
{
goto ExitIsAsynchronousSmartCard;
}
// ---------------------------------------
// power off card
// ---------------------------------------
status = SCCMN50M_PowerOff(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
goto ExitIsAsynchronousSmartCard;
}
// 5MHz smart card ?
SCCMN50M_SetCardManHeader(pSmartcardExtension,0,0,0,1);
SCCMN50M_ClearCardControlFlags(pSmartcardExtension,ALL_FLAGS);
SCCMN50M_SetSCRControlFlags(pSmartcardExtension,CARD_POWER| IGNORE_PARITY | CM2_GET_ATR);
SCCMN50M_SetCardControlFlags(pSmartcardExtension,ENABLE_5MHZ);
// write config + header
status = SCCMN50M_WriteCardMan(pSmartcardExtension,0,NULL);
if (status != STATUS_SUCCESS)
{
goto ExitIsAsynchronousSmartCard;
}
pSmartcardExtension->ReaderExtension->ToRHConfig = FALSE;
// read state and length
status = SCCMN50M_ReadCardMan(pSmartcardExtension,2,&ulBytesRead,ReadBuffer,sizeof(ReadBuffer));
if (status == STATUS_SUCCESS &&
ReadBuffer[1] == 0x01 )
{
goto ExitIsAsynchronousSmartCard;
}
// now we assume that it is a synchronous smart card
fIsAsynchronousSmartCard = FALSE;
// ---------------------------------------
// power off card
// ---------------------------------------
status = SCCMN50M_PowerOff(pSmartcardExtension);
if (status != STATUS_SUCCESS)
{
goto ExitIsAsynchronousSmartCard;
}
ExitIsAsynchronousSmartCard:
pSmartcardExtension->ReaderExtension->SerialConfigData.Timeouts.ReadTotalTimeoutConstant = DEFAULT_READ_TOTAL_TIMEOUT_CONSTANT;
SmartcardDebug(
DEBUG_TRACE,
( "%s!IsAsynchronousSmartcard: Exit \n",
DRIVER_NAME)
);
return fIsAsynchronousSmartCard;
}
/*****************************************************************************
* History:
* $Log: sccmcb.c $
* Revision 1.7 2001/01/22 08:39:41 WFrischauf
* No comment given
*
* Revision 1.6 2000/09/25 10:46:22 WFrischauf
* No comment given
*
* Revision 1.5 2000/08/24 09:05:44 TBruendl
* No comment given
*
* Revision 1.4 2000/08/16 08:24:04 TBruendl
* warning :uninitialized memory removed
*
* Revision 1.3 2000/07/28 09:24:12 TBruendl
* Changes for OMNIKEY on Whistler CD
*
* Revision 1.16 2000/06/27 11:56:28 TBruendl
* workaraound for SAMOR smart cards with invalid ATR (ITSEC)
*
* Revision 1.15 2000/06/08 10:08:47 TBruendl
* bug fix : warm reset for ScfW
*
* Revision 1.14 2000/05/23 09:58:26 TBruendl
* OMNIKEY 3.0.0.1
*
* Revision 1.13 2000/04/13 08:07:22 TBruendl
* PPS bug fix for SCfW
*
* Revision 1.12 2000/04/04 07:52:18 TBruendl
* problem with the new WfsC fixed
*
* Revision 1.11 2000/03/03 09:50:50 TBruendl
* No comment given
*
* Revision 1.10 2000/03/01 09:32:04 TBruendl
* R02.20.0
*
* Revision 1.9 2000/01/04 10:40:33 TBruendl
* bug fix: status instead of DebugStatus used
*
* Revision 1.8 1999/12/16 14:10:16 TBruendl
* After transparent mode has been left, the status is read from the CardMan to be sure that
* the new settings are effective.
*
* Revision 1.6 1999/12/13 07:55:38 TBruendl
* Bug fix for P+ druing initialization
* PTS for 4.9 mhz smartcards added
*
* Revision 1.5 1999/11/04 07:53:21 WFrischauf
* bug fixes due to error reports 2 - 7
*
* Revision 1.4 1999/07/12 12:49:04 TBruendl
* Bug fix: Resync after GET_DEVICE_DESCRIPTION
* Power On SLE4428
*
* Revision 1.3 1999/06/10 09:03:57 TBruendl
* No comment given
*
* Revision 1.2 1999/02/25 10:12:22 TBruendl
* No comment given
*
* Revision 1.1 1999/02/02 13:34:37 TBruendl
* This is the first release (R01.00) of the IFD handler for CardMan running under NT5.0.
*
*
*****************************************************************************/