winscard.h

/*++ Copyright (c) 1996 Microsoft Corporation Module Name: WinSCard Abstract: This header file provides the definitions and symbols necessary for an Application or Smart Card Service Provider to access the Smartcard Subsystem. Environment: Win32 Notes: --*/

#ifndef _WINSCARD_H_

#define _WINSCARD_H_

#if defined (_MSC_VER) && (_MSC_VER >= 1020)

#pragma once

#endif

#include <wtypes.h> #include <winioctl.h> #include "winsmcrd.h"

#ifndef SCARD_S_SUCCESS

#include "SCardErr.h"

#endif

#include <winapifamily.h>

#ifdef __cplusplus

extern

"C"

{

#endif

#if _MSC_VER >= 1200

#pragma warning(push)

#pragma warning(disable:4820) // padding added after data member #endif

#pragma warning(disable:

4820

)

#pragma region Desktop Family

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)

#ifndef _LPCBYTE_DEFINED

#define _LPCBYTE_DEFINED

typedef

const

BYTE

LPCBYTE

;

#endif

#ifndef _LPCVOID_DEFINED

#define _LPCVOID_DEFINED

typedef const VOID *LPCVOID; #endif

typedef

const

void

LPCVOID

;

#ifndef WINSCARDAPI

#define WINSCARDAPI #endif

#ifndef WINSCARDDATA

#define WINSCARDDATA __declspec(dllimport) #endif

/* In clr:pure we cannot mark data export with dllimport. * We should add small functions which returns the value of * the global. */

#if !defined(_M_CEE_PURE)

WINSCARDDATA extern const SCARD_IO_REQUEST

__declspec

(dllimport)

extern

const

SCARD_IO_REQUEST

g_rgSCardT0Pci

g_rgSCardT1Pci

g_rgSCardRawPci

;

#define SCARD_PCI_T0 (&g_rgSCardT0Pci)

#define SCARD_PCI_T1 (&g_rgSCardT1Pci)

#define SCARD_PCI_RAW (&g_rgSCardRawPci) #endif

////////////////////////////////////////////////////////////////////////////////

// Service Manager Access Services

// The following services are used to manage user and terminal contexts for

// Smart Cards.

typedef

ULONG_PTR

SCARDCONTEXT

;

typedef

SCARDCONTEXT

PSCARDCONTEXT

, *

LPSCARDCONTEXT

;

typedef

ULONG_PTR

SCARDHANDLE

;

typedef

SCARDHANDLE

PSCARDHANDLE

, *

LPSCARDHANDLE

;

#define SCARD_AUTOALLOCATE (DWORD)(-1)

#define SCARD_SCOPE_USER 0 // The context is a user context, and any

// database operations are performed within the

// domain of the user.

#define SCARD_SCOPE_TERMINAL 1 // The context is that of the current terminal,

// and any database operations are performed

// within the domain of that terminal. (The

// calling application must have appropriate

// access permissions for any database actions.)

#define SCARD_SCOPE_SYSTEM 2 // The context is the system context, and any

// database operations are performed within the

// domain of the system. (The calling

// application must have appropriate access

// permissions for any database actions.)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardEstablishContext

(

_In_ DWORD dwScope,

DWORD

dwScope

_Reserved_ LPCVOID pvReserved1,

LPCVOID

pvReserved1

_Reserved_ LPCVOID pvReserved2,

LPCVOID

pvReserved2

_Out_ LPSCARDCONTEXT phContext);

LPSCARDCONTEXT

phContext

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardReleaseContext

(

_In_ SCARDCONTEXT hContext);

SCARDCONTEXT

hContext

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardIsValidContext

(

_In_ SCARDCONTEXT hContext);

SCARDCONTEXT

hContext

);

////////////////////////////////////////////////////////////////////////////////

// Smart Card Database Management Services

// The following services provide for managing the Smart Card Database.

#define SCARD_ALL_READERS TEXT("SCard$AllReaders\000")

#define SCARD_DEFAULT_READERS TEXT("SCard$DefaultReaders\000")

#define SCARD_LOCAL_READERS TEXT("SCard$LocalReaders\000")

#define SCARD_SYSTEM_READERS TEXT("SCard$SystemReaders\000")

#define SCARD_PROVIDER_PRIMARY 1 // Primary Provider Id

#define SCARD_PROVIDER_CSP 2 // Crypto Service Provider Id

#define SCARD_PROVIDER_KSP 3 // Key Storage Provider Id

// Database Reader routines

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardListReaderGroupsA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_Out_writes_opt_(*pcchGroups) _Post_ _NullNull_terminated_ LPSTR mszGroups,

LPSTR

mszGroups

_Inout_ LPDWORD pcchGroups);

LPDWORD

pcchGroups

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardListReaderGroupsW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_Out_writes_opt_(*pcchGroups) _Post_ _NullNull_terminated_ LPWSTR mszGroups,

LPWSTR

mszGroups

_Inout_ LPDWORD pcchGroups);

LPDWORD

pcchGroups

);

#ifdef UNICODE

#define SCardListReaderGroups SCardListReaderGroupsW

#else

#define SCardListReaderGroups SCardListReaderGroupsA #endif // !UNICODE

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardListReadersA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_opt_ LPCSTR mszGroups,

LPCSTR

mszGroups

_When_(_Old_(*pcchReaders) == SCARD_AUTOALLOCATE, _At_((LPSTR *)mszReaders, _Outptr_result_buffer_maybenull_(*pcchReaders) _At_(*_Curr_, _Post_z_ _Post_ _NullNull_terminated_)))

_When_(_Old_(*pcchReaders) != SCARD_AUTOALLOCATE, _Out_writes_opt_(*pcchReaders) _Post_ _NullNull_terminated_)

LPSTR

mszReaders

_Inout_ LPDWORD pcchReaders);

LPDWORD

pcchReaders

);

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardListReadersW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_opt_ LPCWSTR mszGroups,

LPCWSTR

mszGroups

_When_(_Old_(*pcchReaders) == SCARD_AUTOALLOCATE, _At_((LPWSTR *)mszReaders, _Outptr_result_buffer_maybenull_(*pcchReaders) _At_(*_Curr_, _Post_z_ _Post_ _NullNull_terminated_)))

_When_(_Old_(*pcchReaders) != SCARD_AUTOALLOCATE, _Out_writes_opt_(*pcchReaders) _Post_ _NullNull_terminated_)

LPWSTR

mszReaders

_Inout_ LPDWORD pcchReaders);

LPDWORD

pcchReaders

);

#ifdef UNICODE

#define SCardListReaders SCardListReadersW

#else

#define SCardListReaders SCardListReadersA #endif // !UNICODE

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardListCardsA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_opt_ LPCBYTE pbAtr,

LPCBYTE

pbAtr

_In_reads_opt_(cguidInterfaceCount) LPCGUID rgquidInterfaces,

LPCGUID

rgquidInterfaces

_In_ DWORD cguidInterfaceCount,

DWORD

cguidInterfaceCount

_When_(_Old_(*pcchCards) == SCARD_AUTOALLOCATE, _At_((LPSTR *)mszCards, _Outptr_result_buffer_maybenull_(*pcchCards) _At_(*_Curr_, _Post_ _NullNull_terminated_)))

_When_(_Old_(*pcchCards) != SCARD_AUTOALLOCATE, _Out_writes_opt_(*pcchCards) _Post_ _NullNull_terminated_)

CHAR

mszCards

_Inout_ LPDWORD pcchCards);

LPDWORD

pcchCards

);

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardListCardsW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_opt_ LPCBYTE pbAtr,

LPCBYTE

pbAtr

_In_reads_opt_(cguidInterfaceCount) LPCGUID rgquidInterfaces,

LPCGUID

rgquidInterfaces

_In_ DWORD cguidInterfaceCount,

DWORD

cguidInterfaceCount

_When_(_Old_(*pcchCards) == SCARD_AUTOALLOCATE, _At_((LPWSTR *)mszCards, _Outptr_result_buffer_maybenull_(*pcchCards) _At_(*_Curr_, _Post_ _NullNull_terminated_)))

_When_(_Old_(*pcchCards) != SCARD_AUTOALLOCATE, _Out_writes_opt_(*pcchCards) _Post_ _NullNull_terminated_)

WCHAR

mszCards

_Inout_ LPDWORD pcchCards);

LPDWORD

pcchCards

);

#ifdef UNICODE

#define SCardListCards SCardListCardsW

#else

#define SCardListCards SCardListCardsA #endif // !UNICODE

// NOTE: The routine SCardListCards name differs from the PC/SC definition.

// It should be:

// extern WINSCARDAPI LONG WINAPI

// SCardListCardTypes(

// _In_ SCARDCONTEXT hContext,

// _In_opt_ LPCBYTE pbAtr,

// _In_opt_ LPCGUID rgquidInterfaces,

// _In_ DWORD cguidInterfaceCount,

// _Out_opt_ LPTSTR mszCards,

// _Inout_ LPDWORD pcchCards);

// Here's a work-around MACRO:

#define SCardListCardTypes SCardListCards

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardListInterfacesA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szCard,

LPCSTR

szCard

_Out_ LPGUID pguidInterfaces,

LPGUID

pguidInterfaces

_Inout_ LPDWORD pcguidInterfaces);

LPDWORD

pcguidInterfaces

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardListInterfacesW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szCard,

LPCWSTR

szCard

_Out_ LPGUID pguidInterfaces,

LPGUID

pguidInterfaces

_Inout_ LPDWORD pcguidInterfaces);

LPDWORD

pcguidInterfaces

);

#ifdef UNICODE

#define SCardListInterfaces SCardListInterfacesW

#else

#define SCardListInterfaces SCardListInterfacesA #endif // !UNICODE

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardGetProviderIdA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szCard,

LPCSTR

szCard

_Out_ LPGUID pguidProviderId);

LPGUID

pguidProviderId

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardGetProviderIdW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szCard,

LPCWSTR

szCard

_Out_ LPGUID pguidProviderId);

LPGUID

pguidProviderId

);

#ifdef UNICODE

#define SCardGetProviderId SCardGetProviderIdW

#else

#define SCardGetProviderId SCardGetProviderIdA #endif // !UNICODE

// NOTE: The routine SCardGetProviderId in this implementation uses GUIDs.

// The PC/SC definition uses BYTEs.

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardGetCardTypeProviderNameA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szCardName,

LPCSTR

szCardName

_In_ DWORD dwProviderId,

DWORD

dwProviderId

_When_(_Old_(*pcchProvider) == SCARD_AUTOALLOCATE, _At_((LPSTR *)szProvider, _Outptr_result_buffer_all_(*pcchProvider)))

_When_(_Old_(*pcchProvider) != SCARD_AUTOALLOCATE, _Out_writes_to_(*pcchProvider, *pcchProvider) _Post_z_)

CHAR

szProvider

_Inout_ LPDWORD pcchProvider);

LPDWORD

pcchProvider

);

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardGetCardTypeProviderNameW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szCardName,

LPCWSTR

szCardName

_In_ DWORD dwProviderId,

DWORD

dwProviderId

_When_(_Old_(*pcchProvider) == SCARD_AUTOALLOCATE, _At_((LPWSTR *)szProvider, _Outptr_result_buffer_all_(*pcchProvider)))

_When_(_Old_(*pcchProvider) != SCARD_AUTOALLOCATE, _Out_writes_to_(*pcchProvider, *pcchProvider) _Post_z_)

WCHAR

szProvider

_Inout_ LPDWORD pcchProvider);

LPDWORD

pcchProvider

);

#ifdef UNICODE

#define SCardGetCardTypeProviderName SCardGetCardTypeProviderNameW

#else

#define SCardGetCardTypeProviderName SCardGetCardTypeProviderNameA #endif // !UNICODE

// NOTE: This routine is an extension to the PC/SC definitions.

// Database Writer routines

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardIntroduceReaderGroupA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szGroupName);

LPCSTR

szGroupName

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardIntroduceReaderGroupW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szGroupName);

LPCWSTR

szGroupName

);

#ifdef UNICODE

#define SCardIntroduceReaderGroup SCardIntroduceReaderGroupW

#else

#define SCardIntroduceReaderGroup SCardIntroduceReaderGroupA #endif // !UNICODE

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardForgetReaderGroupA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szGroupName);

LPCSTR

szGroupName

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardForgetReaderGroupW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szGroupName);

LPCWSTR

szGroupName

);

#ifdef UNICODE

#define SCardForgetReaderGroup SCardForgetReaderGroupW

#else

#define SCardForgetReaderGroup SCardForgetReaderGroupA #endif // !UNICODE

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardIntroduceReaderA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szReaderName,

LPCSTR

szReaderName

_In_ LPCSTR szDeviceName);

LPCSTR

szDeviceName

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardIntroduceReaderW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szReaderName,

LPCWSTR

szReaderName

_In_ LPCWSTR szDeviceName);

LPCWSTR

szDeviceName

);

#ifdef UNICODE

#define SCardIntroduceReader SCardIntroduceReaderW

#else

#define SCardIntroduceReader SCardIntroduceReaderA #endif // !UNICODE

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardForgetReaderA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szReaderName);

LPCSTR

szReaderName

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardForgetReaderW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szReaderName);

LPCWSTR

szReaderName

);

#ifdef UNICODE

#define SCardForgetReader SCardForgetReaderW

#else

#define SCardForgetReader SCardForgetReaderA #endif // !UNICODE

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardAddReaderToGroupA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szReaderName,

LPCSTR

szReaderName

_In_ LPCSTR szGroupName);

LPCSTR

szGroupName

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardAddReaderToGroupW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szReaderName,

LPCWSTR

szReaderName

_In_ LPCWSTR szGroupName);

LPCWSTR

szGroupName

);

#ifdef UNICODE

#define SCardAddReaderToGroup SCardAddReaderToGroupW

#else

#define SCardAddReaderToGroup SCardAddReaderToGroupA #endif // !UNICODE

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardRemoveReaderFromGroupA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szReaderName,

LPCSTR

szReaderName

_In_ LPCSTR szGroupName);

LPCSTR

szGroupName

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardRemoveReaderFromGroupW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szReaderName,

LPCWSTR

szReaderName

_In_ LPCWSTR szGroupName);

LPCWSTR

szGroupName

);

#ifdef UNICODE

#define SCardRemoveReaderFromGroup SCardRemoveReaderFromGroupW

#else

#define SCardRemoveReaderFromGroup SCardRemoveReaderFromGroupA #endif // !UNICODE

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardIntroduceCardTypeA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szCardName,

LPCSTR

szCardName

_In_opt_ LPCGUID pguidPrimaryProvider,

LPCGUID

pguidPrimaryProvider

_In_opt_ LPCGUID rgguidInterfaces,

LPCGUID

rgguidInterfaces

_In_ DWORD dwInterfaceCount,

DWORD

dwInterfaceCount

_In_ LPCBYTE pbAtr,

LPCBYTE

pbAtr

_In_ LPCBYTE pbAtrMask,

LPCBYTE

pbAtrMask

_In_ DWORD cbAtrLen);

DWORD

cbAtrLen

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardIntroduceCardTypeW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szCardName,

LPCWSTR

szCardName

_In_opt_ LPCGUID pguidPrimaryProvider,

LPCGUID

pguidPrimaryProvider

_In_opt_ LPCGUID rgguidInterfaces,

LPCGUID

rgguidInterfaces

_In_ DWORD dwInterfaceCount,

DWORD

dwInterfaceCount

_In_ LPCBYTE pbAtr,

LPCBYTE

pbAtr

_In_ LPCBYTE pbAtrMask,

LPCBYTE

pbAtrMask

_In_ DWORD cbAtrLen);

DWORD

cbAtrLen

);

#ifdef UNICODE

#define SCardIntroduceCardType SCardIntroduceCardTypeW

#else

#define SCardIntroduceCardType SCardIntroduceCardTypeA #endif // !UNICODE

// NOTE: The routine SCardIntroduceCardType's parameters' order differs from

// the PC/SC definition. It should be:

// extern WINSCARDAPI LONG WINAPI

// SCardIntroduceCardType(

// _In_ SCARDCONTEXT hContext,

// _In_ LPCTSTR szCardName,

// _In_ LPCBYTE pbAtr,

// _In_ LPCBYTE pbAtrMask,

// _In_ DWORD cbAtrLen,

// _In_opt_ LPCGUID pguidPrimaryProvider,

// _In_opt_ LPCGUID rgguidInterfaces,

// _In_ DWORD dwInterfaceCount);

// Here's a work-around MACRO:

#define PCSCardIntroduceCardType(hContext, szCardName, pbAtr, pbAtrMask, cbAtrLen, pguidPrimaryProvider, rgguidInterfaces, dwInterfaceCount) \

SCardIntroduceCardType(hContext, szCardName, pguidPrimaryProvider, rgguidInterfaces, dwInterfaceCount, pbAtr, pbAtrMask, cbAtrLen)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardSetCardTypeProviderNameA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szCardName,

LPCSTR

szCardName

_In_ DWORD dwProviderId,

DWORD

dwProviderId

_In_ LPCSTR szProvider);

LPCSTR

szProvider

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardSetCardTypeProviderNameW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szCardName,

LPCWSTR

szCardName

_In_ DWORD dwProviderId,

DWORD

dwProviderId

_In_ LPCWSTR szProvider);

LPCWSTR

szProvider

);

#ifdef UNICODE

#define SCardSetCardTypeProviderName SCardSetCardTypeProviderNameW

#else

#define SCardSetCardTypeProviderName SCardSetCardTypeProviderNameA #endif // !UNICODE

// NOTE: This routine is an extention to the PC/SC specifications.

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardForgetCardTypeA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szCardName);

LPCSTR

szCardName

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardForgetCardTypeW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szCardName);

LPCWSTR

szCardName

);

#ifdef UNICODE

#define SCardForgetCardType SCardForgetCardTypeW

#else

#define SCardForgetCardType SCardForgetCardTypeA #endif // !UNICODE

////////////////////////////////////////////////////////////////////////////////

// Service Manager Support Routines

// The following services are supplied to simplify the use of the Service

// Manager API.

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardFreeMemory

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCVOID pvMem);

LPCVOID

pvMem

);

#if (NTDDI_VERSION >= NTDDI_WINXP)

extern WINSCARDAPI HANDLE WINAPI

extern

HANDLE

__stdcall

SCardAccessStartedEvent

(

void

);

extern WINSCARDAPI void WINAPI

extern

void

__stdcall

SCardReleaseStartedEvent

(

void

);

#endif // (NTDDI_VERSION >= NTDDI_WINXP)

////////////////////////////////////////////////////////////////////////////////

// Reader Services

// The following services supply means for tracking cards within readers.

typedef

struct

{

LPCSTR

szReader

;

// reader name

LPVOID

pvUserData

;

// user defined data

DWORD

dwCurrentState

;

// current state of reader at time of call

DWORD

dwEventState

;

// state of reader after state change

DWORD

cbAtr

;

// Number of bytes in the returned ATR.

BYTE

rgbAtr

[

];

// Atr of inserted card, (extra alignment bytes)

}

SCARD_READERSTATEA

, *

PSCARD_READERSTATEA

, *

LPSCARD_READERSTATEA

;

typedef

struct

{

LPCWSTR

szReader

;

// reader name

LPVOID

pvUserData

;

// user defined data

DWORD

dwCurrentState

;

// current state of reader at time of call

DWORD

dwEventState

;

// state of reader after state change

DWORD

cbAtr

;

// Number of bytes in the returned ATR.

BYTE

rgbAtr

[

];

// Atr of inserted card, (extra alignment bytes)

}

SCARD_READERSTATEW

, *

PSCARD_READERSTATEW

, *

LPSCARD_READERSTATEW

;

#ifdef UNICODE

typedef

SCARD_READERSTATEW

SCARD_READERSTATE

;

typedef

PSCARD_READERSTATEW

PSCARD_READERSTATE

;

typedef

LPSCARD_READERSTATEW

LPSCARD_READERSTATE

;

#else

typedef SCARD_READERSTATEA SCARD_READERSTATE;

typedef PSCARD_READERSTATEA PSCARD_READERSTATE;

typedef LPSCARD_READERSTATEA LPSCARD_READERSTATE; #endif // UNICODE

// Backwards compatibility macros

#define SCARD_READERSTATE_A SCARD_READERSTATEA

#define SCARD_READERSTATE_W SCARD_READERSTATEW

#define PSCARD_READERSTATE_A PSCARD_READERSTATEA

#define PSCARD_READERSTATE_W PSCARD_READERSTATEW

#define LPSCARD_READERSTATE_A LPSCARD_READERSTATEA

#define LPSCARD_READERSTATE_W LPSCARD_READERSTATEW

#define SCARD_STATE_UNAWARE 0x00000000 // The application is unaware of the

// current state, and would like to

// know. The use of this value

// results in an immediate return

// from state transition monitoring

// services. This is represented by

// all bits set to zero.

#define SCARD_STATE_IGNORE 0x00000001 // The application requested that

// this reader be ignored. No other

// bits will be set.

#define SCARD_STATE_CHANGED 0x00000002 // This implies that there is a

// difference between the state

// believed by the application, and

// the state known by the Service

// Manager. When this bit is set,

// the application may assume a

// significant state change has

// occurred on this reader.

#define SCARD_STATE_UNKNOWN 0x00000004 // This implies that the given

// reader name is not recognized by

// the Service Manager. If this bit

// is set, then SCARD_STATE_CHANGED

// and SCARD_STATE_IGNORE will also

// be set.

#define SCARD_STATE_UNAVAILABLE 0x00000008 // This implies that the actual

// state of this reader is not

// available. If this bit is set,

// then all the following bits are

// clear.

#define SCARD_STATE_EMPTY 0x00000010 // This implies that there is not

// card in the reader. If this bit

// is set, all the following bits

// will be clear.

#define SCARD_STATE_PRESENT 0x00000020 // This implies that there is a card

// in the reader.

#define SCARD_STATE_ATRMATCH 0x00000040 // This implies that there is a card

// in the reader with an ATR

// matching one of the target cards.

// If this bit is set,

// SCARD_STATE_PRESENT will also be

// set. This bit is only returned

// on the SCardLocateCard() service.

#define SCARD_STATE_EXCLUSIVE 0x00000080 // This implies that the card in the

// reader is allocated for exclusive

// use by another application. If

// this bit is set,

// SCARD_STATE_PRESENT will also be

// set.

#define SCARD_STATE_INUSE 0x00000100 // This implies that the card in the

// reader is in use by one or more

// other applications, but may be

// connected to in shared mode. If

// this bit is set,

// SCARD_STATE_PRESENT will also be

// set.

#define SCARD_STATE_MUTE 0x00000200 // This implies that the card in the

// reader is unresponsive or not

// supported by the reader or

// software.

#define SCARD_STATE_UNPOWERED 0x00000400 // This implies that the card in the

// reader has not been powered up.

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardLocateCardsA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR mszCards,

LPCSTR

mszCards

_Inout_ LPSCARD_READERSTATEA rgReaderStates,

LPSCARD_READERSTATEA

rgReaderStates

_In_ DWORD cReaders);

DWORD

cReaders

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardLocateCardsW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR mszCards,

LPCWSTR

mszCards

_Inout_ LPSCARD_READERSTATEW rgReaderStates,

LPSCARD_READERSTATEW

rgReaderStates

_In_ DWORD cReaders);

DWORD

cReaders

);

#ifdef UNICODE

#define SCardLocateCards SCardLocateCardsW

#else

#define SCardLocateCards SCardLocateCardsA #endif // !UNICODE

#if (NTDDI_VERSION >= NTDDI_WINXP)

typedef

struct

_SCARD_ATRMASK

{

DWORD

cbAtr

;

// Number of bytes in the ATR and the mask.

BYTE

rgbAtr

[

];

// Atr of card (extra alignment bytes)

BYTE

rgbMask

[

];

// Mask for the Atr (extra alignment bytes)

}

SCARD_ATRMASK

, *

PSCARD_ATRMASK

, *

LPSCARD_ATRMASK

;

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardLocateCardsByATRA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPSCARD_ATRMASK rgAtrMasks,

LPSCARD_ATRMASK

rgAtrMasks

_In_ DWORD cAtrs,

DWORD

cAtrs

_Inout_ LPSCARD_READERSTATEA rgReaderStates,

LPSCARD_READERSTATEA

rgReaderStates

_In_ DWORD cReaders);

DWORD

cReaders

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardLocateCardsByATRW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPSCARD_ATRMASK rgAtrMasks,

LPSCARD_ATRMASK

rgAtrMasks

_In_ DWORD cAtrs,

DWORD

cAtrs

_Inout_ LPSCARD_READERSTATEW rgReaderStates,

LPSCARD_READERSTATEW

rgReaderStates

_In_ DWORD cReaders);

DWORD

cReaders

);

#ifdef UNICODE

#define SCardLocateCardsByATR SCardLocateCardsByATRW

#else

#define SCardLocateCardsByATR SCardLocateCardsByATRA #endif // !UNICODE #endif // (NTDDI_VERSION >= NTDDI_WINXP)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardGetStatusChangeA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ DWORD dwTimeout,

DWORD

dwTimeout

_Inout_ LPSCARD_READERSTATEA rgReaderStates,

LPSCARD_READERSTATEA

rgReaderStates

_In_ DWORD cReaders);

DWORD

cReaders

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardGetStatusChangeW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ DWORD dwTimeout,

DWORD

dwTimeout

_Inout_ LPSCARD_READERSTATEW rgReaderStates,

LPSCARD_READERSTATEW

rgReaderStates

_In_ DWORD cReaders);

DWORD

cReaders

);

#ifdef UNICODE

#define SCardGetStatusChange SCardGetStatusChangeW

#else

#define SCardGetStatusChange SCardGetStatusChangeA #endif // !UNICODE

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardCancel

(

_In_ SCARDCONTEXT hContext);

SCARDCONTEXT

hContext

);

////////////////////////////////////////////////////////////////////////////////

// Card/Reader Communication Services

// The following services provide means for communication with the card.

#define SCARD_SHARE_EXCLUSIVE 1 // This application is not willing to share this

// card with other applications.

#define SCARD_SHARE_SHARED 2 // This application is willing to share this

// card with other applications.

#define SCARD_SHARE_DIRECT 3 // This application demands direct control of

// the reader, so it is not available to other

// applications.

#define SCARD_LEAVE_CARD 0 // Don't do anything special on close

#define SCARD_RESET_CARD 1 // Reset the card on close

#define SCARD_UNPOWER_CARD 2 // Power down the card on close

#define SCARD_EJECT_CARD 3 // Eject the card on close

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardConnectA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szReader,

LPCSTR

szReader

_In_ DWORD dwShareMode,

DWORD

dwShareMode

_In_ DWORD dwPreferredProtocols,

DWORD

dwPreferredProtocols

_Out_ LPSCARDHANDLE phCard,

LPSCARDHANDLE

phCard

_Out_ LPDWORD pdwActiveProtocol);

LPDWORD

pdwActiveProtocol

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardConnectW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szReader,

LPCWSTR

szReader

_In_ DWORD dwShareMode,

DWORD

dwShareMode

_In_ DWORD dwPreferredProtocols,

DWORD

dwPreferredProtocols

_Out_ LPSCARDHANDLE phCard,

LPSCARDHANDLE

phCard

_Out_ LPDWORD pdwActiveProtocol);

LPDWORD

pdwActiveProtocol

);

#ifdef UNICODE

#define SCardConnect SCardConnectW

#else

#define SCardConnect SCardConnectA #endif // !UNICODE

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardReconnect

(

_In_ SCARDHANDLE hCard,

SCARDHANDLE

hCard

_In_ DWORD dwShareMode,

DWORD

dwShareMode

_In_ DWORD dwPreferredProtocols,

DWORD

dwPreferredProtocols

_In_ DWORD dwInitialization,

DWORD

dwInitialization

_Out_opt_ LPDWORD pdwActiveProtocol);

LPDWORD

pdwActiveProtocol

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardDisconnect

(

_In_ SCARDHANDLE hCard,

SCARDHANDLE

hCard

_In_ DWORD dwDisposition);

DWORD

dwDisposition

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardBeginTransaction

(

_In_ SCARDHANDLE hCard);

SCARDHANDLE

hCard

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardEndTransaction

(

_In_ SCARDHANDLE hCard,

SCARDHANDLE

hCard

_In_ DWORD dwDisposition);

DWORD

dwDisposition

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardCancelTransaction

(

_In_ SCARDHANDLE hCard);

SCARDHANDLE

hCard

);

// NOTE: This call corresponds to the PC/SC SCARDCOMM::Cancel routine,

// terminating a blocked SCardBeginTransaction service.

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardState

(

_In_ SCARDHANDLE hCard,

SCARDHANDLE

hCard

_Out_ LPDWORD pdwState,

LPDWORD

pdwState

_Out_ LPDWORD pdwProtocol,

LPDWORD

pdwProtocol

_Out_writes_bytes_(*pcbAtrLen) LPBYTE pbAtr,

LPBYTE

pbAtr

_Inout_ LPDWORD pcbAtrLen);

LPDWORD

pcbAtrLen

);

// NOTE: SCardState is an obsolete routine. PC/SC has replaced it with

// SCardStatus.

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardStatusA

(

_In_ SCARDHANDLE hCard,

SCARDHANDLE

hCard

_When_(_Old_(*pcchReaderLen) == SCARD_AUTOALLOCATE, _At_((LPSTR *)mszReaderNames, _Outptr_result_buffer_maybenull_(*pcchReaderLen) _At_(*_Curr_, _Post_z_ _Post_ _NullNull_terminated_)))

_When_(_Old_(*pcchReaderLen) != SCARD_AUTOALLOCATE, _Out_writes_opt_(*pcchReaderLen) _Post_ _NullNull_terminated_)

LPSTR

mszReaderNames

_Inout_opt_ LPDWORD pcchReaderLen,

LPDWORD

pcchReaderLen

_Out_opt_ LPDWORD pdwState,

LPDWORD

pdwState

_Out_opt_ LPDWORD pdwProtocol,

LPDWORD

pdwProtocol

_When_(_Old_(*pcbAtrLen) == SCARD_AUTOALLOCATE, _At_((LPBYTE *)pbAtr, _Outptr_result_buffer_maybenull_(*pcbAtrLen) _At_(*_Curr_, _Post_ _NullNull_terminated_)))

_When_(_Old_(*pcbAtrLen) != SCARD_AUTOALLOCATE, _Out_writes_opt_(*pcbAtrLen) _Post_ _NullNull_terminated_)

LPBYTE

pbAtr

_Inout_opt_ LPDWORD pcbAtrLen);

LPDWORD

pcbAtrLen

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardStatusW

(

_In_ SCARDHANDLE hCard,

SCARDHANDLE

hCard

_When_(_Old_(*pcchReaderLen) == SCARD_AUTOALLOCATE, _At_((LPWSTR *)mszReaderNames, _Outptr_result_buffer_maybenull_(*pcchReaderLen) _At_(*_Curr_, _Post_z_ _Post_ _NullNull_terminated_)))

_When_(_Old_(*pcchReaderLen) != SCARD_AUTOALLOCATE, _Out_writes_opt_(*pcchReaderLen) _Post_ _NullNull_terminated_)

LPWSTR

mszReaderNames

_Inout_opt_ LPDWORD pcchReaderLen,

LPDWORD

pcchReaderLen

_Out_opt_ LPDWORD pdwState,

LPDWORD

pdwState

_Out_opt_ LPDWORD pdwProtocol,

LPDWORD

pdwProtocol

_When_(_Old_(*pcbAtrLen) == SCARD_AUTOALLOCATE, _At_((LPBYTE *)pbAtr, _Outptr_result_buffer_maybenull_(*pcbAtrLen) _At_(*_Curr_, _Post_ _NullNull_terminated_)))

_When_(_Old_(*pcbAtrLen) != SCARD_AUTOALLOCATE, _Out_writes_opt_(*pcbAtrLen) _Post_ _NullNull_terminated_)

LPBYTE

pbAtr

_Inout_opt_ LPDWORD pcbAtrLen);

LPDWORD

pcbAtrLen

);

#ifdef UNICODE

#define SCardStatus SCardStatusW

#else

#define SCardStatus SCardStatusA #endif // !UNICODE

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardTransmit

(

_In_ SCARDHANDLE hCard,

SCARDHANDLE

hCard

_In_ LPCSCARD_IO_REQUEST pioSendPci,

LPCSCARD_IO_REQUEST

pioSendPci

_In_reads_bytes_(cbSendLength) LPCBYTE pbSendBuffer,

LPCBYTE

pbSendBuffer

_In_ DWORD cbSendLength,

DWORD

cbSendLength

_Inout_opt_ LPSCARD_IO_REQUEST pioRecvPci,

LPSCARD_IO_REQUEST

pioRecvPci

_Out_writes_bytes_(*pcbRecvLength) LPBYTE pbRecvBuffer,

LPBYTE

pbRecvBuffer

_Inout_ LPDWORD pcbRecvLength);

LPDWORD

pcbRecvLength

);

#if (NTDDI_VERSION >= NTDDI_VISTA)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardGetTransmitCount

(

_In_ SCARDHANDLE hCard,

SCARDHANDLE

hCard

_Out_ LPDWORD pcTransmitCount); #endif // (NTDDI_VERSION >= NTDDI_VISTA)

LPDWORD

pcTransmitCount

);

////////////////////////////////////////////////////////////////////////////////

// Reader Control Routines

// The following services provide for direct, low-level manipulation of the

// reader by the calling application allowing it control over the

// attributes of the communications with the card.

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardControl

(

_In_ SCARDHANDLE hCard,

SCARDHANDLE

hCard

_In_ DWORD dwControlCode,

DWORD

dwControlCode

_In_reads_bytes_(cbInBufferSize) LPCVOID lpInBuffer,

LPCVOID

lpInBuffer

_In_ DWORD cbInBufferSize,

DWORD

cbInBufferSize

_Out_writes_bytes_(cbOutBufferSize) LPVOID lpOutBuffer,

LPVOID

lpOutBuffer

_In_ DWORD cbOutBufferSize,

DWORD

cbOutBufferSize

_Out_ LPDWORD lpBytesReturned);

LPDWORD

lpBytesReturned

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardGetAttrib

(

_In_ SCARDHANDLE hCard,

SCARDHANDLE

hCard

_In_ DWORD dwAttrId,

DWORD

dwAttrId

_Out_writes_bytes_opt_(*pcbAttrLen) LPBYTE pbAttr,

LPBYTE

pbAttr

_Inout_ LPDWORD pcbAttrLen);

LPDWORD

pcbAttrLen

);

// NOTE: The routine SCardGetAttrib's name differs from the PC/SC definition.

// It should be:

// extern WINSCARDAPI LONG WINAPI

// SCardGetReaderCapabilities(

// _In_ SCARDHANDLE hCard,

// _In_ DWORD dwTag,

// _Out_ LPBYTE pbAttr,

// _Inout_ LPDWORD pcbAttrLen);

// Here's a work-around MACRO:

#define SCardGetReaderCapabilities SCardGetAttrib

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardSetAttrib

(

_In_ SCARDHANDLE hCard,

SCARDHANDLE

hCard

_In_ DWORD dwAttrId,

DWORD

dwAttrId

_In_reads_bytes_(cbAttrLen) LPCBYTE pbAttr,

LPCBYTE

pbAttr

_In_ DWORD cbAttrLen);

DWORD

cbAttrLen

);

// NOTE: The routine SCardSetAttrib's name differs from the PC/SC definition.

// It should be:

// extern WINSCARDAPI LONG WINAPI

// SCardSetReaderCapabilities(

// _In_ SCARDHANDLE hCard,

// _In_ DWORD dwTag,

// _In_ LPCBYTE pbAttr,

// _In_ DWORD cbAttrLen);

// Here's a work-around MACRO:

#define SCardSetReaderCapabilities SCardSetAttrib

////////////////////////////////////////////////////////////////////////////////

// Smart Card Dialog definitions

// The following section contains structures and exported function

// declarations for the Smart Card Common Dialog dialog.

// Defined constants

// Flags

#define SC_DLG_MINIMAL_UI 0x01

#define SC_DLG_NO_UI 0x02

#define SC_DLG_FORCE_UI 0x04

#define SCERR_NOCARDNAME 0x4000

#define SCERR_NOGUIDS 0x8000

typedef SCARDHANDLE (WINAPI *LPOCNCONNPROCA) (_In_ SCARDCONTEXT, _In_ LPSTR, _In_ LPSTR, _In_ PVOID);

typedef

SCARDHANDLE

(

__stdcall

LPOCNCONNPROCA

) (

SCARDCONTEXT

LPSTR

PVOID

);

typedef SCARDHANDLE (WINAPI *LPOCNCONNPROCW) (_In_ SCARDCONTEXT, _In_ LPWSTR, _In_ LPWSTR, _In_ PVOID);

typedef

SCARDHANDLE

(

__stdcall

LPOCNCONNPROCW

) (

SCARDCONTEXT

LPWSTR

PVOID

);

#ifdef UNICODE

#define LPOCNCONNPROC LPOCNCONNPROCW

#else

#define LPOCNCONNPROC LPOCNCONNPROCA #endif // !UNICODE

typedef BOOL (WINAPI *LPOCNCHKPROC) (_In_ SCARDCONTEXT, _In_ SCARDHANDLE, _In_ PVOID);

typedef

BOOL

(

__stdcall

LPOCNCHKPROC

) (

SCARDCONTEXT

SCARDHANDLE

PVOID

);

typedef void (WINAPI *LPOCNDSCPROC) (_In_ SCARDCONTEXT, _In_ SCARDHANDLE, _In_ PVOID);

typedef

void

(

__stdcall

LPOCNDSCPROC

) (

SCARDCONTEXT

SCARDHANDLE

PVOID

);

// OPENCARD_SEARCH_CRITERIA: In order to specify a user-extended search,

// lpfnCheck must not be NULL. Moreover, the connection to be made to the

// card before performing the callback must be indicated by either providing

// lpfnConnect and lpfnDisconnect OR by setting dwShareMode.

// If both the connection callbacks and dwShareMode are non-NULL, the callbacks

// will be used.

typedef

struct

{

DWORD

dwStructSize

;

LPSTR

lpstrGroupNames

;

// OPTIONAL reader groups to include in

DWORD

nMaxGroupNames

;

// search. NULL defaults to

// SCard$DefaultReaders

LPCGUID

rgguidInterfaces

;

// OPTIONAL requested interfaces

DWORD

cguidInterfaces

;

// supported by card's SSP

LPSTR

lpstrCardNames

;

// OPTIONAL requested card names; all cards w/

DWORD

nMaxCardNames

;

// matching ATRs will be accepted

LPOCNCHKPROC

lpfnCheck

;

// OPTIONAL if NULL no user check will be performed.

LPOCNCONNPROCA

lpfnConnect

;

// OPTIONAL if lpfnConnect is provided,

LPOCNDSCPROC

lpfnDisconnect

;

// lpfnDisconnect must also be set.

LPVOID

pvUserData

;

// OPTIONAL parameter to callbacks

DWORD

dwShareMode

;

// OPTIONAL must be set if lpfnCheck is not null

DWORD

dwPreferredProtocols

;

// OPTIONAL

}

OPENCARD_SEARCH_CRITERIAA

, *

POPENCARD_SEARCH_CRITERIAA

, *

LPOPENCARD_SEARCH_CRITERIAA

;

typedef

struct

{

DWORD

dwStructSize

;

LPWSTR

lpstrGroupNames

;

// OPTIONAL reader groups to include in

DWORD

nMaxGroupNames

;

// search. NULL defaults to

// SCard$DefaultReaders

LPCGUID

rgguidInterfaces

;

// OPTIONAL requested interfaces

DWORD

cguidInterfaces

;

// supported by card's SSP

LPWSTR

lpstrCardNames

;

// OPTIONAL requested card names; all cards w/

DWORD

nMaxCardNames

;

// matching ATRs will be accepted

LPOCNCHKPROC

lpfnCheck

;

// OPTIONAL if NULL no user check will be performed.

LPOCNCONNPROCW

lpfnConnect

;

// OPTIONAL if lpfnConnect is provided,

LPOCNDSCPROC

lpfnDisconnect

;

// lpfnDisconnect must also be set.

LPVOID

pvUserData

;

// OPTIONAL parameter to callbacks

DWORD

dwShareMode

;

// OPTIONAL must be set if lpfnCheck is not null

DWORD

dwPreferredProtocols

;

// OPTIONAL

}

OPENCARD_SEARCH_CRITERIAW

, *

POPENCARD_SEARCH_CRITERIAW

, *

LPOPENCARD_SEARCH_CRITERIAW

;

#ifdef UNICODE

typedef

OPENCARD_SEARCH_CRITERIAW

OPENCARD_SEARCH_CRITERIA

;

typedef

POPENCARD_SEARCH_CRITERIAW

POPENCARD_SEARCH_CRITERIA

;

typedef

LPOPENCARD_SEARCH_CRITERIAW

LPOPENCARD_SEARCH_CRITERIA

;

#else

typedef OPENCARD_SEARCH_CRITERIAA OPENCARD_SEARCH_CRITERIA;

typedef POPENCARD_SEARCH_CRITERIAA POPENCARD_SEARCH_CRITERIA;

typedef LPOPENCARD_SEARCH_CRITERIAA LPOPENCARD_SEARCH_CRITERIA; #endif // UNICODE

// OPENCARDNAME_EX: used by SCardUIDlgSelectCard; replaces obsolete OPENCARDNAME

typedef

struct

{

DWORD

dwStructSize

;

// REQUIRED

SCARDCONTEXT

hSCardContext

;

// REQUIRED

HWND

hwndOwner

;

// OPTIONAL

DWORD

dwFlags

;

// OPTIONAL -- default is SC_DLG_MINIMAL_UI

LPCSTR

lpstrTitle

;

// OPTIONAL

LPCSTR

lpstrSearchDesc

;

// OPTIONAL (eg. "Please insert your <brandname> smart card.")

HICON

hIcon

;

// OPTIONAL 32x32 icon for your brand insignia

POPENCARD_SEARCH_CRITERIAA

pOpenCardSearchCriteria

;

// OPTIONAL

LPOCNCONNPROCA

lpfnConnect

;

// OPTIONAL - performed on successful selection

LPVOID

pvUserData

;

// OPTIONAL parameter to lpfnConnect

DWORD

dwShareMode

;

// OPTIONAL - if lpfnConnect is NULL, dwShareMode and

DWORD

dwPreferredProtocols

;

// OPTIONAL dwPreferredProtocols will be used to

// connect to the selected card

LPSTR

lpstrRdr

;

// REQUIRED [IN|OUT] Name of selected reader

DWORD

nMaxRdr

;

// REQUIRED [IN|OUT]

LPSTR

lpstrCard

;

// REQUIRED [IN|OUT] Name of selected card

DWORD

nMaxCard

;

// REQUIRED [IN|OUT]

DWORD

dwActiveProtocol

;

// [OUT] set only if dwShareMode not NULL

SCARDHANDLE

hCardHandle

;

// [OUT] set if a card connection was indicated

}

OPENCARDNAME_EXA

, *

POPENCARDNAME_EXA

, *

LPOPENCARDNAME_EXA

;

typedef

struct

{

DWORD

dwStructSize

;

// REQUIRED

SCARDCONTEXT

hSCardContext

;

// REQUIRED

HWND

hwndOwner

;

// OPTIONAL

DWORD

dwFlags

;

// OPTIONAL -- default is SC_DLG_MINIMAL_UI

LPCWSTR

lpstrTitle

;

// OPTIONAL

LPCWSTR

lpstrSearchDesc

;

// OPTIONAL (eg. "Please insert your <brandname> smart card.")

HICON

hIcon

;

// OPTIONAL 32x32 icon for your brand insignia

POPENCARD_SEARCH_CRITERIAW

pOpenCardSearchCriteria

;

// OPTIONAL

LPOCNCONNPROCW

lpfnConnect

;

// OPTIONAL - performed on successful selection

LPVOID

pvUserData

;

// OPTIONAL parameter to lpfnConnect

DWORD

dwShareMode

;

// OPTIONAL - if lpfnConnect is NULL, dwShareMode and

DWORD

dwPreferredProtocols

;

// OPTIONAL dwPreferredProtocols will be used to

// connect to the selected card

LPWSTR

lpstrRdr

;

// REQUIRED [IN|OUT] Name of selected reader

DWORD

nMaxRdr

;

// REQUIRED [IN|OUT]

LPWSTR

lpstrCard

;

// REQUIRED [IN|OUT] Name of selected card

DWORD

nMaxCard

;

// REQUIRED [IN|OUT]

DWORD

dwActiveProtocol

;

// [OUT] set only if dwShareMode not NULL

SCARDHANDLE

hCardHandle

;

// [OUT] set if a card connection was indicated

}

OPENCARDNAME_EXW

, *

POPENCARDNAME_EXW

, *

LPOPENCARDNAME_EXW

;

#ifdef UNICODE

typedef

OPENCARDNAME_EXW

OPENCARDNAME_EX

;

typedef

POPENCARDNAME_EXW

POPENCARDNAME_EX

;

typedef

LPOPENCARDNAME_EXW

LPOPENCARDNAME_EX

;

#else

typedef OPENCARDNAME_EXA OPENCARDNAME_EX;

typedef POPENCARDNAME_EXA POPENCARDNAME_EX;

typedef LPOPENCARDNAME_EXA LPOPENCARDNAME_EX; #endif // UNICODE

#define OPENCARDNAMEA_EX OPENCARDNAME_EXA

#define OPENCARDNAMEW_EX OPENCARDNAME_EXW

#define POPENCARDNAMEA_EX POPENCARDNAME_EXA

#define POPENCARDNAMEW_EX POPENCARDNAME_EXW

#define LPOPENCARDNAMEA_EX LPOPENCARDNAME_EXA

#define LPOPENCARDNAMEW_EX LPOPENCARDNAME_EXW

// Smart Card Reader Selection Provider

// Only UNICODE is supported. Invoke smart card reader selection provider by calling

// CredUIPromptForWindowsCredentials() supplying SCARD_READER_SEL_AUTH_PACKAGE as

// pulAuthPackage, an instance of READER_SEL_REQUEST as pvInAuthBuffer and setting

// CREDUIWIN_AUTHPACKAGE_ONLY in dwFlags. Upon successful return, an instance of

// READER_SEL_RESPONSE will be returned in ppvOutAuthBuffer.

#define SCARD_READER_SEL_AUTH_PACKAGE ((DWORD)-629)

// READER_SEL_REQUEST

// Reader selection request to reader selection provider

// Members:

// dwShareMode:

// Share mode used by SCardConnect to connect to smart cards

// dwPreferredProtocols:

// Acceptable protocols for SCardConnect to connect to smart cards

// MatchType:

// Indicates how the caller wants the reader selection provider to verify smart

// cards.

// If MatchType is set to RSR_MATCH_TYPE_READER_AND_CONTAINER, reader selection

// provider will match smart cards based on whether they are in the given

// reader and have the given key container. Reader name and container name are

// both optional. Reader name and container name, if any, need to be appended

// after READER_SEL_REQUEST structure and set their offsets and lengths in

// ReaderAndContainerParameter member.

// If MatchType is set to RSR_MATCH_TYPE_SERIAL_NUMBER, reader selection

// provider will match smart cards based on their serial numbers / card IDs.

// Serial number is required. It needs to be appended after READER_SEL_REQUEST

// structure as a byte array and set its offset and length in

// SerialNumberParameter member.

// If MatchType is set to RSR_MATCH_TYPE_ALL_CARDS, reader selection provider

// will allow all recognized cards to be selected by user without any filtering.

// The card may not be personalized for Base CSP / Smart Card KSP yet, or even

// have its own CSP.

// ReaderAndContainerParameter.cbReaderNameOffset:

// Byte offset of reader name UNICODE string from the beginning of

// READER_SEL_REQUEST structure

// ReaderAndContainerParameter.cchReaderNameLength:

// Number of characters in reader name UNICODE string including the terminating

// NULL character

// ReaderAndContainerParameter.cbContainerNameOffset:

// Byte offset of container name UNICODE string from the beginning of

// READER_SEL_REQUEST structure

// ReaderAndContainerParameter.cchContainerNameLength:

// Number of characters in container name UNICODE string including the

// terminating NULL character

// ReaderAndContainerParameter.dwDesiredCardModuleVersion:

// The desired smart card module version

// ReaderAndContainerParameter.dwCspFlags:

// CSP and KSP flags to indicate how smart cards will be used

// (Valid flags include CRYPT_NEWKEYSET, CRYPT_DELETEKEYSET, CRYPT_VERIFYCONTEXT

// and CRYPT_DEFAULT_CONTAINER_OPTIONAL)

// SerialNumberParameter.cbSerialNumberOffset:

// Byte offset of serial number byte array from the beginning of

// READER_SEL_REQUEST structure

// SerialNumberParameter.cbSerialNumberLength:

// Number of bytes in serial number byte array

// SerialNumberParameter.dwDesiredCardModuleVersion:

// The desired smart card module version

typedef

enum

{

RSR_MATCH_TYPE_READER_AND_CONTAINER

RSR_MATCH_TYPE_SERIAL_NUMBER

RSR_MATCH_TYPE_ALL_CARDS

}

READER_SEL_REQUEST_MATCH_TYPE

;

typedef

struct

{

DWORD

dwShareMode

;

DWORD

dwPreferredProtocols

;

READER_SEL_REQUEST_MATCH_TYPE

MatchType

; #pragma warning(push) #pragma warning(disable:

4201

)

union

{

struct

{

DWORD

cbReaderNameOffset

;

DWORD

cchReaderNameLength

;

DWORD

cbContainerNameOffset

;

DWORD

cchContainerNameLength

;

DWORD

dwDesiredCardModuleVersion

;

DWORD

dwCspFlags

; }

ReaderAndContainerParameter

;

struct

{

DWORD

cbSerialNumberOffset

;

DWORD

cbSerialNumberLength

;

DWORD

dwDesiredCardModuleVersion

; }

SerialNumberParameter

;

} DUMMYUNIONNAME;

} ;

#pragma warning(pop) }

READER_SEL_REQUEST

, *

PREADER_SEL_REQUEST

;

// READER_SEL_RESPONSE

// Reader selection response from reader selection provider

// Members:

// cbReaderNameOffset:

// Byte offset of matched reader name UNICODE string from the beginning of

// READER_SEL_RESPONSE structure

// cchReaderNameLength:

// Number of characters in matched reader name UNICODE string including the

// terminating NULL character

// cbCardNameOffset:

// Byte offset of matched card name UNICODE string from the beginning of

// READER_SEL_RESPONSE structure

// cchCardNameLength:

// Number of characters in matched card name UNICODE string including the

// terminating NULL character

typedef

struct

{

DWORD

cbReaderNameOffset

;

DWORD

cchReaderNameLength

;

DWORD

cbCardNameOffset

;

DWORD

cchCardNameLength

; }

READER_SEL_RESPONSE

, *

PREADER_SEL_RESPONSE

;

// SCardUIDlgSelectCard replaces GetOpenCardName

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardUIDlgSelectCardA

(

LPOPENCARDNAMEA_EX);

LPOPENCARDNAME_EXA

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardUIDlgSelectCardW

(

LPOPENCARDNAMEW_EX);

LPOPENCARDNAME_EXW

);

#ifdef UNICODE

#define SCardUIDlgSelectCard SCardUIDlgSelectCardW

#else

#define SCardUIDlgSelectCard SCardUIDlgSelectCardA #endif // !UNICODE

// "Smart Card Common Dialog" definitions for backwards compatibility

// with the Smart Card Base Services SDK version 1.0

typedef

struct

{

DWORD

dwStructSize

;

HWND

hwndOwner

;

SCARDCONTEXT

hSCardContext

;

LPSTR

lpstrGroupNames

;

DWORD

nMaxGroupNames

;

LPSTR

lpstrCardNames

;

DWORD

nMaxCardNames

;

LPCGUID

rgguidInterfaces

;

DWORD

cguidInterfaces

;

LPSTR

lpstrRdr

;

DWORD

nMaxRdr

;

LPSTR

lpstrCard

;

DWORD

nMaxCard

;

LPCSTR

lpstrTitle

;

DWORD

dwFlags

;

LPVOID

pvUserData

;

DWORD

dwShareMode

;

DWORD

dwPreferredProtocols

;

DWORD

dwActiveProtocol

;

LPOCNCONNPROCA

lpfnConnect

;

LPOCNCHKPROC

lpfnCheck

;

LPOCNDSCPROC

lpfnDisconnect

;

SCARDHANDLE

hCardHandle

; }

OPENCARDNAMEA

, *

POPENCARDNAMEA

, *

LPOPENCARDNAMEA

;

typedef

struct

{

DWORD

dwStructSize

;

HWND

hwndOwner

;

SCARDCONTEXT

hSCardContext

;

LPWSTR

lpstrGroupNames

;

DWORD

nMaxGroupNames

;

LPWSTR

lpstrCardNames

;

DWORD

nMaxCardNames

;

LPCGUID

rgguidInterfaces

;

DWORD

cguidInterfaces

;

LPWSTR

lpstrRdr

;

DWORD

nMaxRdr

;

LPWSTR

lpstrCard

;

DWORD

nMaxCard

;

LPCWSTR

lpstrTitle

;

DWORD

dwFlags

;

LPVOID

pvUserData

;

DWORD

dwShareMode

;

DWORD

dwPreferredProtocols

;

DWORD

dwActiveProtocol

;

LPOCNCONNPROCW

lpfnConnect

;

LPOCNCHKPROC

lpfnCheck

;

LPOCNDSCPROC

lpfnDisconnect

;

SCARDHANDLE

hCardHandle

; }

OPENCARDNAMEW

, *

POPENCARDNAMEW

, *

LPOPENCARDNAMEW

;

#ifdef UNICODE

typedef

OPENCARDNAMEW

OPENCARDNAME

;

typedef

POPENCARDNAMEW

POPENCARDNAME

;

typedef

LPOPENCARDNAMEW

LPOPENCARDNAME

;

#else

typedef OPENCARDNAMEA OPENCARDNAME;

typedef POPENCARDNAMEA POPENCARDNAME;

typedef LPOPENCARDNAMEA LPOPENCARDNAME; #endif // UNICODE

// Backwards compatibility macros

#define OPENCARDNAME_A OPENCARDNAMEA

#define OPENCARDNAME_W OPENCARDNAMEW

#define POPENCARDNAME_A POPENCARDNAMEA

#define POPENCARDNAME_W POPENCARDNAMEW

#define LPOPENCARDNAME_A LPOPENCARDNAMEA

#define LPOPENCARDNAME_W LPOPENCARDNAMEW

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

GetOpenCardNameA

(

LPOPENCARDNAMEA

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

GetOpenCardNameW

(

LPOPENCARDNAMEW

);

#ifdef UNICODE

#define GetOpenCardName GetOpenCardNameW

#else

#define GetOpenCardName GetOpenCardNameA #endif // !UNICODE

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardDlgExtendedError

(

void

);

#if (NTDDI_VERSION >= NTDDI_VISTA)

// Smartcard Caching API

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardReadCacheA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ UUID *CardIdentifier,

UUID

CardIdentifier

_In_ DWORD FreshnessCounter,

DWORD

FreshnessCounter

_In_ LPSTR LookupName,

LPSTR

LookupName

_Out_writes_bytes_(*DataLen) PBYTE Data,

PBYTE

Data

_Out_ DWORD *DataLen);

DWORD

DataLen

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardReadCacheW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ UUID *CardIdentifier,

UUID

CardIdentifier

_In_ DWORD FreshnessCounter,

DWORD

FreshnessCounter

_In_ LPWSTR LookupName,

LPWSTR

LookupName

_Out_writes_bytes_(*DataLen) PBYTE Data,

PBYTE

Data

_Out_ DWORD *DataLen);

DWORD

DataLen

);

#ifdef UNICODE

#define SCardReadCache SCardReadCacheW

#else

#define SCardReadCache SCardReadCacheA #endif // !UNICODE

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardWriteCacheA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ UUID *CardIdentifier,

UUID

CardIdentifier

_In_ DWORD FreshnessCounter,

DWORD

FreshnessCounter

_In_ LPSTR LookupName,

LPSTR

LookupName

_In_reads_bytes_(DataLen) PBYTE Data,

PBYTE

Data

_In_ DWORD DataLen);

DWORD

DataLen

);

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardWriteCacheW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ UUID *CardIdentifier,

UUID

CardIdentifier

_In_ DWORD FreshnessCounter,

DWORD

FreshnessCounter

_In_ LPWSTR LookupName,

LPWSTR

LookupName

_In_reads_bytes_(DataLen) PBYTE Data,

PBYTE

Data

_In_ DWORD DataLen);

DWORD

DataLen

);

#ifdef UNICODE

#define SCardWriteCache SCardWriteCacheW

#else

#define SCardWriteCache SCardWriteCacheA #endif // !UNICODE

#endif // (NTDDI_VERSION >= NTDDI_VISTA)

#if (NTDDI_VERSION >= NTDDI_WIN8)

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardGetReaderIconA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szReaderName,

LPCSTR

szReaderName

_When_(_Old_(*pcbIcon) == SCARD_AUTOALLOCATE, _At_((LPBYTE *)pbIcon, _Outptr_result_bytebuffer_all_maybenull_(*pcbIcon)))

_When_(_Old_(*pcbIcon) != SCARD_AUTOALLOCATE, _Out_writes_bytes_to_(*pcbIcon, *pcbIcon) _Post_z_)

LPBYTE

pbIcon

_Inout_ LPDWORD pcbIcon);

LPDWORD

pcbIcon

);

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardGetReaderIconW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szReaderName,

LPCWSTR

szReaderName

_When_(_Old_(*pcbIcon) == SCARD_AUTOALLOCATE, _At_((LPBYTE *)pbIcon, _Outptr_result_bytebuffer_all_maybenull_(*pcbIcon)))

_When_(_Old_(*pcbIcon) != SCARD_AUTOALLOCATE, _Out_writes_bytes_to_(*pcbIcon, *pcbIcon) _Post_z_)

LPBYTE

pbIcon

_Inout_ LPDWORD pcbIcon);

LPDWORD

pcbIcon

);

#ifdef UNICODE

#define SCardGetReaderIcon SCardGetReaderIconW

#else

#define SCardGetReaderIcon SCardGetReaderIconA #endif // !UNICODE

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardGetDeviceTypeIdA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szReaderName,

LPCSTR

szReaderName

_Inout_ LPDWORD pdwDeviceTypeId);

LPDWORD

pdwDeviceTypeId

);

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardGetDeviceTypeIdW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szReaderName,

LPCWSTR

szReaderName

_Inout_ LPDWORD pdwDeviceTypeId);

LPDWORD

pdwDeviceTypeId

);

#ifdef UNICODE

#define SCardGetDeviceTypeId SCardGetDeviceTypeIdW

#else

#define SCardGetDeviceTypeId SCardGetDeviceTypeIdA #endif // !UNICODE

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardGetReaderDeviceInstanceIdA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szReaderName,

LPCSTR

szReaderName

_When_(_Old_(*pcchDeviceInstanceId) == SCARD_AUTOALLOCATE, _At_((LPSTR *)szDeviceInstanceId, _Outptr_result_buffer_maybenull_(*pcchDeviceInstanceId) _At_(*_Curr_, _Post_z_ _Post_ _NullNull_terminated_)))

_When_(_Old_(*pcchDeviceInstanceId) != SCARD_AUTOALLOCATE, _Out_writes_opt_(*pcchDeviceInstanceId) _Post_ _NullNull_terminated_)

LPSTR

szDeviceInstanceId

_Inout_ LPDWORD pcchDeviceInstanceId);

LPDWORD

pcchDeviceInstanceId

);

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardGetReaderDeviceInstanceIdW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szReaderName,

LPCWSTR

szReaderName

_When_(_Old_(*pcchDeviceInstanceId) == SCARD_AUTOALLOCATE, _At_((LPWSTR *)szDeviceInstanceId, _Outptr_result_buffer_maybenull_(*pcchDeviceInstanceId) _At_(*_Curr_, _Post_z_ _Post_ _NullNull_terminated_)))

_When_(_Old_(*pcchDeviceInstanceId) != SCARD_AUTOALLOCATE, _Out_writes_opt_(*pcchDeviceInstanceId) _Post_ _NullNull_terminated_)

LPWSTR

szDeviceInstanceId

_Inout_ LPDWORD pcchDeviceInstanceId);

LPDWORD

pcchDeviceInstanceId

);

#ifdef UNICODE

#define SCardGetReaderDeviceInstanceId SCardGetReaderDeviceInstanceIdW

#else

#define SCardGetReaderDeviceInstanceId SCardGetReaderDeviceInstanceIdA #endif // !UNICODE

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardListReadersWithDeviceInstanceIdA

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCSTR szDeviceInstanceId,

LPCSTR

szDeviceInstanceId

_When_(_Old_(*pcchReaders) == SCARD_AUTOALLOCATE, _At_((LPSTR *)mszReaders, _Outptr_result_buffer_maybenull_(*pcchReaders) _At_(*_Curr_, _Post_z_ _Post_ _NullNull_terminated_)))

_When_(_Old_(*pcchReaders) != SCARD_AUTOALLOCATE, _Out_writes_opt_(*pcchReaders) _Post_ _NullNull_terminated_)

LPSTR

mszReaders

_Inout_ LPDWORD pcchReaders);

LPDWORD

pcchReaders

);

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardListReadersWithDeviceInstanceIdW

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ LPCWSTR szDeviceInstanceId,

LPCWSTR

szDeviceInstanceId

_When_(_Old_(*pcchReaders) == SCARD_AUTOALLOCATE, _At_((LPWSTR *)mszReaders, _Outptr_result_buffer_maybenull_(*pcchReaders) _At_(*_Curr_, _Post_z_ _Post_ _NullNull_terminated_)))

_When_(_Old_(*pcchReaders) != SCARD_AUTOALLOCATE, _Out_writes_opt_(*pcchReaders) _Post_ _NullNull_terminated_)

LPWSTR

mszReaders

_Inout_ LPDWORD pcchReaders);

LPDWORD

pcchReaders

);

#ifdef UNICODE

#define SCardListReadersWithDeviceInstanceId SCardListReadersWithDeviceInstanceIdW

#else

#define SCardListReadersWithDeviceInstanceId SCardListReadersWithDeviceInstanceIdA #endif // !UNICODE

////////////////////////////////////////////////////////////////////////////////

// Smart Card Auditing

#define SCARD_AUDIT_CHV_FAILURE 0x0 // A smart card holder verification (CHV)

// attempt failed.

#define SCARD_AUDIT_CHV_SUCCESS 0x1 // A smart card holder verification (CHV)

// attempt succeeded.

_Success_(return == SCARD_S_SUCCESS)

extern WINSCARDAPI LONG WINAPI

extern

LONG

__stdcall

SCardAudit

(

_In_ SCARDCONTEXT hContext,

SCARDCONTEXT

hContext

_In_ DWORD dwEvent);

DWORD

dwEvent

);

#endif // (NTDDI_VERSION >= NTDDI_WIN8)

#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */

#pragma endregion

#if _MSC_VER >= 1200

#pragma warning(pop)

#endif

#ifdef __cplusplus

}

#endif #endif // _WINSCARD_H_