home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / winscard.h < prev    next >
C/C++ Source or Header  |  2000-02-01  |  38KB  |  1,044 lines
  1. /*++
  2.  
  3. Copyright (c) 1996  Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     WinSCard
  8.  
  9. Abstract:
  10.  
  11.     This header file provides the definitions and symbols necessary for an
  12.     Application or Smart Card Service Provider to access the Smartcard
  13.     Subsystem.
  14.  
  15. Author:
  16.  
  17.     Doug Barlow (dbarlow) 10/23/1996
  18.  
  19. Environment:
  20.  
  21.     Win32
  22.  
  23. Notes:
  24.  
  25. --*/
  26.  
  27. #ifndef _WINSCARD_H_
  28. #pragma option push -b -a8 -pc -A- /*P_O_Push*/
  29. #define _WINSCARD_H_
  30.  
  31. #if defined (_MSC_VER) && (_MSC_VER >= 1020)
  32. #pragma once
  33. #endif
  34.  
  35. #include <wtypes.h>
  36. #include <winioctl.h>
  37. #include "winsmcrd.h"
  38. #ifndef SCARD_S_SUCCESS
  39. #include "SCardErr.h"
  40. #endif
  41.  
  42. #ifdef __cplusplus
  43. extern "C" {
  44. #endif
  45.  
  46. #ifndef _LPCBYTE_DEFINED
  47. #define _LPCBYTE_DEFINED
  48. typedef const BYTE *LPCBYTE;
  49. #endif
  50. #ifndef _LPCVOID_DEFINED
  51. #define _LPCVOID_DEFINED
  52. typedef const VOID *LPCVOID;
  53. #endif
  54.  
  55. #ifndef WINSCARDAPI
  56. #define WINSCARDAPI
  57. #endif
  58. #ifndef WINSCARDDATA
  59. #define WINSCARDDATA __declspec(dllimport)
  60. #endif
  61.  
  62. WINSCARDDATA extern const SCARD_IO_REQUEST
  63.     g_rgSCardT0Pci,
  64.     g_rgSCardT1Pci,
  65.     g_rgSCardRawPci;
  66. #define SCARD_PCI_T0  (&g_rgSCardT0Pci)
  67. #define SCARD_PCI_T1  (&g_rgSCardT1Pci)
  68. #define SCARD_PCI_RAW (&g_rgSCardRawPci)
  69.  
  70.  
  71. //
  72. ////////////////////////////////////////////////////////////////////////////////
  73. //
  74. //  Service Manager Access Services
  75. //
  76. //      The following services are used to manage user and terminal contexts for
  77. //      Smart Cards.
  78. //
  79.  
  80. typedef ULONG_PTR SCARDCONTEXT;
  81. typedef SCARDCONTEXT *PSCARDCONTEXT, *LPSCARDCONTEXT;
  82.  
  83. typedef ULONG_PTR SCARDHANDLE;
  84. typedef SCARDHANDLE *PSCARDHANDLE, *LPSCARDHANDLE;
  85.  
  86. #define SCARD_AUTOALLOCATE (DWORD)(-1)
  87.  
  88. #define SCARD_SCOPE_USER     0  // The context is a user context, and any
  89.                                 // database operations are performed within the
  90.                                 // domain of the user.
  91. #define SCARD_SCOPE_TERMINAL 1  // The context is that of the current terminal,
  92.                                 // and any database operations are performed
  93.                                 // within the domain of that terminal.  (The
  94.                                 // calling application must have appropriate
  95.                                 // access permissions for any database actions.)
  96. #define SCARD_SCOPE_SYSTEM    2 // The context is the system context, and any
  97.                                 // database operations are performed within the
  98.                                 // domain of the system.  (The calling
  99.                                 // application must have appropriate access
  100.                                 // permissions for any database actions.)
  101.  
  102. extern WINSCARDAPI LONG WINAPI
  103. SCardEstablishContext(
  104.     IN  DWORD dwScope,
  105.     IN  LPCVOID pvReserved1,
  106.     IN  LPCVOID pvReserved2,
  107.     OUT LPSCARDCONTEXT phContext);
  108.  
  109. extern WINSCARDAPI LONG WINAPI
  110. SCardReleaseContext(
  111.     IN      SCARDCONTEXT hContext);
  112.  
  113. extern WINSCARDAPI LONG WINAPI
  114. SCardIsValidContext(
  115.     IN      SCARDCONTEXT hContext);
  116.  
  117.  
  118. //
  119. ////////////////////////////////////////////////////////////////////////////////
  120. //
  121. //  Smart Card Database Management Services
  122. //
  123. //      The following services provide for managing the Smart Card Database.
  124. //
  125.  
  126. #define SCARD_ALL_READERS       TEXT("SCard$AllReaders\000")
  127. #define SCARD_DEFAULT_READERS   TEXT("SCard$DefaultReaders\000")
  128. #define SCARD_LOCAL_READERS     TEXT("SCard$LocalReaders\000")
  129. #define SCARD_SYSTEM_READERS    TEXT("SCard$SystemReaders\000")
  130.  
  131. #define SCARD_PROVIDER_PRIMARY  1   // Primary Provider Id
  132. #define SCARD_PROVIDER_CSP      2   // Crypto Service Provider Id
  133.  
  134.  
  135. //
  136. // Database Reader routines
  137. //
  138.  
  139. extern WINSCARDAPI LONG WINAPI
  140. SCardListReaderGroupsA(
  141.     IN      SCARDCONTEXT hContext,
  142.     OUT     LPSTR mszGroups,
  143.     IN OUT  LPDWORD pcchGroups);
  144. extern WINSCARDAPI LONG WINAPI
  145. SCardListReaderGroupsW(
  146.     IN      SCARDCONTEXT hContext,
  147.     OUT     LPWSTR mszGroups,
  148.     IN OUT  LPDWORD pcchGroups);
  149. #ifdef UNICODE
  150. #define SCardListReaderGroups  SCardListReaderGroupsW
  151. #else
  152. #define SCardListReaderGroups  SCardListReaderGroupsA
  153. #endif // !UNICODE
  154.  
  155. extern WINSCARDAPI LONG WINAPI
  156. SCardListReadersA(
  157.     IN      SCARDCONTEXT hContext,
  158.     IN      LPCSTR mszGroups,
  159.     OUT     LPSTR mszReaders,
  160.     IN OUT  LPDWORD pcchReaders);
  161. extern WINSCARDAPI LONG WINAPI
  162. SCardListReadersW(
  163.     IN      SCARDCONTEXT hContext,
  164.     IN      LPCWSTR mszGroups,
  165.     OUT     LPWSTR mszReaders,
  166.     IN OUT  LPDWORD pcchReaders);
  167. #ifdef UNICODE
  168. #define SCardListReaders  SCardListReadersW
  169. #else
  170. #define SCardListReaders  SCardListReadersA
  171. #endif // !UNICODE
  172.  
  173. extern WINSCARDAPI LONG WINAPI
  174. SCardListCardsA(
  175.     IN      SCARDCONTEXT hContext,
  176.     IN      LPCBYTE pbAtr,
  177.     IN      LPCGUID rgquidInterfaces,
  178.     IN      DWORD cguidInterfaceCount,
  179.     OUT     LPSTR mszCards,
  180.     IN OUT  LPDWORD pcchCards);
  181. extern WINSCARDAPI LONG WINAPI
  182. SCardListCardsW(
  183.     IN      SCARDCONTEXT hContext,
  184.     IN      LPCBYTE pbAtr,
  185.     IN      LPCGUID rgquidInterfaces,
  186.     IN      DWORD cguidInterfaceCount,
  187.     OUT     LPWSTR mszCards,
  188.     IN OUT  LPDWORD pcchCards);
  189. #ifdef UNICODE
  190. #define SCardListCards  SCardListCardsW
  191. #else
  192. #define SCardListCards  SCardListCardsA
  193. #endif // !UNICODE
  194. //
  195. // NOTE:    The routine SCardListCards name differs from the PC/SC definition.
  196. //          It should be:
  197. //
  198. //              extern WINSCARDAPI LONG WINAPI
  199. //              SCardListCardTypes(
  200. //                  IN      SCARDCONTEXT hContext,
  201. //                  IN      LPCBYTE pbAtr,
  202. //                  IN      LPCGUID rgquidInterfaces,
  203. //                  IN      DWORD cguidInterfaceCount,
  204. //                  OUT     LPTSTR mszCards,
  205. //                  IN OUT  LPDWORD pcchCards);
  206. //
  207. //          Here's a work-around MACRO:
  208. #define SCardListCardTypes SCardListCards
  209.  
  210. extern WINSCARDAPI LONG WINAPI
  211. SCardListInterfacesA(
  212.     IN      SCARDCONTEXT hContext,
  213.     IN      LPCSTR szCard,
  214.     OUT     LPGUID pguidInterfaces,
  215.     IN OUT  LPDWORD pcguidInterfaces);
  216. extern WINSCARDAPI LONG WINAPI
  217. SCardListInterfacesW(
  218.     IN      SCARDCONTEXT hContext,
  219.     IN      LPCWSTR szCard,
  220.     OUT     LPGUID pguidInterfaces,
  221.     IN OUT  LPDWORD pcguidInterfaces);
  222. #ifdef UNICODE
  223. #define SCardListInterfaces  SCardListInterfacesW
  224. #else
  225. #define SCardListInterfaces  SCardListInterfacesA
  226. #endif // !UNICODE
  227.  
  228. extern WINSCARDAPI LONG WINAPI
  229. SCardGetProviderIdA(
  230.     IN      SCARDCONTEXT hContext,
  231.     IN      LPCSTR szCard,
  232.     OUT     LPGUID pguidProviderId);
  233. extern WINSCARDAPI LONG WINAPI
  234. SCardGetProviderIdW(
  235.     IN      SCARDCONTEXT hContext,
  236.     IN      LPCWSTR szCard,
  237.     OUT     LPGUID pguidProviderId);
  238. #ifdef UNICODE
  239. #define SCardGetProviderId  SCardGetProviderIdW
  240. #else
  241. #define SCardGetProviderId  SCardGetProviderIdA
  242. #endif // !UNICODE
  243. //
  244. // NOTE:    The routine SCardGetProviderId in this implementation uses GUIDs.
  245. //          The PC/SC definition uses BYTEs.
  246. //
  247.  
  248. extern WINSCARDAPI LONG WINAPI
  249. SCardGetCardTypeProviderNameA(
  250.     IN SCARDCONTEXT hContext,
  251.     IN LPCSTR szCardName,
  252.     IN DWORD dwProviderId,
  253.     OUT LPSTR szProvider,
  254.     IN OUT LPDWORD pcchProvider);
  255. extern WINSCARDAPI LONG WINAPI
  256. SCardGetCardTypeProviderNameW(
  257.     IN SCARDCONTEXT hContext,
  258.     IN LPCWSTR szCardName,
  259.     IN DWORD dwProviderId,
  260.     OUT LPWSTR szProvider,
  261.     IN OUT LPDWORD pcchProvider);
  262. #ifdef UNICODE
  263. #define SCardGetCardTypeProviderName  SCardGetCardTypeProviderNameW
  264. #else
  265. #define SCardGetCardTypeProviderName  SCardGetCardTypeProviderNameA
  266. #endif // !UNICODE
  267. //
  268. // NOTE:    This routine is an extension to the PC/SC definitions.
  269. //
  270.  
  271.  
  272. //
  273. // Database Writer routines
  274. //
  275.  
  276. extern WINSCARDAPI LONG WINAPI
  277. SCardIntroduceReaderGroupA(
  278.     IN SCARDCONTEXT hContext,
  279.     IN LPCSTR szGroupName);
  280. extern WINSCARDAPI LONG WINAPI
  281. SCardIntroduceReaderGroupW(
  282.     IN SCARDCONTEXT hContext,
  283.     IN LPCWSTR szGroupName);
  284. #ifdef UNICODE
  285. #define SCardIntroduceReaderGroup  SCardIntroduceReaderGroupW
  286. #else
  287. #define SCardIntroduceReaderGroup  SCardIntroduceReaderGroupA
  288. #endif // !UNICODE
  289.  
  290. extern WINSCARDAPI LONG WINAPI
  291. SCardForgetReaderGroupA(
  292.     IN SCARDCONTEXT hContext,
  293.     IN LPCSTR szGroupName);
  294. extern WINSCARDAPI LONG WINAPI
  295. SCardForgetReaderGroupW(
  296.     IN SCARDCONTEXT hContext,
  297.     IN LPCWSTR szGroupName);
  298. #ifdef UNICODE
  299. #define SCardForgetReaderGroup  SCardForgetReaderGroupW
  300. #else
  301. #define SCardForgetReaderGroup  SCardForgetReaderGroupA
  302. #endif // !UNICODE
  303.  
  304. extern WINSCARDAPI LONG WINAPI
  305. SCardIntroduceReaderA(
  306.     IN SCARDCONTEXT hContext,
  307.     IN LPCSTR szReaderName,
  308.     IN LPCSTR szDeviceName);
  309. extern WINSCARDAPI LONG WINAPI
  310. SCardIntroduceReaderW(
  311.     IN SCARDCONTEXT hContext,
  312.     IN LPCWSTR szReaderName,
  313.     IN LPCWSTR szDeviceName);
  314. #ifdef UNICODE
  315. #define SCardIntroduceReader  SCardIntroduceReaderW
  316. #else
  317. #define SCardIntroduceReader  SCardIntroduceReaderA
  318. #endif // !UNICODE
  319.  
  320. extern WINSCARDAPI LONG WINAPI
  321. SCardForgetReaderA(
  322.     IN SCARDCONTEXT hContext,
  323.     IN LPCSTR szReaderName);
  324. extern WINSCARDAPI LONG WINAPI
  325. SCardForgetReaderW(
  326.     IN SCARDCONTEXT hContext,
  327.     IN LPCWSTR szReaderName);
  328. #ifdef UNICODE
  329. #define SCardForgetReader  SCardForgetReaderW
  330. #else
  331. #define SCardForgetReader  SCardForgetReaderA
  332. #endif // !UNICODE
  333.  
  334. extern WINSCARDAPI LONG WINAPI
  335. SCardAddReaderToGroupA(
  336.     IN SCARDCONTEXT hContext,
  337.     IN LPCSTR szReaderName,
  338.     IN LPCSTR szGroupName);
  339. extern WINSCARDAPI LONG WINAPI
  340. SCardAddReaderToGroupW(
  341.     IN SCARDCONTEXT hContext,
  342.     IN LPCWSTR szReaderName,
  343.     IN LPCWSTR szGroupName);
  344. #ifdef UNICODE
  345. #define SCardAddReaderToGroup  SCardAddReaderToGroupW
  346. #else
  347. #define SCardAddReaderToGroup  SCardAddReaderToGroupA
  348. #endif // !UNICODE
  349.  
  350. extern WINSCARDAPI LONG WINAPI
  351. SCardRemoveReaderFromGroupA(
  352.     IN SCARDCONTEXT hContext,
  353.     IN LPCSTR szReaderName,
  354.     IN LPCSTR szGroupName);
  355. extern WINSCARDAPI LONG WINAPI
  356. SCardRemoveReaderFromGroupW(
  357.     IN SCARDCONTEXT hContext,
  358.     IN LPCWSTR szReaderName,
  359.     IN LPCWSTR szGroupName);
  360. #ifdef UNICODE
  361. #define SCardRemoveReaderFromGroup  SCardRemoveReaderFromGroupW
  362. #else
  363. #define SCardRemoveReaderFromGroup  SCardRemoveReaderFromGroupA
  364. #endif // !UNICODE
  365.  
  366. extern WINSCARDAPI LONG WINAPI
  367. SCardIntroduceCardTypeA(
  368.     IN SCARDCONTEXT hContext,
  369.     IN LPCSTR szCardName,
  370.     IN LPCGUID pguidPrimaryProvider,
  371.     IN LPCGUID rgguidInterfaces,
  372.     IN DWORD dwInterfaceCount,
  373.     IN LPCBYTE pbAtr,
  374.     IN LPCBYTE pbAtrMask,
  375.     IN DWORD cbAtrLen);
  376. extern WINSCARDAPI LONG WINAPI
  377. SCardIntroduceCardTypeW(
  378.     IN SCARDCONTEXT hContext,
  379.     IN LPCWSTR szCardName,
  380.     IN LPCGUID pguidPrimaryProvider,
  381.     IN LPCGUID rgguidInterfaces,
  382.     IN DWORD dwInterfaceCount,
  383.     IN LPCBYTE pbAtr,
  384.     IN LPCBYTE pbAtrMask,
  385.     IN DWORD cbAtrLen);
  386. #ifdef UNICODE
  387. #define SCardIntroduceCardType  SCardIntroduceCardTypeW
  388. #else
  389. #define SCardIntroduceCardType  SCardIntroduceCardTypeA
  390. #endif // !UNICODE
  391. //
  392. // NOTE:    The routine SCardIntroduceCardType's parameters' order differs from
  393. //          the PC/SC definition.  It should be:
  394. //
  395. //              extern WINSCARDAPI LONG WINAPI
  396. //              SCardIntroduceCardType(
  397. //                  IN SCARDCONTEXT hContext,
  398. //                  IN LPCTSTR szCardName,
  399. //                  IN LPCBYTE pbAtr,
  400. //                  IN LPCBYTE pbAtrMask,
  401. //                  IN DWORD cbAtrLen,
  402. //                  IN LPCGUID pguidPrimaryProvider,
  403. //                  IN LPCGUID rgguidInterfaces,
  404. //                  IN DWORD dwInterfaceCount);
  405. //
  406. //          Here's a work-around MACRO:
  407. #define PCSCardIntroduceCardType(hContext, szCardName, pbAtr, pbAtrMask, cbAtrLen, pguidPrimaryProvider, rgguidInterfaces, dwInterfaceCount) \
  408.           SCardIntroduceCardType(hContext, szCardName, pguidPrimaryProvider, rgguidInterfaces, dwInterfaceCount, pbAtr, pbAtrMask, cbAtrLen)
  409.  
  410. extern WINSCARDAPI LONG WINAPI
  411. SCardSetCardTypeProviderNameA(
  412.     IN SCARDCONTEXT hContext,
  413.     IN LPCSTR szCardName,
  414.     IN DWORD dwProviderId,
  415.     IN LPCSTR szProvider);
  416. extern WINSCARDAPI LONG WINAPI
  417. SCardSetCardTypeProviderNameW(
  418.     IN SCARDCONTEXT hContext,
  419.     IN LPCWSTR szCardName,
  420.     IN DWORD dwProviderId,
  421.     IN LPCWSTR szProvider);
  422. #ifdef UNICODE
  423. #define SCardSetCardTypeProviderName  SCardSetCardTypeProviderNameW
  424. #else
  425. #define SCardSetCardTypeProviderName  SCardSetCardTypeProviderNameA
  426. #endif // !UNICODE
  427. //
  428. // NOTE:    This routine is an extention to the PC/SC specifications.
  429. //
  430.  
  431. extern WINSCARDAPI LONG WINAPI
  432. SCardForgetCardTypeA(
  433.     IN SCARDCONTEXT hContext,
  434.     IN LPCSTR szCardName);
  435. extern WINSCARDAPI LONG WINAPI
  436. SCardForgetCardTypeW(
  437.     IN SCARDCONTEXT hContext,
  438.     IN LPCWSTR szCardName);
  439. #ifdef UNICODE
  440. #define SCardForgetCardType  SCardForgetCardTypeW
  441. #else
  442. #define SCardForgetCardType  SCardForgetCardTypeA
  443. #endif // !UNICODE
  444.  
  445.  
  446. //
  447. ////////////////////////////////////////////////////////////////////////////////
  448. //
  449. //  Service Manager Support Routines
  450. //
  451. //      The following services are supplied to simplify the use of the Service
  452. //      Manager API.
  453. //
  454.  
  455. extern WINSCARDAPI LONG WINAPI
  456. SCardFreeMemory(
  457.     IN SCARDCONTEXT hContext,
  458.     IN LPCVOID pvMem);
  459.  
  460.  
  461. //
  462. ////////////////////////////////////////////////////////////////////////////////
  463. //
  464. //  Reader Services
  465. //
  466. //      The following services supply means for tracking cards within readers.
  467. //
  468.  
  469. typedef struct {
  470.     LPCSTR      szReader;       // reader name
  471.     LPVOID      pvUserData;     // user defined data
  472.     DWORD       dwCurrentState; // current state of reader at time of call
  473.     DWORD       dwEventState;   // state of reader after state change
  474.     DWORD       cbAtr;          // Number of bytes in the returned ATR.
  475.     BYTE        rgbAtr[36];     // Atr of inserted card, (extra alignment bytes)
  476. } SCARD_READERSTATEA, *PSCARD_READERSTATEA, *LPSCARD_READERSTATEA;
  477. typedef struct {
  478.     LPCWSTR     szReader;       // reader name
  479.     LPVOID      pvUserData;     // user defined data
  480.     DWORD       dwCurrentState; // current state of reader at time of call
  481.     DWORD       dwEventState;   // state of reader after state change
  482.     DWORD       cbAtr;          // Number of bytes in the returned ATR.
  483.     BYTE        rgbAtr[36];     // Atr of inserted card, (extra alignment bytes)
  484. } SCARD_READERSTATEW, *PSCARD_READERSTATEW, *LPSCARD_READERSTATEW;
  485. #ifdef UNICODE
  486. typedef SCARD_READERSTATEW SCARD_READERSTATE;
  487. typedef PSCARD_READERSTATEW PSCARD_READERSTATE;
  488. typedef LPSCARD_READERSTATEW LPSCARD_READERSTATE;
  489. #else
  490. typedef SCARD_READERSTATEA SCARD_READERSTATE;
  491. typedef PSCARD_READERSTATEA PSCARD_READERSTATE;
  492. typedef LPSCARD_READERSTATEA LPSCARD_READERSTATE;
  493. #endif // UNICODE
  494.  
  495. // Backwards compatibility macros
  496. #define SCARD_READERSTATE_A SCARD_READERSTATEA
  497. #define SCARD_READERSTATE_W SCARD_READERSTATEW
  498. #define PSCARD_READERSTATE_A PSCARD_READERSTATEA
  499. #define PSCARD_READERSTATE_W PSCARD_READERSTATEW
  500. #define LPSCARD_READERSTATE_A LPSCARD_READERSTATEA
  501. #define LPSCARD_READERSTATE_W LPSCARD_READERSTATEW
  502.  
  503. #define SCARD_STATE_UNAWARE     0x00000000  // The application is unaware of the
  504.                                             // current state, and would like to
  505.                                             // know.  The use of this value
  506.                                             // results in an immediate return
  507.                                             // from state transition monitoring
  508.                                             // services.  This is represented by
  509.                                             // all bits set to zero.
  510. #define SCARD_STATE_IGNORE      0x00000001  // The application requested that
  511.                                             // this reader be ignored.  No other
  512.                                             // bits will be set.
  513. #define SCARD_STATE_CHANGED     0x00000002  // This implies that there is a
  514.                                             // difference between the state
  515.                                             // believed by the application, and
  516.                                             // the state known by the Service
  517.                                             // Manager.  When this bit is set,
  518.                                             // the application may assume a
  519.                                             // significant state change has
  520.                                             // occurred on this reader.
  521. #define SCARD_STATE_UNKNOWN     0x00000004  // This implies that the given
  522.                                             // reader name is not recognized by
  523.                                             // the Service Manager.  If this bit
  524.                                             // is set, then SCARD_STATE_CHANGED
  525.                                             // and SCARD_STATE_IGNORE will also
  526.                                             // be set.
  527. #define SCARD_STATE_UNAVAILABLE 0x00000008  // This implies that the actual
  528.                                             // state of this reader is not
  529.                                             // available.  If this bit is set,
  530.                                             // then all the following bits are
  531.                                             // clear.
  532. #define SCARD_STATE_EMPTY       0x00000010  // This implies that there is not
  533.                                             // card in the reader.  If this bit
  534.                                             // is set, all the following bits
  535.                                             // will be clear.
  536. #define SCARD_STATE_PRESENT     0x00000020  // This implies that there is a card
  537.                                             // in the reader.
  538. #define SCARD_STATE_ATRMATCH    0x00000040  // This implies that there is a card
  539.                                             // in the reader with an ATR
  540.                                             // matching one of the target cards.
  541.                                             // If this bit is set,
  542.                                             // SCARD_STATE_PRESENT will also be
  543.                                             // set.  This bit is only returned
  544.                                             // on the SCardLocateCard() service.
  545. #define SCARD_STATE_EXCLUSIVE   0x00000080  // This implies that the card in the
  546.                                             // reader is allocated for exclusive
  547.                                             // use by another application.  If
  548.                                             // this bit is set,
  549.                                             // SCARD_STATE_PRESENT will also be
  550.                                             // set.
  551. #define SCARD_STATE_INUSE       0x00000100  // This implies that the card in the
  552.                                             // reader is in use by one or more
  553.                                             // other applications, but may be
  554.                                             // connected to in shared mode.  If
  555.                                             // this bit is set,
  556.                                             // SCARD_STATE_PRESENT will also be
  557.                                             // set.
  558. #define SCARD_STATE_MUTE        0x00000200  // This implies that the card in the
  559.                                             // reader is unresponsive or not
  560.                                             // supported by the reader or
  561.                                             // software.
  562. #define SCARD_STATE_UNPOWERED   0x00000400  // This implies that the card in the
  563.                                             // reader has not been powered up.
  564.  
  565. extern WINSCARDAPI LONG WINAPI
  566. SCardLocateCardsA(
  567.     IN      SCARDCONTEXT hContext,
  568.     IN      LPCSTR mszCards,
  569.     IN OUT  LPSCARD_READERSTATEA rgReaderStates,
  570.     IN      DWORD cReaders);
  571. extern WINSCARDAPI LONG WINAPI
  572. SCardLocateCardsW(
  573.     IN      SCARDCONTEXT hContext,
  574.     IN      LPCWSTR mszCards,
  575.     IN OUT  LPSCARD_READERSTATEW rgReaderStates,
  576.     IN      DWORD cReaders);
  577. #ifdef UNICODE
  578. #define SCardLocateCards  SCardLocateCardsW
  579. #else
  580. #define SCardLocateCards  SCardLocateCardsA
  581. #endif // !UNICODE
  582.  
  583. extern WINSCARDAPI LONG WINAPI
  584. SCardGetStatusChangeA(
  585.     IN      SCARDCONTEXT hContext,
  586.     IN      DWORD dwTimeout,
  587.     IN OUT  LPSCARD_READERSTATEA rgReaderStates,
  588.     IN      DWORD cReaders);
  589. extern WINSCARDAPI LONG WINAPI
  590. SCardGetStatusChangeW(
  591.     IN      SCARDCONTEXT hContext,
  592.     IN      DWORD dwTimeout,
  593.     IN OUT  LPSCARD_READERSTATEW rgReaderStates,
  594.     IN      DWORD cReaders);
  595. #ifdef UNICODE
  596. #define SCardGetStatusChange  SCardGetStatusChangeW
  597. #else
  598. #define SCardGetStatusChange  SCardGetStatusChangeA
  599. #endif // !UNICODE
  600.  
  601. extern WINSCARDAPI LONG WINAPI
  602. SCardCancel(
  603.     IN      SCARDCONTEXT hContext);
  604.  
  605.  
  606. //
  607. ////////////////////////////////////////////////////////////////////////////////
  608. //
  609. //  Card/Reader Communication Services
  610. //
  611. //      The following services provide means for communication with the card.
  612. //
  613.  
  614. #define SCARD_SHARE_EXCLUSIVE 1 // This application is not willing to share this
  615.                                 // card with other applications.
  616. #define SCARD_SHARE_SHARED    2 // This application is willing to share this
  617.                                 // card with other applications.
  618. #define SCARD_SHARE_DIRECT    3 // This application demands direct control of
  619.                                 // the reader, so it is not available to other
  620.                                 // applications.
  621.  
  622. #define SCARD_LEAVE_CARD      0 // Don't do anything special on close
  623. #define SCARD_RESET_CARD      1 // Reset the card on close
  624. #define SCARD_UNPOWER_CARD    2 // Power down the card on close
  625. #define SCARD_EJECT_CARD      3 // Eject the card on close
  626.  
  627. extern WINSCARDAPI LONG WINAPI
  628. SCardConnectA(
  629.     IN      SCARDCONTEXT hContext,
  630.     IN      LPCSTR szReader,
  631.     IN      DWORD dwShareMode,
  632.     IN      DWORD dwPreferredProtocols,
  633.     OUT     LPSCARDHANDLE phCard,
  634.     OUT     LPDWORD pdwActiveProtocol);
  635. extern WINSCARDAPI LONG WINAPI
  636. SCardConnectW(
  637.     IN      SCARDCONTEXT hContext,
  638.     IN      LPCWSTR szReader,
  639.     IN      DWORD dwShareMode,
  640.     IN      DWORD dwPreferredProtocols,
  641.     OUT     LPSCARDHANDLE phCard,
  642.     OUT     LPDWORD pdwActiveProtocol);
  643. #ifdef UNICODE
  644. #define SCardConnect  SCardConnectW
  645. #else
  646. #define SCardConnect  SCardConnectA
  647. #endif // !UNICODE
  648.  
  649. extern WINSCARDAPI LONG WINAPI
  650. SCardReconnect(
  651.     IN      SCARDHANDLE hCard,
  652.     IN      DWORD dwShareMode,
  653.     IN      DWORD dwPreferredProtocols,
  654.     IN      DWORD dwInitialization,
  655.     OUT     LPDWORD pdwActiveProtocol);
  656.  
  657. extern WINSCARDAPI LONG WINAPI
  658. SCardDisconnect(
  659.     IN      SCARDHANDLE hCard,
  660.     IN      DWORD dwDisposition);
  661.  
  662. extern WINSCARDAPI LONG WINAPI
  663. SCardBeginTransaction(
  664.     IN      SCARDHANDLE hCard);
  665.  
  666. extern WINSCARDAPI LONG WINAPI
  667. SCardEndTransaction(
  668.     IN      SCARDHANDLE hCard,
  669.     IN      DWORD dwDisposition);
  670.  
  671. extern WINSCARDAPI LONG WINAPI
  672. SCardCancelTransaction(
  673.     IN      SCARDHANDLE hCard);
  674. //
  675. // NOTE:    This call corresponds to the PC/SC SCARDCOMM::Cancel routine,
  676. //          terminating a blocked SCardBeginTransaction service.
  677. //
  678.  
  679.  
  680. extern WINSCARDAPI LONG WINAPI
  681. SCardState(
  682.     IN SCARDHANDLE hCard,
  683.     OUT LPDWORD pdwState,
  684.     OUT LPDWORD pdwProtocol,
  685.     OUT LPBYTE pbAtr,
  686.     IN OUT LPDWORD pcbAtrLen);
  687. //
  688. // NOTE:    SCardState is an obsolete routine.  PC/SC has replaced it with
  689. //          SCardStatus.
  690. //
  691.  
  692. extern WINSCARDAPI LONG WINAPI
  693. SCardStatusA(
  694.     IN SCARDHANDLE hCard,
  695.     OUT LPSTR szReaderName,
  696.     IN OUT LPDWORD pcchReaderLen,
  697.     OUT LPDWORD pdwState,
  698.     OUT LPDWORD pdwProtocol,
  699.     OUT LPBYTE pbAtr,
  700.     IN OUT LPDWORD pcbAtrLen);
  701. extern WINSCARDAPI LONG WINAPI
  702. SCardStatusW(
  703.     IN SCARDHANDLE hCard,
  704.     OUT LPWSTR szReaderName,
  705.     IN OUT LPDWORD pcchReaderLen,
  706.     OUT LPDWORD pdwState,
  707.     OUT LPDWORD pdwProtocol,
  708.     OUT LPBYTE pbAtr,
  709.     IN OUT LPDWORD pcbAtrLen);
  710. #ifdef UNICODE
  711. #define SCardStatus  SCardStatusW
  712. #else
  713. #define SCardStatus  SCardStatusA
  714. #endif // !UNICODE
  715.  
  716. extern WINSCARDAPI LONG WINAPI
  717. SCardTransmit(
  718.     IN SCARDHANDLE hCard,
  719.     IN LPCSCARD_IO_REQUEST pioSendPci,
  720.     IN LPCBYTE pbSendBuffer,
  721.     IN DWORD cbSendLength,
  722.     IN OUT LPSCARD_IO_REQUEST pioRecvPci,
  723.     OUT LPBYTE pbRecvBuffer,
  724.     IN OUT LPDWORD pcbRecvLength);
  725.  
  726.  
  727. //
  728. ////////////////////////////////////////////////////////////////////////////////
  729. //
  730. //  Reader Control Routines
  731. //
  732. //      The following services provide for direct, low-level manipulation of the
  733. //      reader by the calling application allowing it control over the
  734. //      attributes of the communications with the card.
  735. //
  736.  
  737. extern WINSCARDAPI LONG WINAPI
  738. SCardControl(
  739.     IN      SCARDHANDLE hCard,
  740.     IN      DWORD dwControlCode,
  741.     IN      LPCVOID lpInBuffer,
  742.     IN      DWORD nInBufferSize,
  743.     OUT     LPVOID lpOutBuffer,
  744.     IN      DWORD nOutBufferSize,
  745.     OUT     LPDWORD lpBytesReturned);
  746.  
  747. extern WINSCARDAPI LONG WINAPI
  748. SCardGetAttrib(
  749.     IN SCARDHANDLE hCard,
  750.     IN DWORD dwAttrId,
  751.     OUT LPBYTE pbAttr,
  752.     IN OUT LPDWORD pcbAttrLen);
  753. //
  754. // NOTE:    The routine SCardGetAttrib's name differs from the PC/SC definition.
  755. //          It should be:
  756. //
  757. //              extern WINSCARDAPI LONG WINAPI
  758. //              SCardGetReaderCapabilities(
  759. //                  IN SCARDHANDLE hCard,
  760. //                  IN DWORD dwTag,
  761. //                  OUT LPBYTE pbAttr,
  762. //                  IN OUT LPDWORD pcbAttrLen);
  763. //
  764. //          Here's a work-around MACRO:
  765. #define SCardGetReaderCapabilities SCardGetAttrib
  766.  
  767. extern WINSCARDAPI LONG WINAPI
  768. SCardSetAttrib(
  769.     IN SCARDHANDLE hCard,
  770.     IN DWORD dwAttrId,
  771.     IN LPCBYTE pbAttr,
  772.     IN DWORD cbAttrLen);
  773. //
  774. // NOTE:    The routine SCardSetAttrib's name differs from the PC/SC definition.
  775. //          It should be:
  776. //
  777. //              extern WINSCARDAPI LONG WINAPI
  778. //              SCardSetReaderCapabilities(
  779. //                  IN SCARDHANDLE hCard,
  780. //                  IN DWORD dwTag,
  781. //                  OUT LPBYTE pbAttr,
  782. //                  IN OUT LPDWORD pcbAttrLen);
  783. //
  784. //          Here's a work-around MACRO:
  785. #define SCardSetReaderCapabilities SCardSetAttrib
  786.  
  787.  
  788. //
  789. ////////////////////////////////////////////////////////////////////////////////
  790. //
  791. //  Smart Card Dialog definitions
  792. //
  793. //      The following section contains structures and  exported function
  794. //      declarations for the Smart Card Common Dialog dialog.
  795. //
  796.  
  797. // Defined constants
  798. // Flags
  799. #define SC_DLG_MINIMAL_UI       0x01
  800. #define SC_DLG_NO_UI            0x02
  801. #define SC_DLG_FORCE_UI         0x04
  802.  
  803. #define SCERR_NOCARDNAME        0x4000
  804. #define SCERR_NOGUIDS           0x8000
  805.  
  806. typedef SCARDHANDLE (WINAPI *LPOCNCONNPROCA) (IN SCARDCONTEXT, IN LPSTR, IN LPSTR, IN PVOID);
  807. typedef SCARDHANDLE (WINAPI *LPOCNCONNPROCW) (IN SCARDCONTEXT, IN LPWSTR, IN LPWSTR, IN PVOID);
  808. #ifdef UNICODE
  809. #define LPOCNCONNPROC  LPOCNCONNPROCW
  810. #else
  811. #define LPOCNCONNPROC  LPOCNCONNPROCA
  812. #endif // !UNICODE
  813. typedef BOOL (WINAPI *LPOCNCHKPROC) (IN SCARDCONTEXT, IN SCARDHANDLE, IN PVOID);
  814. typedef void (WINAPI *LPOCNDSCPROC) (IN SCARDCONTEXT, IN SCARDHANDLE, IN PVOID);
  815.  
  816.  
  817. //
  818. // OPENCARD_SEARCH_CRITERIA: In order to specify a user-extended search,
  819. // lpfnCheck must not be NULL.  Moreover, the connection to be made to the
  820. // card before performing the callback must be indicated by either providing
  821. // lpfnConnect and lpfnDisconnect OR by setting dwShareMode.
  822. // If both the connection callbacks and dwShareMode are non-NULL, the callbacks
  823. // will be used.
  824. //
  825.  
  826. typedef struct {
  827.     DWORD           dwStructSize;
  828.     LPSTR           lpstrGroupNames;        // OPTIONAL reader groups to include in
  829.     DWORD           nMaxGroupNames;         //          search.  NULL defaults to
  830.                                             //          SCard$DefaultReaders
  831.     LPCGUID         rgguidInterfaces;       // OPTIONAL requested interfaces
  832.     DWORD           cguidInterfaces;        //          supported by card's SSP
  833.     LPSTR           lpstrCardNames;         // OPTIONAL requested card names; all cards w/
  834.     DWORD           nMaxCardNames;          //          matching ATRs will be accepted
  835.     LPOCNCHKPROC    lpfnCheck;              // OPTIONAL if NULL no user check will be performed.
  836.     LPOCNCONNPROCA  lpfnConnect;            // OPTIONAL if lpfnConnect is provided,
  837.     LPOCNDSCPROC    lpfnDisconnect;         //          lpfnDisconnect must also be set.
  838.     LPVOID          pvUserData;             // OPTIONAL parameter to callbacks
  839.     DWORD           dwShareMode;            // OPTIONAL must be set if lpfnCheck is not null
  840.     DWORD           dwPreferredProtocols;   // OPTIONAL
  841. } OPENCARD_SEARCH_CRITERIAA, *POPENCARD_SEARCH_CRITERIAA, *LPOPENCARD_SEARCH_CRITERIAA;
  842. typedef struct {
  843.     DWORD           dwStructSize;
  844.     LPWSTR          lpstrGroupNames;        // OPTIONAL reader groups to include in
  845.     DWORD           nMaxGroupNames;         //          search.  NULL defaults to
  846.                                             //          SCard$DefaultReaders
  847.     LPCGUID         rgguidInterfaces;       // OPTIONAL requested interfaces
  848.     DWORD           cguidInterfaces;        //          supported by card's SSP
  849.     LPWSTR          lpstrCardNames;         // OPTIONAL requested card names; all cards w/
  850.     DWORD           nMaxCardNames;          //          matching ATRs will be accepted
  851.     LPOCNCHKPROC    lpfnCheck;              // OPTIONAL if NULL no user check will be performed.
  852.     LPOCNCONNPROCW  lpfnConnect;            // OPTIONAL if lpfnConnect is provided,
  853.     LPOCNDSCPROC    lpfnDisconnect;         //          lpfnDisconnect must also be set.
  854.     LPVOID          pvUserData;             // OPTIONAL parameter to callbacks
  855.     DWORD           dwShareMode;            // OPTIONAL must be set if lpfnCheck is not null
  856.     DWORD           dwPreferredProtocols;   // OPTIONAL
  857. } OPENCARD_SEARCH_CRITERIAW, *POPENCARD_SEARCH_CRITERIAW, *LPOPENCARD_SEARCH_CRITERIAW;
  858. #ifdef UNICODE
  859. typedef OPENCARD_SEARCH_CRITERIAW OPENCARD_SEARCH_CRITERIA;
  860. typedef POPENCARD_SEARCH_CRITERIAW POPENCARD_SEARCH_CRITERIA;
  861. typedef LPOPENCARD_SEARCH_CRITERIAW LPOPENCARD_SEARCH_CRITERIA;
  862. #else
  863. typedef OPENCARD_SEARCH_CRITERIAA OPENCARD_SEARCH_CRITERIA;
  864. typedef POPENCARD_SEARCH_CRITERIAA POPENCARD_SEARCH_CRITERIA;
  865. typedef LPOPENCARD_SEARCH_CRITERIAA LPOPENCARD_SEARCH_CRITERIA;
  866. #endif // UNICODE
  867.  
  868.  
  869. //
  870. // OPENCARDNAME_EX: used by SCardUIDlgSelectCard; replaces obsolete OPENCARDNAME
  871. //
  872.  
  873. typedef struct {
  874.     DWORD           dwStructSize;           // REQUIRED
  875.     SCARDCONTEXT    hSCardContext;          // REQUIRED
  876.     HWND            hwndOwner;              // OPTIONAL
  877.     DWORD           dwFlags;                // OPTIONAL -- default is SC_DLG_MINIMAL_UI
  878.     LPCSTR          lpstrTitle;             // OPTIONAL
  879.     LPCSTR          lpstrSearchDesc;        // OPTIONAL (eg. "Please insert your <brandname> smart card.")
  880.     HICON           hIcon;                  // OPTIONAL 32x32 icon for your brand insignia
  881.     POPENCARD_SEARCH_CRITERIAA pOpenCardSearchCriteria; // OPTIONAL
  882.     LPOCNCONNPROCA  lpfnConnect;            // OPTIONAL - performed on successful selection
  883.     LPVOID          pvUserData;             // OPTIONAL parameter to lpfnConnect
  884.     DWORD           dwShareMode;            // OPTIONAL - if lpfnConnect is NULL, dwShareMode and
  885.     DWORD           dwPreferredProtocols;   // OPTIONAL dwPreferredProtocols will be used to
  886.                                             //          connect to the selected card
  887.     LPSTR           lpstrRdr;               // REQUIRED [IN|OUT] Name of selected reader
  888.     DWORD           nMaxRdr;                // REQUIRED [IN|OUT]
  889.     LPSTR           lpstrCard;              // REQUIRED [IN|OUT] Name of selected card
  890.     DWORD           nMaxCard;               // REQUIRED [IN|OUT]
  891.     DWORD           dwActiveProtocol;       // [OUT] set only if dwShareMode not NULL
  892.     SCARDHANDLE     hCardHandle;            // [OUT] set if a card connection was indicated
  893. } OPENCARDNAME_EXA, *POPENCARDNAME_EXA, *LPOPENCARDNAME_EXA;
  894. typedef struct {
  895.     DWORD           dwStructSize;           // REQUIRED
  896.     SCARDCONTEXT    hSCardContext;          // REQUIRED
  897.     HWND            hwndOwner;              // OPTIONAL
  898.     DWORD           dwFlags;                // OPTIONAL -- default is SC_DLG_MINIMAL_UI
  899.     LPCWSTR         lpstrTitle;             // OPTIONAL
  900.     LPCWSTR         lpstrSearchDesc;        // OPTIONAL (eg. "Please insert your <brandname> smart card.")
  901.     HICON           hIcon;                  // OPTIONAL 32x32 icon for your brand insignia
  902.     POPENCARD_SEARCH_CRITERIAW pOpenCardSearchCriteria; // OPTIONAL
  903.     LPOCNCONNPROCW  lpfnConnect;            // OPTIONAL - performed on successful selection
  904.     LPVOID          pvUserData;             // OPTIONAL parameter to lpfnConnect
  905.     DWORD           dwShareMode;            // OPTIONAL - if lpfnConnect is NULL, dwShareMode and
  906.     DWORD           dwPreferredProtocols;   // OPTIONAL dwPreferredProtocols will be used to
  907.                                             //          connect to the selected card
  908.     LPWSTR          lpstrRdr;               // REQUIRED [IN|OUT] Name of selected reader
  909.     DWORD           nMaxRdr;                // REQUIRED [IN|OUT]
  910.     LPWSTR          lpstrCard;              // REQUIRED [IN|OUT] Name of selected card
  911.     DWORD           nMaxCard;               // REQUIRED [IN|OUT]
  912.     DWORD           dwActiveProtocol;       // [OUT] set only if dwShareMode not NULL
  913.     SCARDHANDLE     hCardHandle;            // [OUT] set if a card connection was indicated
  914. } OPENCARDNAME_EXW, *POPENCARDNAME_EXW, *LPOPENCARDNAME_EXW;
  915. #ifdef UNICODE
  916. typedef OPENCARDNAME_EXW OPENCARDNAME_EX;
  917. typedef POPENCARDNAME_EXW POPENCARDNAME_EX;
  918. typedef LPOPENCARDNAME_EXW LPOPENCARDNAME_EX;
  919. #else
  920. typedef OPENCARDNAME_EXA OPENCARDNAME_EX;
  921. typedef POPENCARDNAME_EXA POPENCARDNAME_EX;
  922. typedef LPOPENCARDNAME_EXA LPOPENCARDNAME_EX;
  923. #endif // UNICODE
  924.  
  925. #define OPENCARDNAMEA_EX OPENCARDNAME_EXA
  926. #define OPENCARDNAMEW_EX OPENCARDNAME_EXW
  927. #define POPENCARDNAMEA_EX POPENCARDNAME_EXA
  928. #define POPENCARDNAMEW_EX POPENCARDNAME_EXW
  929. #define LPOPENCARDNAMEA_EX LPOPENCARDNAME_EXA
  930. #define LPOPENCARDNAMEW_EX LPOPENCARDNAME_EXW
  931.  
  932.  
  933. //
  934. // SCardUIDlgSelectCard replaces GetOpenCardName
  935. //
  936.  
  937. extern WINSCARDAPI LONG WINAPI
  938. SCardUIDlgSelectCardA(
  939.     LPOPENCARDNAMEA_EX);
  940. extern WINSCARDAPI LONG WINAPI
  941. SCardUIDlgSelectCardW(
  942.     LPOPENCARDNAMEW_EX);
  943. #ifdef UNICODE
  944. #define SCardUIDlgSelectCard  SCardUIDlgSelectCardW
  945. #else
  946. #define SCardUIDlgSelectCard  SCardUIDlgSelectCardA
  947. #endif // !UNICODE
  948.  
  949.  
  950. //
  951. // "Smart Card Common Dialog" definitions for backwards compatibility
  952. //  with the Smart Card Base Services SDK version 1.0
  953. //
  954.  
  955. typedef struct {
  956.     DWORD           dwStructSize;
  957.     HWND            hwndOwner;
  958.     SCARDCONTEXT    hSCardContext;
  959.     LPSTR           lpstrGroupNames;
  960.     DWORD           nMaxGroupNames;
  961.     LPSTR           lpstrCardNames;
  962.     DWORD           nMaxCardNames;
  963.     LPCGUID         rgguidInterfaces;
  964.     DWORD           cguidInterfaces;
  965.     LPSTR           lpstrRdr;
  966.     DWORD           nMaxRdr;
  967.     LPSTR           lpstrCard;
  968.     DWORD           nMaxCard;
  969.     LPCSTR          lpstrTitle;
  970.     DWORD           dwFlags;
  971.     LPVOID          pvUserData;
  972.     DWORD           dwShareMode;
  973.     DWORD           dwPreferredProtocols;
  974.     DWORD           dwActiveProtocol;
  975.     LPOCNCONNPROCA  lpfnConnect;
  976.     LPOCNCHKPROC    lpfnCheck;
  977.     LPOCNDSCPROC    lpfnDisconnect;
  978.     SCARDHANDLE     hCardHandle;
  979. } OPENCARDNAMEA, *POPENCARDNAMEA, *LPOPENCARDNAMEA;
  980. typedef struct {
  981.     DWORD           dwStructSize;
  982.     HWND            hwndOwner;
  983.     SCARDCONTEXT    hSCardContext;
  984.     LPWSTR          lpstrGroupNames;
  985.     DWORD           nMaxGroupNames;
  986.     LPWSTR          lpstrCardNames;
  987.     DWORD           nMaxCardNames;
  988.     LPCGUID         rgguidInterfaces;
  989.     DWORD           cguidInterfaces;
  990.     LPWSTR          lpstrRdr;
  991.     DWORD           nMaxRdr;
  992.     LPWSTR          lpstrCard;
  993.     DWORD           nMaxCard;
  994.     LPCWSTR         lpstrTitle;
  995.     DWORD           dwFlags;
  996.     LPVOID          pvUserData;
  997.     DWORD           dwShareMode;
  998.     DWORD           dwPreferredProtocols;
  999.     DWORD           dwActiveProtocol;
  1000.     LPOCNCONNPROCW  lpfnConnect;
  1001.     LPOCNCHKPROC    lpfnCheck;
  1002.     LPOCNDSCPROC    lpfnDisconnect;
  1003.     SCARDHANDLE     hCardHandle;
  1004. } OPENCARDNAMEW, *POPENCARDNAMEW, *LPOPENCARDNAMEW;
  1005. #ifdef UNICODE
  1006. typedef OPENCARDNAMEW OPENCARDNAME;
  1007. typedef POPENCARDNAMEW POPENCARDNAME;
  1008. typedef LPOPENCARDNAMEW LPOPENCARDNAME;
  1009. #else
  1010. typedef OPENCARDNAMEA OPENCARDNAME;
  1011. typedef POPENCARDNAMEA POPENCARDNAME;
  1012. typedef LPOPENCARDNAMEA LPOPENCARDNAME;
  1013. #endif // UNICODE
  1014.  
  1015. // Backwards compatibility macros
  1016. #define OPENCARDNAME_A OPENCARDNAMEA
  1017. #define OPENCARDNAME_W OPENCARDNAMEW
  1018. #define POPENCARDNAME_A POPENCARDNAMEA
  1019. #define POPENCARDNAME_W POPENCARDNAMEW
  1020. #define LPOPENCARDNAME_A LPOPENCARDNAMEA
  1021. #define LPOPENCARDNAME_W LPOPENCARDNAMEW
  1022.  
  1023. extern WINSCARDAPI LONG WINAPI
  1024. GetOpenCardNameA(
  1025.     LPOPENCARDNAMEA);
  1026. extern WINSCARDAPI LONG WINAPI
  1027. GetOpenCardNameW(
  1028.     LPOPENCARDNAMEW);
  1029. #ifdef UNICODE
  1030. #define GetOpenCardName  GetOpenCardNameW
  1031. #else
  1032. #define GetOpenCardName  GetOpenCardNameA
  1033. #endif // !UNICODE
  1034.  
  1035. extern WINSCARDAPI LONG WINAPI
  1036. SCardDlgExtendedError (void);
  1037.  
  1038. #ifdef __cplusplus
  1039. }
  1040. #endif
  1041. #pragma option pop /*P_O_Pop*/
  1042. #endif // _WINSCARD_H_
  1043.  
  1044.