2101 lines
55 KiB
C++
2101 lines
55 KiB
C++
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <conio.h>
|
|
|
|
#include <afx.h>
|
|
#include <afxtempl.h>
|
|
|
|
#include <winioctl.h>
|
|
#include <winsmcrd.h>
|
|
|
|
#include "ifdtest.h"
|
|
|
|
class CCardProvider *CCardProvider::s_pFirst;
|
|
|
|
#define INSERT_CARD "Please insert smart card"
|
|
#define REMOVE_CARD "Please remove smart card"
|
|
|
|
PCHAR
|
|
CAtr::GetAtrString(
|
|
PCHAR in_pchBuffer
|
|
)
|
|
{
|
|
for (ULONG i = 0; i < m_uAtrLength; i++) {
|
|
|
|
sprintf(in_pchBuffer + i * 3, "%02X ", m_rgbAtr[i]);
|
|
}
|
|
|
|
return in_pchBuffer;
|
|
}
|
|
|
|
CCardProvider::CCardProvider(
|
|
void
|
|
)
|
|
{
|
|
m_pNext = NULL;
|
|
m_uTestNo = 0;
|
|
m_bCardTested = FALSE;
|
|
m_bTestFailed = FALSE;
|
|
m_pSetProtocol = NULL;
|
|
m_pCardTest = NULL;
|
|
}
|
|
|
|
CCardProvider::CCardProvider(
|
|
void (*in_pEntryFunction)(class CCardProvider&)
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Constructor for class CCardProvider.
|
|
This constructor is called for every card that is to be tested.
|
|
It creates a new instance and appends it to a singly linked list
|
|
|
|
Arguments:
|
|
|
|
Pointer to function that registers all test functions
|
|
|
|
--*/
|
|
{
|
|
class CCardProvider *l_pCardProvider;
|
|
|
|
*this = CCardProvider();
|
|
|
|
if (s_pFirst == NULL) {
|
|
|
|
s_pFirst = new CCardProvider;
|
|
l_pCardProvider = s_pFirst;
|
|
|
|
} else {
|
|
|
|
l_pCardProvider = s_pFirst;
|
|
|
|
while (l_pCardProvider->m_pNext) {
|
|
|
|
l_pCardProvider = l_pCardProvider->m_pNext;
|
|
}
|
|
|
|
l_pCardProvider->m_pNext = new CCardProvider;
|
|
l_pCardProvider = l_pCardProvider->m_pNext;
|
|
}
|
|
|
|
(*in_pEntryFunction)(*l_pCardProvider);
|
|
}
|
|
|
|
BOOL
|
|
CCardProvider::CardsUntested(
|
|
void
|
|
)
|
|
{
|
|
class CCardProvider *l_pCCardProvider = s_pFirst;
|
|
|
|
while (l_pCCardProvider) {
|
|
|
|
if (l_pCCardProvider->m_bCardTested == FALSE) {
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
l_pCCardProvider = l_pCCardProvider->m_pNext;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
CCardProvider::CardTest(
|
|
class CReader& io_pCReader,
|
|
ULONG in_uTestNo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Calls every registered card provider in the list until one of
|
|
the providers indicates that it recognized the card
|
|
|
|
Arguments:
|
|
|
|
io_pCReader - reference to the test structure
|
|
|
|
Return Value:
|
|
|
|
IFDSTATUS value
|
|
|
|
--*/
|
|
{
|
|
class CCardProvider *l_pCCardProvider = s_pFirst;
|
|
ULONG l_uStatus;
|
|
|
|
while (l_pCCardProvider) {
|
|
|
|
if ( l_pCCardProvider->IsValidAtr(io_pCReader.GetAtr()) ) {
|
|
|
|
if (l_pCCardProvider->m_bCardTested) {
|
|
|
|
// We tested this card already
|
|
LogMessage("Card has been tested already. Please remove the card");
|
|
return;
|
|
}
|
|
|
|
l_pCCardProvider->m_bCardTested = TRUE;
|
|
LogMessage(
|
|
"\nTesting card %s",
|
|
(LPCSTR) l_pCCardProvider->m_CCardName
|
|
);
|
|
|
|
if (l_pCCardProvider->m_pSetProtocol == NULL) {
|
|
|
|
return;
|
|
}
|
|
|
|
// Call card provider function
|
|
l_uStatus = (*l_pCCardProvider->m_pSetProtocol)(
|
|
*l_pCCardProvider,
|
|
io_pCReader
|
|
);
|
|
|
|
if (l_uStatus == IFDSTATUS_END) {
|
|
|
|
return;
|
|
}
|
|
|
|
if (l_uStatus != IFDSTATUS_SUCCESS) {
|
|
|
|
return;
|
|
}
|
|
|
|
// Check if the card test function pointer exists
|
|
if (l_pCCardProvider->m_pCardTest == NULL) {
|
|
|
|
return;
|
|
}
|
|
|
|
if (in_uTestNo) {
|
|
|
|
// user wants to run only a single test
|
|
l_pCCardProvider->m_uTestNo = in_uTestNo;
|
|
|
|
LogMessage("Test No. %2d", l_pCCardProvider->m_uTestNo);
|
|
|
|
// Call card provider function
|
|
l_uStatus = (*l_pCCardProvider->m_pCardTest)(
|
|
*l_pCCardProvider,
|
|
io_pCReader
|
|
);
|
|
|
|
return;
|
|
}
|
|
|
|
// run the whole test set
|
|
for (l_pCCardProvider->m_uTestNo = 1; ;l_pCCardProvider->m_uTestNo++) {
|
|
|
|
LogMessage("Test No. %2d", l_pCCardProvider->m_uTestNo);
|
|
|
|
// Call card provider function
|
|
l_uStatus = (*l_pCCardProvider->m_pCardTest)(
|
|
*l_pCCardProvider,
|
|
io_pCReader
|
|
);
|
|
|
|
if (l_uStatus != IFDSTATUS_SUCCESS) {
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
l_pCCardProvider = l_pCCardProvider->m_pNext;
|
|
}
|
|
|
|
PCHAR l_rgbAtrBuffer = new CHAR[256];
|
|
|
|
LogMessage("Card unknown!");
|
|
LogMessage(" CURRENT CARD");
|
|
LogMessage(" %s", io_pCReader.GetAtrString(l_rgbAtrBuffer));
|
|
|
|
for (l_pCCardProvider = s_pFirst;
|
|
l_pCCardProvider;
|
|
l_pCCardProvider = l_pCCardProvider->m_pNext) {
|
|
|
|
if (l_pCCardProvider->m_bCardTested == FALSE) {
|
|
|
|
LogMessage(" * %s", (LPCSTR) l_pCCardProvider->m_CCardName);
|
|
for (int i = 0; i < MAX_NUM_ATR && l_pCCardProvider->m_CAtr[i].GetLength(); i++) {
|
|
|
|
LogMessage(" %s", l_pCCardProvider->m_CAtr[i].GetAtrString(l_rgbAtrBuffer));
|
|
}
|
|
}
|
|
}
|
|
|
|
delete l_rgbAtrBuffer;
|
|
|
|
LogMessage("Please remove card");
|
|
}
|
|
|
|
void
|
|
CCardProvider::ListUntestedCards(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Prints a list of all cards that have not been tested
|
|
|
|
--*/
|
|
{
|
|
class CCardProvider *l_pCCardProvider = s_pFirst;
|
|
|
|
while (l_pCCardProvider) {
|
|
|
|
if (l_pCCardProvider->m_bCardTested == FALSE) {
|
|
|
|
LogMessage(" * %s", (LPCSTR) l_pCCardProvider->m_CCardName);
|
|
}
|
|
|
|
l_pCCardProvider = l_pCCardProvider->m_pNext;
|
|
}
|
|
}
|
|
|
|
void
|
|
CCardProvider::SetAtr(
|
|
BYTE in_rgbAtr[],
|
|
ULONG in_uAtrLength
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Sets the ATR of the card
|
|
|
|
Arguments:
|
|
in_rgchAtr - the atr string
|
|
in_uAtrLength - length of the atr
|
|
|
|
--*/
|
|
{
|
|
for (int i = 0; i < MAX_NUM_ATR; i++) {
|
|
|
|
if (m_CAtr[i].GetLength() == 0) {
|
|
|
|
m_CAtr[i] = CAtr(in_rgbAtr, in_uAtrLength);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
CCardProvider::SetCardName(
|
|
CHAR in_rgchCardName[]
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Sets a friendly name for the card
|
|
|
|
Arguments:
|
|
in_rgchCardName - Friendly name for the card
|
|
|
|
--*/
|
|
{
|
|
m_CCardName = in_rgchCardName;
|
|
}
|
|
|
|
void
|
|
CheckCardMonitor(
|
|
CReader &in_CReader
|
|
)
|
|
{
|
|
ULONG l_lResult, l_uReplyLength, l_lTestNo = 1;
|
|
time_t l_lStartTime;
|
|
BOOL l_bResult;
|
|
OVERLAPPED l_Ovr;
|
|
HANDLE l_hReader = in_CReader.GetHandle();
|
|
|
|
l_Ovr.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
ResetEvent(l_Ovr.hEvent);
|
|
|
|
LogMessage("=============================");
|
|
LogMessage("Part A: Checking card monitor");
|
|
LogMessage("=============================");
|
|
|
|
LogMessage(" << %s", REMOVE_CARD);
|
|
in_CReader.WaitForCardRemoval();
|
|
TestStart("%2d. %s", l_lTestNo++, INSERT_CARD);
|
|
l_lResult = in_CReader.WaitForCardInsertion();
|
|
TEST_CHECK_SUCCESS("Reader failed card insertion monitor", l_lResult);
|
|
TestEnd();
|
|
|
|
TestStart("%2d. IOCTL_SMARTCARD_IS_PRESENT", l_lTestNo++);
|
|
l_bResult = DeviceIoControl (
|
|
l_hReader,
|
|
IOCTL_SMARTCARD_IS_PRESENT,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0,
|
|
&l_uReplyLength,
|
|
&l_Ovr
|
|
);
|
|
|
|
TestCheck(
|
|
l_bResult == TRUE,
|
|
"DeviceIoControl should return TRUE with card inserted"
|
|
);
|
|
TestEnd();
|
|
|
|
TestStart("%2d. %s", l_lTestNo++, REMOVE_CARD);
|
|
l_lResult = in_CReader.WaitForCardRemoval();
|
|
TEST_CHECK_SUCCESS("Reader failed card removal monitor", l_lResult);
|
|
TestEnd();
|
|
|
|
TestStart("%2d. IOCTL_SMARTCARD_IS_ABSENT", l_lTestNo++);
|
|
l_bResult = DeviceIoControl (
|
|
l_hReader,
|
|
IOCTL_SMARTCARD_IS_ABSENT,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0,
|
|
&l_uReplyLength,
|
|
&l_Ovr
|
|
);
|
|
|
|
TestCheck(
|
|
l_bResult == TRUE,
|
|
"DeviceIoControl should return TRUE with card removed"
|
|
);
|
|
TestEnd();
|
|
|
|
TestStart("%2d. Insert and remove a smart card repeatedly", l_lTestNo++);
|
|
|
|
for (l_lStartTime = time(NULL); time(NULL) - l_lStartTime < 15;) {
|
|
|
|
l_lResult = in_CReader.ColdResetCard();
|
|
#ifdef insert_remove_alternate
|
|
l_bResult = DeviceIoControl (
|
|
l_hReader,
|
|
IOCTL_SMARTCARD_IS_PRESENT,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0,
|
|
&l_uReplyLength,
|
|
&l_Ovr
|
|
);
|
|
|
|
SetLastError(0);
|
|
|
|
l_bResult = GetOverlappedResult(
|
|
l_hReader,
|
|
&l_Ovr,
|
|
&l_uReplyLength,
|
|
FALSE
|
|
);
|
|
|
|
l_lResult = GetLastError();
|
|
|
|
TestCheck(
|
|
l_bResult == TRUE && l_lResult == ERROR_SUCCESS ||
|
|
l_bResult == FALSE &&
|
|
(l_lResult == ERROR_IO_INCOMPLETE ||
|
|
l_lResult == ERROR_BUSY ||
|
|
l_lResult == ERROR_IO_PENDING),
|
|
"Reader failed card insertion monitor.\nReturned %2lxH",
|
|
l_lResult
|
|
);
|
|
|
|
l_bResult = DeviceIoControl (
|
|
l_hReader,
|
|
IOCTL_SMARTCARD_IS_ABSENT,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0,
|
|
&l_uReplyLength,
|
|
&l_Ovr
|
|
);
|
|
|
|
SetLastError(0);
|
|
|
|
l_bResult = GetOverlappedResult(
|
|
l_hReader,
|
|
&l_Ovr,
|
|
&l_uReplyLength,
|
|
FALSE
|
|
);
|
|
|
|
l_lResult = GetLastError();
|
|
|
|
TestCheck(
|
|
l_bResult == TRUE && l_lResult == ERROR_SUCCESS ||
|
|
l_bResult == FALSE &&
|
|
(l_lResult == ERROR_IO_INCOMPLETE ||
|
|
l_lResult == ERROR_BUSY ||
|
|
l_lResult == ERROR_IO_PENDING),
|
|
"Reader failed card removal monitor:\nReturned %2lxH",
|
|
l_lResult
|
|
);
|
|
#endif
|
|
}
|
|
#ifdef insert_remove_alternate
|
|
l_bResult = GetOverlappedResult(
|
|
l_hReader,
|
|
&l_Ovr,
|
|
&l_uReplyLength,
|
|
TRUE
|
|
);
|
|
#endif
|
|
TestEnd();
|
|
|
|
LogMessage("Press any key to continue");
|
|
_getch();
|
|
|
|
if (ReaderFailed()) {
|
|
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
void
|
|
CheckReader(
|
|
CReader &in_CReader
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Checks the attributes of a reader.
|
|
Once with card inserted and then without
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
BOOL l_bResult;
|
|
ULONG l_iIndex, l_uReplyLength, l_lTestNo = 1, l_uStart, l_uEnd;
|
|
OVERLAPPED l_Ovr;
|
|
UCHAR l_rgbReplyBuffer[512];
|
|
HANDLE l_hReader = in_CReader.GetHandle();
|
|
|
|
l_Ovr.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
ResetEvent(l_Ovr.hEvent);
|
|
|
|
#define ATTR(x) #x, x
|
|
|
|
struct {
|
|
|
|
PCHAR m_pchName;
|
|
ULONG m_uType;
|
|
|
|
} l_aAttr[] = {
|
|
|
|
ATTR(SCARD_ATTR_VENDOR_NAME),
|
|
ATTR(SCARD_ATTR_VENDOR_IFD_TYPE),
|
|
ATTR(SCARD_ATTR_DEVICE_UNIT),
|
|
ATTR(SCARD_ATTR_ATR_STRING),
|
|
ATTR(SCARD_ATTR_DEFAULT_CLK),
|
|
ATTR(SCARD_ATTR_MAX_CLK),
|
|
ATTR(SCARD_ATTR_DEFAULT_DATA_RATE),
|
|
ATTR(SCARD_ATTR_MAX_DATA_RATE),
|
|
ATTR(SCARD_ATTR_MAX_IFSD),
|
|
ATTR(SCARD_ATTR_CURRENT_PROTOCOL_TYPE),
|
|
ATTR(SCARD_ATTR_PROTOCOL_TYPES),
|
|
0, 0,
|
|
ATTR(SCARD_ATTR_ATR_STRING),
|
|
ATTR(SCARD_ATTR_CURRENT_PROTOCOL_TYPE)
|
|
};
|
|
|
|
LogMessage("=======================");
|
|
LogMessage("Part B: Checking reader");
|
|
LogMessage("=======================");
|
|
|
|
BOOL l_bCardInserted = FALSE;
|
|
LogMessage(" << %s", REMOVE_CARD);
|
|
in_CReader.WaitForCardRemoval();
|
|
|
|
TestStart("%2d. Device name", l_lTestNo++);
|
|
|
|
CString l_COperatingSystem = GetOperatingSystem();
|
|
|
|
if (l_COperatingSystem == OS_WINNT4) {
|
|
|
|
TestCheck(
|
|
in_CReader.GetDeviceName().Left(12) == "\\\\.\\SCReader",
|
|
"Device name is not NT 4.0 compliant"
|
|
);
|
|
|
|
} else if (l_COperatingSystem == OS_WIN95 ||
|
|
l_COperatingSystem == OS_WIN98) {
|
|
|
|
// there is no special naming convention for Win9x
|
|
|
|
} else {
|
|
|
|
TestCheck(
|
|
in_CReader.GetDeviceName().Find("{50dd5230-ba8a-11d1-bf5d-0000f805f530}") != -1,
|
|
"Device name is not WDM PnP compliant"
|
|
);
|
|
}
|
|
TestEnd();
|
|
|
|
TestStart(
|
|
"%2d. Null pointer check",
|
|
l_lTestNo++
|
|
);
|
|
|
|
for (l_iIndex = 0; l_aAttr[l_iIndex].m_pchName; l_iIndex++) {
|
|
|
|
// try to crash reader by using null pointers as arguments
|
|
l_bResult = DeviceIoControl (
|
|
l_hReader,
|
|
IOCTL_SMARTCARD_GET_ATTRIBUTE,
|
|
&l_aAttr[l_iIndex].m_uType,
|
|
sizeof(ULONG),
|
|
NULL,
|
|
1000,
|
|
&l_uReplyLength,
|
|
&l_Ovr
|
|
);
|
|
|
|
ULONG l_lResult = GetLastError();
|
|
|
|
TestCheck(
|
|
l_lResult == ERROR_INSUFFICIENT_BUFFER ||
|
|
l_lResult == ERROR_BAD_COMMAND,
|
|
"IOCTL_SMARTCARD_GET_ATTRIBUTE (%lxh) should fail\nReturned %2lxH (NTSTATUS %lxH)\nExpected %2lxH (NTSTATUS %lxH)\nor %2lxH (NTSTATUS %lxH)",
|
|
l_aAttr[l_iIndex].m_uType & 0xFFFF,
|
|
l_lResult,
|
|
MapWinErrorToNtStatus(l_lResult),
|
|
ERROR_INSUFFICIENT_BUFFER,
|
|
MapWinErrorToNtStatus(ERROR_BAD_COMMAND),
|
|
ERROR_BAD_COMMAND,
|
|
MapWinErrorToNtStatus(ERROR_BAD_COMMAND)
|
|
);
|
|
}
|
|
TestEnd();
|
|
|
|
for (l_iIndex = 0; l_iIndex < sizeof(l_aAttr) / sizeof(l_aAttr[0]); l_iIndex++) {
|
|
|
|
if (l_aAttr[l_iIndex].m_pchName == 0) {
|
|
|
|
TestStart("%2d. Close driver with I/O-request still pending", l_lTestNo++);
|
|
|
|
// Check if the reader correctly terminates pending io-requests
|
|
l_bResult = DeviceIoControl (
|
|
l_hReader,
|
|
IOCTL_SMARTCARD_IS_PRESENT,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0,
|
|
&l_uReplyLength,
|
|
&l_Ovr
|
|
);
|
|
|
|
TestCheck(
|
|
l_bResult == FALSE,
|
|
"Wait for present succeeded with no card inserted"
|
|
);
|
|
|
|
// With the pending i/o request close and re-open the driver
|
|
in_CReader.Close();
|
|
l_bResult = in_CReader.Open();
|
|
|
|
TestCheck(
|
|
l_bResult,
|
|
"Reader failed to terminate pending i/o request"
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
if (TestFailed()) {
|
|
|
|
// If the open failed we can't contiue
|
|
exit(GetLastError());
|
|
}
|
|
|
|
l_hReader = in_CReader.GetHandle();
|
|
|
|
LogMessage(" >> Please insert 'IBM PC/SC Compliance Test Card'");
|
|
in_CReader.WaitForCardInsertion();
|
|
l_bCardInserted = TRUE;
|
|
|
|
// Cold reset
|
|
TestStart("%2d. Cold reset", l_lTestNo++);
|
|
l_uStart = clock();
|
|
LONG l_lResult = in_CReader.ColdResetCard();
|
|
l_uEnd = clock();
|
|
TEST_CHECK_SUCCESS("Cold reset failed", l_lResult);
|
|
TestCheck(
|
|
(l_uEnd - l_uStart) / CLOCKS_PER_SEC <= 2,
|
|
"Cold reset took too long.\nElapsed time %ld sec\nExpected time %ld sec",
|
|
(l_uEnd - l_uStart) / CLOCKS_PER_SEC,
|
|
2
|
|
);
|
|
TestEnd();
|
|
|
|
if (TestFailed()) {
|
|
|
|
exit(l_lResult);
|
|
}
|
|
|
|
// Set protocol
|
|
TestStart("%2d. Set protocol to T0 | T1", l_lTestNo++);
|
|
l_lResult = in_CReader.SetProtocol(
|
|
SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1
|
|
);
|
|
TEST_CHECK_SUCCESS("Set protocol failed", l_lResult);
|
|
TestEnd();
|
|
continue;
|
|
}
|
|
|
|
TestStart("%2d. %s", l_lTestNo++, l_aAttr[l_iIndex].m_pchName);
|
|
|
|
SetLastError(0);
|
|
*(PULONG) l_rgbReplyBuffer = 0;
|
|
|
|
l_bResult = DeviceIoControl (
|
|
l_hReader,
|
|
IOCTL_SMARTCARD_GET_ATTRIBUTE,
|
|
&l_aAttr[l_iIndex].m_uType,
|
|
sizeof(ULONG),
|
|
l_rgbReplyBuffer,
|
|
sizeof(l_rgbReplyBuffer),
|
|
&l_uReplyLength,
|
|
&l_Ovr
|
|
);
|
|
|
|
if (l_bResult == FALSE && GetLastError() == ERROR_IO_PENDING) {
|
|
|
|
//
|
|
// The I/O request returned pending, so
|
|
// wait until the request is finished
|
|
//
|
|
SetLastError(0);
|
|
|
|
l_bResult = GetOverlappedResult(
|
|
l_hReader,
|
|
&l_Ovr,
|
|
&l_uReplyLength,
|
|
TRUE
|
|
);
|
|
}
|
|
|
|
if (GetLastError() != ERROR_SUCCESS) {
|
|
|
|
l_bResult = FALSE;
|
|
|
|
} else {
|
|
|
|
l_rgbReplyBuffer[l_uReplyLength] = 0;
|
|
}
|
|
|
|
LONG l_lResult = GetLastError();
|
|
|
|
switch (l_aAttr[l_iIndex].m_uType) {
|
|
|
|
case SCARD_ATTR_VENDOR_NAME:
|
|
TEST_CHECK_SUCCESS(
|
|
"Ioctl SCARD_ATTR_VENDOR_NAME failed",
|
|
l_lResult
|
|
);
|
|
TestCheck(
|
|
strlen((PCHAR) l_rgbReplyBuffer) != 0,
|
|
"No vendor name defined"
|
|
);
|
|
TestEnd();
|
|
break;
|
|
|
|
case SCARD_ATTR_VENDOR_IFD_TYPE:
|
|
TEST_CHECK_SUCCESS(
|
|
"Ioctl SCARD_ATTR_VENDOR_IFD_TYPE failed",
|
|
l_lResult
|
|
);
|
|
TestCheck(
|
|
strlen((PCHAR) l_rgbReplyBuffer) != 0,
|
|
"No ifd type defined"
|
|
);
|
|
TestEnd();
|
|
break;
|
|
|
|
case SCARD_ATTR_DEVICE_UNIT:
|
|
TEST_CHECK_SUCCESS(
|
|
"Ioctl SCARD_ATTR_DEVICE_UNIT failed",
|
|
l_lResult
|
|
);
|
|
TestCheck(
|
|
*(PULONG) l_rgbReplyBuffer < 4,
|
|
"Invalid value: %ld (0 - 3)",
|
|
*(PULONG) l_rgbReplyBuffer
|
|
);
|
|
TestEnd();
|
|
break;
|
|
|
|
case SCARD_ATTR_ATR_STRING:
|
|
if (l_bCardInserted) {
|
|
|
|
TEST_CHECK_SUCCESS(
|
|
"Ioctl SCARD_ATTR_ATR_STRING failed",
|
|
l_lResult
|
|
);
|
|
|
|
} else {
|
|
|
|
TestCheck(
|
|
l_bResult == FALSE,
|
|
"Reader returned ATR with no card inserted"
|
|
);
|
|
}
|
|
TestEnd();
|
|
break;
|
|
|
|
case SCARD_ATTR_DEFAULT_CLK:
|
|
case SCARD_ATTR_MAX_CLK:
|
|
TEST_CHECK_SUCCESS(
|
|
"Ioctl SCARD_ATTR_DEFAULT_CLK/SCARD_ATTR_MAX_CLK failed",
|
|
l_lResult
|
|
);
|
|
TestCheck(
|
|
*(PULONG) l_rgbReplyBuffer >= 1000 && *(PULONG) l_rgbReplyBuffer <= 20000,
|
|
"Invalid value %ld (1000 - 20000)",
|
|
*(PULONG) l_rgbReplyBuffer
|
|
);
|
|
TestEnd();
|
|
break;
|
|
|
|
case SCARD_ATTR_DEFAULT_DATA_RATE:
|
|
case SCARD_ATTR_MAX_DATA_RATE:
|
|
TEST_CHECK_SUCCESS(
|
|
"Ioctl SCARD_ATTR_DEFAULT_DATA_RATE/SCARD_ATTR_MAX_DATA_RATE failed",
|
|
l_lResult
|
|
);
|
|
TestEnd();
|
|
break;
|
|
|
|
case SCARD_ATTR_MAX_IFSD:
|
|
TEST_CHECK_SUCCESS(
|
|
"Ioctl SCARD_ATTR_MAX_IFSD failed",
|
|
l_lResult
|
|
);
|
|
TestCheck(
|
|
*(PULONG) l_rgbReplyBuffer >= 1 && *(PULONG) l_rgbReplyBuffer <= 254,
|
|
"Invalid value: %ld (1 - 254)",
|
|
*(PULONG) l_rgbReplyBuffer
|
|
);
|
|
TestEnd();
|
|
break;
|
|
|
|
case SCARD_ATTR_PROTOCOL_TYPES:
|
|
TEST_CHECK_SUCCESS(
|
|
"Ioctl SCARD_ATTR_PROTOCOL_TYPES failed",
|
|
l_lResult
|
|
);
|
|
|
|
// check if the reader at least supports T=0 and T=1
|
|
TestCheck(
|
|
(*(PULONG) l_rgbReplyBuffer & SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1) ==
|
|
(SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1),
|
|
"Reader must support T=0 and T=1"
|
|
);
|
|
TestEnd();
|
|
break;
|
|
|
|
case SCARD_ATTR_CURRENT_PROTOCOL_TYPE:
|
|
|
|
if (l_bCardInserted) {
|
|
|
|
TEST_CHECK_SUCCESS(
|
|
"Ioctl SCARD_ATTR_CURRENT_PROTOCOL_TYPE failed",
|
|
l_lResult
|
|
);
|
|
|
|
TestCheck(
|
|
*(PULONG) l_rgbReplyBuffer != 0,
|
|
"Reader returned no protocol"
|
|
);
|
|
|
|
} else {
|
|
|
|
// Check that without a card the current protocol is set to 0
|
|
TestCheck(
|
|
l_bResult == FALSE,
|
|
"Ioctl SCARD_ATTR_CURRENT_PROTOCOL_TYPE failed should fail with no card inserted"
|
|
);
|
|
}
|
|
TestEnd();
|
|
break;
|
|
|
|
default:
|
|
TestCheck(
|
|
l_bResult,
|
|
"Ioctl returned %lxh",
|
|
GetLastError()
|
|
);
|
|
TestEnd();
|
|
break;
|
|
}
|
|
}
|
|
|
|
LogMessage(" << %s", REMOVE_CARD);
|
|
in_CReader.WaitForCardRemoval();
|
|
LogMessage(" << Please insert smart card BACKWARDS");
|
|
in_CReader.WaitForCardInsertion();
|
|
|
|
TestStart("%2d. IOCTL_SMARTCARD_GET_STATE", l_lTestNo++);
|
|
ULONG l_uState;
|
|
|
|
l_bResult = DeviceIoControl (
|
|
l_hReader,
|
|
IOCTL_SMARTCARD_GET_STATE,
|
|
NULL,
|
|
0,
|
|
&l_uState,
|
|
sizeof(l_uState),
|
|
&l_uReplyLength,
|
|
&l_Ovr
|
|
);
|
|
|
|
LONG l_lResult = GetLastError();
|
|
|
|
TestCheck(
|
|
l_bResult,
|
|
"IOCTL_SMARTCARD_GET_STATE failed.\nReturned %8lxH (NTSTATUS %8lxH).\nExpected %8lxH (NTSTATUS %8lxH)",
|
|
l_lResult,
|
|
MapWinErrorToNtStatus(l_lResult),
|
|
ERROR_SUCCESS,
|
|
MapWinErrorToNtStatus(ERROR_SUCCESS)
|
|
);
|
|
|
|
TestCheck(
|
|
l_uState <= SCARD_SWALLOWED,
|
|
"Invalid reader state.\nReturned %d\nExpected <= %d",
|
|
l_uState,
|
|
SCARD_SWALLOWED
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
TestStart("%2d. Cold reset", l_lTestNo++);
|
|
l_uStart = clock();
|
|
l_lResult = in_CReader.ColdResetCard();
|
|
l_uEnd = clock();
|
|
|
|
TestCheck(
|
|
l_lResult == ERROR_UNRECOGNIZED_MEDIA,
|
|
"Cold reset failed.\nReturned %8lxH (NTSTATUS %8lxH).\nExpected %8lxH (NTSTATUS %8lxH)",
|
|
l_lResult,
|
|
MapWinErrorToNtStatus(l_lResult),
|
|
ERROR_UNRECOGNIZED_MEDIA,
|
|
MapWinErrorToNtStatus(ERROR_UNRECOGNIZED_MEDIA)
|
|
);
|
|
|
|
TestCheck(
|
|
(l_uEnd - l_uStart) / CLOCKS_PER_SEC <= 2,
|
|
"Cold reset took too long.\nElapsed time %ld sec\nExpected time %ld sec",
|
|
(l_uEnd - l_uStart) / CLOCKS_PER_SEC,
|
|
2
|
|
);
|
|
|
|
TestEnd();
|
|
}
|
|
|
|
void
|
|
SimulateResMngr(
|
|
CReader &in_CReader
|
|
)
|
|
{
|
|
BOOL l_bWaitForPresent = FALSE, l_bWaitForAbsent = FALSE, l_bResult;
|
|
BOOL l_bMustWait = FALSE, l_bPoweredDown = FALSE;
|
|
ULONG l_uState, l_uStatus, l_uReplyLength, l_uStateExpected = SCARD_ABSENT, l_lTestNo = 1;
|
|
ULONG l_uMinorIoctl;
|
|
OVERLAPPED l_Ovr, l_OvrWait;
|
|
HANDLE l_hReader = in_CReader.GetHandle();
|
|
|
|
l_Ovr.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
ResetEvent(l_Ovr.hEvent);
|
|
|
|
l_OvrWait.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
ResetEvent(l_OvrWait.hEvent);
|
|
|
|
LogMessage("===================================");
|
|
LogMessage("Part C: Resource Manager Simulation");
|
|
LogMessage("===================================");
|
|
|
|
LogMessage(" << %s", REMOVE_CARD);
|
|
in_CReader.WaitForCardRemoval();
|
|
|
|
while (TRUE) {
|
|
|
|
TestStart("%2d. IOCTL_SMARTCARD_GET_STATE", l_lTestNo++);
|
|
|
|
l_bResult = DeviceIoControl (
|
|
l_hReader,
|
|
IOCTL_SMARTCARD_GET_STATE,
|
|
NULL,
|
|
0,
|
|
&l_uState,
|
|
sizeof(l_uState),
|
|
&l_uReplyLength,
|
|
&l_Ovr
|
|
);
|
|
|
|
LONG l_lResult = GetLastError();
|
|
|
|
TestCheck(
|
|
l_bResult,
|
|
"IOCTL_SMARTCARD_GET_STATE failed.\nReturned %8lxH (NTSTATUS %8lxH).\nExpected %8lxH (NTSTATUS %8lxH)",
|
|
l_lResult,
|
|
MapWinErrorToNtStatus(l_lResult),
|
|
ERROR_SUCCESS,
|
|
MapWinErrorToNtStatus(ERROR_SUCCESS)
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
if (l_bWaitForPresent) {
|
|
|
|
TestStart("%2d. %s", l_lTestNo++, INSERT_CARD);
|
|
|
|
l_bResult = GetOverlappedResult(
|
|
l_hReader,
|
|
&l_OvrWait,
|
|
&l_uReplyLength,
|
|
TRUE
|
|
);
|
|
|
|
l_lResult = GetLastError();
|
|
|
|
TestCheck(
|
|
l_bResult,
|
|
"Card insertion monitor failed.\nReturned %8lxH (NTSTATUS %8lxH).\nExpected %8lxH (NTSTATUS %8lxH)",
|
|
l_lResult,
|
|
MapWinErrorToNtStatus(l_lResult),
|
|
ERROR_SUCCESS,
|
|
MapWinErrorToNtStatus(ERROR_SUCCESS)
|
|
);
|
|
l_lResult = GetLastError();
|
|
|
|
TestEnd();
|
|
|
|
l_bWaitForPresent = FALSE;
|
|
continue;
|
|
}
|
|
|
|
if (l_bWaitForAbsent) {
|
|
|
|
if (l_bMustWait) {
|
|
|
|
TestStart("%2d. %s", l_lTestNo++, REMOVE_CARD);
|
|
|
|
} else {
|
|
|
|
TestStart("%2d. GetOverlappedResult", l_lTestNo++);
|
|
}
|
|
|
|
l_bResult = GetOverlappedResult(
|
|
l_hReader,
|
|
&l_OvrWait,
|
|
&l_uReplyLength,
|
|
l_bMustWait
|
|
);
|
|
|
|
if (l_bMustWait == FALSE) {
|
|
|
|
TestCheck(
|
|
l_bResult == FALSE,
|
|
"Smart card not removed"
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
if (TestFailed()) {
|
|
|
|
return;
|
|
}
|
|
|
|
} else {
|
|
|
|
l_lResult = GetLastError();
|
|
|
|
TestCheck(
|
|
l_bResult,
|
|
"Card removal monitor failed.\nReturned %8lxH (NTSTATUS %8lxH).\nExpected %8lxH (NTSTATUS %8lxH)",
|
|
l_lResult,
|
|
MapWinErrorToNtStatus(l_lResult),
|
|
ERROR_SUCCESS,
|
|
MapWinErrorToNtStatus(ERROR_SUCCESS)
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
if (TestFailed()) {
|
|
|
|
return;
|
|
}
|
|
l_bWaitForAbsent = FALSE;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
TestStart("%2d. Checking reader status", l_lTestNo++);
|
|
|
|
switch (l_uState) {
|
|
|
|
case SCARD_UNKNOWN:
|
|
TestCheck(FALSE, "Reader returned illegal state SCARD_UNKNOWN");
|
|
TestEnd();
|
|
return;
|
|
|
|
case SCARD_ABSENT:
|
|
TestCheck(
|
|
l_uStateExpected == SCARD_ABSENT,
|
|
"Invalid reader state.\nCurrent state = %d\nExpected state = %d",
|
|
l_uState,
|
|
l_uStateExpected
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
if (TestFailed()) {
|
|
|
|
return;
|
|
}
|
|
|
|
if (l_bMustWait) {
|
|
|
|
return;
|
|
}
|
|
|
|
TestStart("%2d. IOCTL_SMARTCARD_IS_PRESENT", l_lTestNo++);
|
|
|
|
l_bResult = DeviceIoControl (
|
|
l_hReader,
|
|
IOCTL_SMARTCARD_IS_PRESENT,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0,
|
|
&l_uReplyLength,
|
|
&l_OvrWait
|
|
);
|
|
|
|
TestCheck(
|
|
GetLastError() == ERROR_IO_PENDING,
|
|
"Monitor is supposed to return ERROR_IO_PENDING (%lxh)",
|
|
GetLastError()
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
if (TestFailed()) {
|
|
|
|
return;
|
|
}
|
|
|
|
l_bWaitForPresent = TRUE;
|
|
l_uStateExpected = SCARD_PRESENT;
|
|
break;
|
|
|
|
case SCARD_PRESENT:
|
|
case SCARD_SWALLOWED:
|
|
case SCARD_POWERED:
|
|
if (l_bPoweredDown) {
|
|
|
|
TestCheck(
|
|
l_uStateExpected <= SCARD_POWERED,
|
|
"Invalid reader state.\nCurrent state = %d\nExpected state <= %d",
|
|
l_uState,
|
|
l_uStateExpected
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
if (TestFailed()) {
|
|
|
|
return;
|
|
}
|
|
|
|
l_bMustWait = TRUE;
|
|
l_uStateExpected = SCARD_ABSENT;
|
|
break;
|
|
}
|
|
|
|
TestCheck(
|
|
l_uStateExpected > SCARD_ABSENT,
|
|
"Invalid reader state.\nCurrent state = %d\nExpected state <= %d",
|
|
l_uState,
|
|
l_uStateExpected
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
if (TestFailed()) {
|
|
|
|
return;
|
|
}
|
|
|
|
TestStart("%2d. IOCTL_SMARTCARD_IS_ABSENT", l_lTestNo++);
|
|
l_bResult = DeviceIoControl (
|
|
l_hReader,
|
|
IOCTL_SMARTCARD_IS_ABSENT,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0,
|
|
&l_uReplyLength,
|
|
&l_OvrWait
|
|
);
|
|
|
|
l_lResult = GetLastError();
|
|
|
|
TestCheck(
|
|
l_bResult == FALSE,
|
|
"IOCTL_SMARTCARD_IS_ABSENT should fail.\nReturned %8lxH (NTSTATUS %8lxH).\nExpected %8lxH (NTSTATUS %8lxH)",
|
|
l_lResult,
|
|
MapWinErrorToNtStatus(l_lResult),
|
|
ERROR_IO_PENDING,
|
|
MapWinErrorToNtStatus(ERROR_IO_PENDING)
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
l_bWaitForAbsent = TRUE;
|
|
TestStart("%2d. Cold reset card", l_lTestNo++);
|
|
l_uStatus = in_CReader.ColdResetCard();
|
|
TEST_CHECK_SUCCESS("ColdReset", l_uStatus)
|
|
l_uStateExpected = SCARD_NEGOTIABLE;
|
|
|
|
TestEnd();
|
|
|
|
if (TestFailed()) {
|
|
|
|
return;
|
|
}
|
|
break;
|
|
|
|
case SCARD_NEGOTIABLE:
|
|
TestCheck(
|
|
l_bPoweredDown == FALSE,
|
|
"Invalid reader state.\nCurrent state = %d\nExpected state = %d",
|
|
l_uState,
|
|
SCARD_PRESENT
|
|
);
|
|
|
|
TestCheck(
|
|
l_uStateExpected > SCARD_ABSENT,
|
|
"Invalid reader state.\nCurrent state = %d\nExpected state <= %d",
|
|
l_uState,
|
|
l_uStateExpected
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
if (TestFailed()) {
|
|
|
|
return;
|
|
}
|
|
|
|
TestStart("%2d. Set protocol to T0 | T1", l_lTestNo++);
|
|
|
|
l_uStatus = in_CReader.SetProtocol(
|
|
SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1
|
|
);
|
|
|
|
TestCheck(
|
|
l_uStatus == ERROR_SUCCESS,
|
|
"Protocol selection failed with error %lxh",
|
|
GetLastError()
|
|
);
|
|
TestEnd();
|
|
|
|
if (TestFailed()) {
|
|
|
|
return;
|
|
}
|
|
l_uStateExpected = SCARD_SPECIFIC;
|
|
break;
|
|
|
|
case SCARD_SPECIFIC:
|
|
TestCheck(
|
|
l_bPoweredDown == FALSE,
|
|
"Invalid reader state.\nCurrent state = %d\nExpected state = %d",
|
|
l_uState,
|
|
SCARD_PRESENT
|
|
);
|
|
|
|
TestCheck(
|
|
l_uStateExpected > SCARD_ABSENT,
|
|
"Invalid reader state.\nReturned %d\nExpected < %d",
|
|
l_uState,
|
|
l_uStateExpected
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
if (TestFailed()) {
|
|
|
|
return;
|
|
}
|
|
|
|
TestStart("%2d. IOCTL_SMARTCARD_POWER (SCARD_POWER_DOWN)", l_lTestNo++);
|
|
l_uMinorIoctl = SCARD_POWER_DOWN;
|
|
SetLastError(0);
|
|
l_bResult = DeviceIoControl (
|
|
l_hReader,
|
|
IOCTL_SMARTCARD_POWER,
|
|
&l_uMinorIoctl,
|
|
sizeof(l_uMinorIoctl),
|
|
NULL,
|
|
0,
|
|
&l_uReplyLength,
|
|
&l_Ovr
|
|
);
|
|
|
|
if (l_bResult == FALSE && GetLastError() == ERROR_IO_PENDING) {
|
|
|
|
SetLastError(0);
|
|
|
|
l_bResult = GetOverlappedResult(
|
|
l_hReader,
|
|
&l_Ovr,
|
|
&l_uReplyLength,
|
|
TRUE
|
|
);
|
|
}
|
|
|
|
l_lResult = GetLastError();
|
|
|
|
TEST_CHECK_SUCCESS("IOCTL_SMARTCARD_POWER failed", l_lResult);
|
|
TestEnd();
|
|
|
|
l_uStateExpected = SCARD_PRESENT;
|
|
l_bPoweredDown = TRUE;
|
|
break;
|
|
|
|
default:
|
|
TestCheck(
|
|
FALSE,
|
|
"Reader returned invalid state %d",
|
|
l_uState
|
|
);
|
|
TestEnd();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
PowerManagementTest(
|
|
CReader &in_CReader,
|
|
ULONG in_uWaitTime
|
|
)
|
|
{
|
|
LONG l_lResult;
|
|
ULONG l_uState, l_uPrevState, l_uRepeat;
|
|
ULONG l_uDuration = 30;
|
|
|
|
if (in_uWaitTime > 30 && in_uWaitTime < 120) {
|
|
|
|
l_uDuration = in_uWaitTime;
|
|
}
|
|
|
|
LogMessage("=============================");
|
|
LogMessage("Part E: Power Management Test");
|
|
LogMessage("=============================");
|
|
|
|
LogMessage("Note: Each test cycle takes %ld seconds!", l_uDuration);
|
|
LogMessage(" << %s", REMOVE_CARD);
|
|
in_CReader.WaitForCardRemoval();
|
|
|
|
LogMessage("Test 1: DO NOT INSERT smart card during hibernate mode");
|
|
TestStart("Card out / card out - Hibernate now");
|
|
|
|
l_lResult = in_CReader.StartWaitForCardInsertion();
|
|
l_lResult = in_CReader.GetState(&l_uPrevState);
|
|
|
|
for (l_uRepeat = 0; l_uRepeat < l_uDuration; l_uRepeat++) {
|
|
|
|
l_lResult = in_CReader.GetState(&l_uState);
|
|
|
|
LONG l_uGoal = clock() + CLOCKS_PER_SEC;
|
|
while(l_uGoal > clock())
|
|
;
|
|
printf("\x08\x08%2ld", l_uDuration - l_uRepeat);
|
|
}
|
|
printf("\x08\x08 ");
|
|
|
|
l_lResult = in_CReader.FinishWaitForCard(FALSE);
|
|
|
|
TestCheck(
|
|
l_lResult == ERROR_IO_INCOMPLETE,
|
|
"GetOverlappedResult failed\nReturned %8lx\nExpected %8lx",
|
|
l_lResult,
|
|
ERROR_IO_INCOMPLETE
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
TestStart("%s", INSERT_CARD);
|
|
l_lResult = in_CReader.FinishWaitForCard(TRUE);
|
|
TEST_CHECK_SUCCESS("Reader failed card insertion", l_lResult);
|
|
TestEnd();
|
|
|
|
TestStart("Checking reader status");
|
|
l_lResult = in_CReader.GetState(&l_uState);
|
|
TEST_CHECK_SUCCESS("Reader failed IOCTL_SMARTCARD_GET_STATE", l_lResult);
|
|
|
|
TestCheck(
|
|
l_uState > SCARD_ABSENT,
|
|
"Invalid reader state.\nReturned %d\nExpected > %d",
|
|
l_uState,
|
|
SCARD_ABSENT
|
|
);
|
|
TestEnd();
|
|
|
|
//
|
|
// Test 2
|
|
//
|
|
|
|
LogMessage("Test 2: REMOVE smart card DURING hibernate mode");
|
|
TestStart("Card in / card out - Hibernate now");
|
|
|
|
l_lResult = in_CReader.StartWaitForCardRemoval();
|
|
l_lResult = in_CReader.GetState(&l_uPrevState);
|
|
|
|
for (l_uRepeat = 0; l_uRepeat < l_uDuration; l_uRepeat++) {
|
|
|
|
l_lResult = in_CReader.GetState(&l_uState);
|
|
|
|
LONG l_uGoal = clock() + CLOCKS_PER_SEC;
|
|
while(l_uGoal > clock())
|
|
;
|
|
printf("\x08\x08%2ld", l_uDuration - l_uRepeat);
|
|
}
|
|
printf("\x08\x08 ");
|
|
|
|
l_lResult = in_CReader.FinishWaitForCard(FALSE);
|
|
|
|
TEST_CHECK_SUCCESS(
|
|
"GetOverlappedResult failed",
|
|
l_lResult
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
TestStart("Checking reader status");
|
|
l_lResult = in_CReader.GetState(&l_uState);
|
|
TEST_CHECK_SUCCESS("Reader failed IOCTL_SMARTCARD_GET_STATE", l_lResult);
|
|
|
|
TestCheck(
|
|
l_uState == SCARD_ABSENT,
|
|
"Invalid reader state.\nReturned %d\nExpected %d",
|
|
l_uState,
|
|
SCARD_ABSENT
|
|
);
|
|
TestEnd();
|
|
|
|
LogMessage(" >> %s", INSERT_CARD);
|
|
in_CReader.WaitForCardInsertion();
|
|
|
|
//
|
|
// Test 3
|
|
//
|
|
LogMessage("Test 3: DO NOT REMOVE smart card during hibernate mode");
|
|
TestStart("Card in / card in - Hibernate now");
|
|
|
|
l_lResult = in_CReader.StartWaitForCardRemoval();
|
|
l_lResult = in_CReader.GetState(&l_uPrevState);
|
|
|
|
for (l_uRepeat = 0; l_uRepeat < l_uDuration; l_uRepeat++) {
|
|
|
|
l_lResult = in_CReader.GetState(&l_uState);
|
|
|
|
LONG l_uGoal = clock() + CLOCKS_PER_SEC;
|
|
while(l_uGoal > clock())
|
|
;
|
|
printf("\x08\x08%2ld", l_uDuration - l_uRepeat);
|
|
}
|
|
printf("\x08\x08 ");
|
|
|
|
l_lResult = in_CReader.FinishWaitForCard(FALSE);
|
|
|
|
TEST_CHECK_SUCCESS(
|
|
"GetOverlappedResult failed",
|
|
l_lResult
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
TestStart("Checking reader status");
|
|
l_lResult = in_CReader.GetState(&l_uState);
|
|
TEST_CHECK_SUCCESS("Reader failed IOCTL_SMARTCARD_GET_STATE", l_lResult);
|
|
|
|
TestCheck(
|
|
l_uState >= SCARD_PRESENT,
|
|
"Invalid reader state.\nReturned %d\nExpected > %d",
|
|
l_uState,
|
|
SCARD_ABSENT
|
|
);
|
|
TestEnd();
|
|
|
|
LogMessage(" << %s", REMOVE_CARD);
|
|
in_CReader.WaitForCardRemoval();
|
|
|
|
//
|
|
// Test 4
|
|
//
|
|
|
|
LogMessage("Test 4: INSERT smart card DURING hibernate mode");
|
|
TestStart("Card out / card in - Hibernate now");
|
|
|
|
l_lResult = in_CReader.StartWaitForCardInsertion();
|
|
l_lResult = in_CReader.GetState(&l_uPrevState);
|
|
|
|
for (l_uRepeat = 0; l_uRepeat < l_uDuration; l_uRepeat++) {
|
|
|
|
l_lResult = in_CReader.GetState(&l_uState);
|
|
|
|
LONG l_uGoal = clock() + CLOCKS_PER_SEC;
|
|
while(l_uGoal > clock())
|
|
;
|
|
printf("\x08\x08%2ld", l_uDuration - l_uRepeat);
|
|
}
|
|
printf("\x08\x08 ");
|
|
l_lResult = in_CReader.FinishWaitForCard(FALSE);
|
|
|
|
TEST_CHECK_SUCCESS(
|
|
"GetOverlappedResult failed",
|
|
l_lResult
|
|
);
|
|
|
|
TestEnd();
|
|
|
|
TestStart("Checking reader status");
|
|
l_lResult = in_CReader.GetState(&l_uState);
|
|
TEST_CHECK_SUCCESS("Reader failed IOCTL_SMARTCARD_GET_STATE", l_lResult);
|
|
|
|
TestCheck(
|
|
l_uState >= SCARD_PRESENT,
|
|
"Invalid reader state.\nReturned %d\nExpected > %d",
|
|
l_uState,
|
|
SCARD_ABSENT
|
|
);
|
|
TestEnd();
|
|
}
|
|
|
|
class CArgv {
|
|
|
|
int m_iArgc;
|
|
char **m_pArgv;
|
|
BOOL *m_pfRef;
|
|
|
|
public:
|
|
|
|
CArgv(int in_iArgc, char **in_pArgv);
|
|
|
|
int OptionExist(PCHAR);
|
|
|
|
PCHAR ParameterExist(PCHAR);
|
|
|
|
PCHAR CheckParameters(CString);
|
|
|
|
PCHAR CArgv::ParameterUnused(void);
|
|
};
|
|
|
|
|
|
CArgv::CArgv(
|
|
int in_iArgc,
|
|
char **in_pArgv
|
|
)
|
|
{
|
|
m_iArgc = in_iArgc;
|
|
m_pArgv = in_pArgv;
|
|
m_pfRef = new BOOL[in_iArgc];
|
|
memset(m_pfRef, 0, sizeof(BOOL) * in_iArgc);
|
|
}
|
|
|
|
CArgv::OptionExist(
|
|
PCHAR in_pchParameter
|
|
)
|
|
{
|
|
for (int i = 0; i < m_iArgc; i++) {
|
|
|
|
if (m_pArgv[i][0] == '-' || m_pArgv[i][0] == '/') {
|
|
|
|
int j = 1;
|
|
|
|
while (m_pArgv[i][j] && m_pArgv[i][j] != ' ') {
|
|
|
|
if (strncmp(m_pArgv[i] + j, in_pchParameter, strlen(m_pArgv[i] + j)) == 0) {
|
|
|
|
m_pfRef[i] = TRUE;
|
|
return i;
|
|
}
|
|
|
|
j++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
PCHAR
|
|
CArgv::ParameterExist(
|
|
PCHAR in_pchParameter
|
|
)
|
|
{
|
|
if (int i = OptionExist(in_pchParameter)) {
|
|
|
|
m_pfRef[i + 1] = TRUE;
|
|
return m_pArgv[i + 1];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PCHAR
|
|
CArgv::CheckParameters(
|
|
CString in_CParameters
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Checks if the command line includes in invalid/unknown parameter
|
|
|
|
--*/
|
|
{
|
|
int i, l_iPos;
|
|
|
|
for (i = 1; i < m_iArgc; i++) {
|
|
|
|
if ((l_iPos = in_CParameters.Find(m_pArgv[i])) == -1) {
|
|
|
|
return m_pArgv[i];
|
|
}
|
|
|
|
if (l_iPos + 3 < in_CParameters.GetLength() &&
|
|
in_CParameters[l_iPos + 3] == '*') {
|
|
|
|
// skip the next parameter
|
|
i += 1;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
PCHAR
|
|
CArgv::ParameterUnused(
|
|
void
|
|
)
|
|
{
|
|
int i;
|
|
|
|
for (i = 1; i < m_iArgc; i++) {
|
|
|
|
if (m_pfRef[i] == FALSE) {
|
|
|
|
return m_pArgv[i];
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
CString &
|
|
GetOperatingSystem(
|
|
void
|
|
)
|
|
{
|
|
static CString l_COperatingSystem;
|
|
OSVERSIONINFO VersionInformation;
|
|
|
|
if (l_COperatingSystem.GetLength() == 0) {
|
|
|
|
VersionInformation.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
|
|
|
|
if (GetVersionEx(&VersionInformation) == FALSE) {
|
|
|
|
l_COperatingSystem += "Unknown";
|
|
|
|
} else {
|
|
|
|
if (VersionInformation.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
|
|
|
|
if (VersionInformation.dwMinorVersion == 0) {
|
|
|
|
l_COperatingSystem += OS_WIN95;
|
|
|
|
} else {
|
|
|
|
l_COperatingSystem += OS_WIN98;
|
|
}
|
|
|
|
} else if (VersionInformation.dwPlatformId == VER_PLATFORM_WIN32_NT) {
|
|
|
|
if (VersionInformation.dwMajorVersion <= 4) {
|
|
|
|
l_COperatingSystem += OS_WINNT4;
|
|
|
|
} else {
|
|
|
|
l_COperatingSystem += OS_WINNT5;
|
|
}
|
|
|
|
} else {
|
|
|
|
l_COperatingSystem += "Unknown";
|
|
}
|
|
}
|
|
}
|
|
|
|
return l_COperatingSystem;
|
|
}
|
|
|
|
CString &
|
|
SelectReader(
|
|
void
|
|
)
|
|
{
|
|
CReaderList l_CReaderList;
|
|
ULONG l_uIndex, l_uReader;
|
|
ULONG l_uNumReaders = l_CReaderList.GetNumReaders();
|
|
static CString l_CEmpty("");
|
|
|
|
if (l_uNumReaders == 0) {
|
|
|
|
return l_CEmpty;
|
|
}
|
|
|
|
if (l_uNumReaders == 1) {
|
|
|
|
return l_CReaderList.GetDeviceName(0);
|
|
}
|
|
|
|
CString l_CLetter;
|
|
|
|
printf("\n");
|
|
printf(" Vendor IfdType Type\n");
|
|
printf(" -----------------------------------------------------\n");
|
|
|
|
for (l_uIndex = 0; l_uIndex < l_uNumReaders; l_uIndex++) {
|
|
|
|
INT l_iLetterPos;
|
|
INT l_iLength = l_CReaderList.GetVendorName(l_uIndex).GetLength();
|
|
CString l_CVendorName = l_CReaderList.GetVendorName(l_uIndex);
|
|
|
|
for (l_iLetterPos = 0;
|
|
l_iLetterPos < l_CVendorName.GetLength();
|
|
l_iLetterPos++) {
|
|
|
|
CHAR l_chLetter = l_CVendorName[l_iLetterPos];
|
|
|
|
if (l_chLetter == ' ' || l_chLetter == 'x') {
|
|
|
|
continue;
|
|
}
|
|
|
|
if (l_CLetter.Find(l_chLetter) == -1) {
|
|
|
|
l_CLetter += l_chLetter;
|
|
break;
|
|
}
|
|
}
|
|
if (l_iLetterPos >= l_iLength) {
|
|
|
|
l_CVendorName += (CHAR) (l_uIndex + '0') ;
|
|
l_iLetterPos = l_iLength;
|
|
}
|
|
|
|
printf(
|
|
" %s[%c]%-*s %-20s %8s\n",
|
|
(LPCSTR) l_CVendorName.Left(l_iLetterPos),
|
|
l_CVendorName[l_iLetterPos],
|
|
20 - l_iLetterPos,
|
|
l_CVendorName.Right(l_iLength - l_iLetterPos - 1),
|
|
(LPCSTR) l_CReaderList.GetIfdType(l_uIndex),
|
|
(LPCSTR) l_CReaderList.GetPnPType(l_uIndex)
|
|
);
|
|
}
|
|
|
|
putchar('\n');
|
|
do {
|
|
|
|
printf("\rSelect reader: \010");
|
|
|
|
CHAR l_chInput = (CHAR) _getche();
|
|
if (l_chInput == 3) {
|
|
|
|
exit(-1);
|
|
}
|
|
|
|
l_uReader = l_CLetter.Find(l_chInput);
|
|
|
|
} while(l_uReader == -1);
|
|
|
|
printf("\n");
|
|
|
|
return l_CReaderList.GetDeviceName(l_uReader);
|
|
}
|
|
|
|
CString
|
|
SelectReader(
|
|
CString &in_CVendorName
|
|
)
|
|
{
|
|
CReaderList l_CReaderList;
|
|
ULONG l_uIndex;
|
|
ULONG l_uNumReaders = l_CReaderList.GetNumReaders();
|
|
CString l_CVendorName = in_CVendorName;
|
|
|
|
l_CVendorName.MakeLower();
|
|
|
|
for (l_uIndex = 0; l_uIndex < l_uNumReaders; l_uIndex++) {
|
|
|
|
CString l_CVendorListName = l_CReaderList.GetVendorName(l_uIndex);
|
|
l_CVendorListName.MakeLower();
|
|
|
|
if (l_CVendorListName.Find(l_CVendorName) != -1) {
|
|
|
|
return l_CReaderList.GetDeviceName(l_uIndex);
|
|
}
|
|
}
|
|
|
|
return CString("");
|
|
}
|
|
|
|
|
|
|
|
//**********************************************************************
|
|
//
|
|
// StopService()
|
|
//
|
|
// PURPOSE : This function attempts to stop a service. It will fail
|
|
// the service has any dependent services.
|
|
// It also allows a timeout
|
|
// value to be passed, to prevent a scenario in which a
|
|
// service shutdown hangs, and in turn the application
|
|
// stopping the service hangs.
|
|
//
|
|
// PARAMETERS: hSCM - open handle to the service control manager
|
|
// hService - open handle to the service to be stopped
|
|
// dwTimeout - maximum time (in milliseconds) to wait
|
|
// for the service and its dependencies to stop
|
|
//
|
|
// RETURN VALUE: TRUE if the service is successfully stopped
|
|
//
|
|
//**********************************************************************
|
|
|
|
BOOL StopService( SC_HANDLE hSCM, SC_HANDLE hService,
|
|
DWORD dwTimeout ) {
|
|
|
|
SERVICE_STATUS ss;
|
|
DWORD dwStartTime = GetTickCount();
|
|
|
|
// Make sure the service is not already stopped
|
|
if ( !QueryServiceStatus( hService, &ss ) )
|
|
return FALSE;
|
|
|
|
if ( ss.dwCurrentState == SERVICE_STOPPED )
|
|
return FALSE;
|
|
|
|
// If a stop is pending, just wait for it
|
|
while ( ss.dwCurrentState == SERVICE_STOP_PENDING ) {
|
|
|
|
Sleep( 5000 );
|
|
if ( !QueryServiceStatus( hService, &ss ) )
|
|
return FALSE;
|
|
|
|
if ( ss.dwCurrentState == SERVICE_STOPPED )
|
|
return FALSE;
|
|
|
|
if ( GetTickCount() - dwStartTime > dwTimeout )
|
|
return FALSE;
|
|
}
|
|
|
|
// Send a stop code to service
|
|
if ( !ControlService( hService, SERVICE_CONTROL_STOP, &ss ) )
|
|
return FALSE;
|
|
|
|
// Wait for the service to stop
|
|
while ( ss.dwCurrentState != SERVICE_STOPPED ) {
|
|
|
|
Sleep( 5000 );
|
|
if ( !QueryServiceStatus( hService, &ss ) )
|
|
return FALSE;
|
|
|
|
if ( ss.dwCurrentState == SERVICE_STOPPED )
|
|
break;
|
|
|
|
if ( GetTickCount() - dwStartTime > dwTimeout )
|
|
return FALSE;
|
|
}
|
|
|
|
// Return success
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
__cdecl
|
|
main(
|
|
int argc,
|
|
char* argv[]
|
|
)
|
|
{
|
|
CArgv l_CArgv(argc, argv);
|
|
BOOL l_bSuccess, l_fInvalidParameter = FALSE;
|
|
BOOL l_bStoppedScardsvr = FALSE; // true==> we succesfully stoped scardsvr service
|
|
SC_HANDLE l_hSCM = NULL;
|
|
SC_HANDLE l_hService = NULL;
|
|
|
|
LogMessage("Smart Card Reader Test Suite");
|
|
LogMessage("Version 2.0.5");
|
|
LogMessage("Copyright(c) Microsoft Corporation 1997 - 1999");
|
|
|
|
if(PCHAR l_pchArgv = l_CArgv.CheckParameters("-d -e -h -m -r * -sa -sb -sc -sd -se -t * -v * -w *")) {
|
|
|
|
LogMessage("Invalid Parameter '%s'", l_pchArgv);
|
|
l_fInvalidParameter = TRUE;
|
|
}
|
|
|
|
if (l_fInvalidParameter ||
|
|
|
|
l_CArgv.OptionExist("h")) {
|
|
|
|
LogMessage("IfdTest [-d] [-m] [-r name] [-sa] [-sb] [-sc] [-sd] [-se] [-ss] [-w sec] [-t test] [-v name]\n");
|
|
LogMessage(" -d dumps all i/o");
|
|
LogMessage(" -e ends (stops) scardsvr service");
|
|
LogMessage(" -m manual test");
|
|
LogMessage(" -r name opens reader using device name");
|
|
LogMessage(" -sa skips card monitor test");
|
|
LogMessage(" -sb skips general reader test");
|
|
LogMessage(" -sc skips resource manager simulation");
|
|
LogMessage(" -sd skips card tests");
|
|
LogMessage(" -se skips power management tests");
|
|
LogMessage(" -v name opens reader using vendor name");
|
|
LogMessage(" -t test runs only specific card test in part d");
|
|
LogMessage(" -w sec runs power management test using specified waiting time");
|
|
exit(-1);
|
|
}
|
|
|
|
static CReader l_CReader;
|
|
CString l_CDeviceName;
|
|
|
|
//
|
|
// sandysp 5/9/01: stop scardsvr service because open will fail if it's running
|
|
//
|
|
|
|
if (l_CArgv.OptionExist("e")) {
|
|
l_hSCM = OpenSCManager( NULL, NULL, SC_MANAGER_CONNECT );
|
|
if (l_hSCM) {
|
|
|
|
// Open the specified service
|
|
l_hService = OpenService( l_hSCM,
|
|
"scardsvr",
|
|
SERVICE_STOP | SERVICE_START | SERVICE_QUERY_STATUS );
|
|
if (l_hService) {
|
|
// Try to stop the service, specifying a 30 second timeout
|
|
l_bStoppedScardsvr = StopService( l_hSCM, l_hService, 30000 ) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PCHAR l_pchReader = l_CArgv.ParameterExist("r")) {
|
|
|
|
l_CDeviceName = CString("\\\\.\\") + CString(l_pchReader);
|
|
|
|
} else if (PCHAR l_pchVendorName = l_CArgv.ParameterExist("v")) {
|
|
|
|
CReaderList l_CReaderList;
|
|
l_CDeviceName = SelectReader(CString(l_pchVendorName));
|
|
|
|
} else {
|
|
|
|
CReaderList l_CReaderList;
|
|
l_CDeviceName = SelectReader();
|
|
}
|
|
|
|
if (l_CDeviceName == "") {
|
|
|
|
LogMessage("No reader found");
|
|
exit (-1);
|
|
}
|
|
|
|
l_bSuccess = l_CReader.Open(l_CDeviceName);
|
|
|
|
LogMessage(".");
|
|
if (l_bSuccess == FALSE) {
|
|
|
|
LogMessage("Can't open smart card reader");
|
|
exit (-1);
|
|
}
|
|
|
|
if (l_CArgv.OptionExist("d")) {
|
|
|
|
l_CReader.SetDump(TRUE);
|
|
}
|
|
|
|
void ManualTest(CReader &in_CReader);
|
|
if (l_CArgv.OptionExist("m")) {
|
|
|
|
ManualTest(l_CReader);
|
|
}
|
|
|
|
CCardProvider l_CCardProvider;
|
|
|
|
LogOpen("ifdtest");
|
|
|
|
time_t l_osBinaryTime;
|
|
time( &l_osBinaryTime );
|
|
CTime l_CTime( l_osBinaryTime );
|
|
|
|
LogMessage("Vendor: %s", l_CReader.GetVendorName());
|
|
LogMessage("Reader: %s", l_CReader.GetIfdType());
|
|
LogMessage(
|
|
"Date: %d/%02d/%02d",
|
|
l_CTime.GetMonth(),
|
|
l_CTime.GetDay(),
|
|
l_CTime.GetYear()
|
|
);
|
|
LogMessage(
|
|
"Time: %d:%02d",
|
|
l_CTime.GetHour(),
|
|
l_CTime.GetMinute()
|
|
);
|
|
LogMessage("OS: %s", (LPCSTR) GetOperatingSystem());
|
|
|
|
//
|
|
// Check if the reader properly supports
|
|
// card insertion and removal
|
|
//
|
|
if (l_CArgv.OptionExist("sa")) {
|
|
|
|
LogMessage("=================================");
|
|
LogMessage("Part A: Card monitor test skipped");
|
|
LogMessage("=================================");
|
|
|
|
} else {
|
|
|
|
CheckCardMonitor(l_CReader);
|
|
}
|
|
|
|
if (l_CArgv.OptionExist("sb")) {
|
|
|
|
LogMessage("===========================");
|
|
LogMessage("Part B: Reader test skipped");
|
|
LogMessage("===========================");
|
|
|
|
} else {
|
|
|
|
CheckReader(l_CReader);
|
|
}
|
|
|
|
if (l_CArgv.OptionExist("sc")) {
|
|
|
|
LogMessage("===========================================");
|
|
LogMessage("Part C: Resource Manager Simulation skipped");
|
|
LogMessage("===========================================");
|
|
|
|
} else {
|
|
|
|
// Check res manager behavior
|
|
SimulateResMngr(l_CReader);
|
|
}
|
|
|
|
if (l_CArgv.OptionExist("sd")) {
|
|
|
|
LogMessage("========================================");
|
|
LogMessage("Part D: Smart Card Provider Test skipped");
|
|
LogMessage("========================================");
|
|
|
|
} else {
|
|
|
|
ULONG l_uTestNo = 0;
|
|
PCHAR l_pchTestNo;
|
|
|
|
if (l_pchTestNo = l_CArgv.ParameterExist("t")) {
|
|
|
|
// The user wants us to run only one test
|
|
l_uTestNo = atoi(l_pchTestNo);
|
|
}
|
|
|
|
while (l_CCardProvider.CardsUntested()) {
|
|
|
|
LogMessage("================================");
|
|
LogMessage("Part D: Smart Card Provider Test");
|
|
LogMessage("================================");
|
|
|
|
LogMessage("Insert any of the following PC/SC Compliance Test Cards:");
|
|
l_CCardProvider.ListUntestedCards();
|
|
|
|
LogMessage(" >> %s", INSERT_CARD);
|
|
if (l_CReader.WaitForCardInsertion() != ERROR_SUCCESS) {
|
|
|
|
LogMessage("Reader failed card insertion monitor");
|
|
return -1;
|
|
}
|
|
|
|
// Reset the card
|
|
if (l_CReader.ColdResetCard() != ERROR_SUCCESS) {
|
|
|
|
LogMessage("Unable to reset smart card");
|
|
|
|
} else {
|
|
|
|
// Try to run tests with this card
|
|
l_CCardProvider.CardTest(l_CReader, l_uTestNo);
|
|
|
|
if (l_uTestNo != 0) {
|
|
|
|
// Quit the program if we only run one test.
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
LogMessage(" << %s", REMOVE_CARD);
|
|
if (l_CReader.WaitForCardRemoval() != ERROR_SUCCESS) {
|
|
|
|
LogMessage("Reader failed card removal monitor");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (GetOperatingSystem() == OS_WINNT5) {
|
|
|
|
if (l_CArgv.OptionExist("se")) {
|
|
|
|
LogMessage("=====================================");
|
|
LogMessage("Part E: Power Management Test skipped");
|
|
LogMessage("=====================================");
|
|
|
|
} else {
|
|
|
|
ULONG l_uWaitTime = 0;
|
|
|
|
if (PCHAR l_pchWaitTime = l_CArgv.ParameterExist("w")) {
|
|
|
|
// The user wants us to run only one test
|
|
l_uWaitTime = atoi(l_pchWaitTime);
|
|
}
|
|
|
|
PowerManagementTest(l_CReader, l_uWaitTime);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Sandysp 5/9/01: restart smart card reader service if we stopped it
|
|
//
|
|
if (l_bStoppedScardsvr) {
|
|
StartService( l_hService, 0, NULL );
|
|
}
|
|
if ( l_hService )
|
|
CloseServiceHandle( l_hService );
|
|
|
|
if ( l_hSCM )
|
|
CloseServiceHandle( l_hSCM );
|
|
|
|
|
|
LogMessage("Reader %s the test", (ReaderFailed() ? "failed" : "passed"));
|
|
return 0;
|
|
} |