windows-xp/Source/XPSP1/NT/drivers/smartcrd/ifdtest/ifdtest.cpp

#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;
}