pcsc-lite  1.8.8
readerfactory.h
Go to the documentation of this file.
1 /*
2  * MUSCLE SmartCard Development ( http://www.linuxnet.com )
3  *
4  * Copyright (C) 1999
5  * David Corcoran <corcoran@linuxnet.com>
6  * Copyright (C) 2002-2011
7  * Ludovic Rousseau <ludovic.rousseau@free.fr>
8  *
9  * $Id: readerfactory.h 6458 2012-09-13 15:35:12Z rousseau $
10  */
11 
17 #ifndef __readerfactory_h__
18 #define __readerfactory_h__
19 
20 #include <inttypes.h>
21 #include <pthread.h>
22 
23 #include "ifdhandler.h"
24 #include "pcscd.h"
25 #include "simclist.h"
26 
27  typedef struct
28  {
30  char *pcDevicename;
31  char *pcLibpath;
32  int channelId;
33  } SerialReader;
34 
35  struct FctMap_V2
36  {
37  /* shared with API 3.0 */
38  RESPONSECODE (*pvfCreateChannel)(DWORD, DWORD);
39  RESPONSECODE (*pvfCloseChannel)(DWORD);
40  RESPONSECODE (*pvfGetCapabilities)(DWORD, DWORD, PDWORD, PUCHAR);
41  RESPONSECODE (*pvfSetCapabilities)(DWORD, DWORD, DWORD, PUCHAR);
42  RESPONSECODE (*pvfSetProtocolParameters)(DWORD, DWORD, UCHAR, UCHAR,
43  UCHAR, UCHAR);
44  RESPONSECODE (*pvfPowerICC)(DWORD, DWORD, PUCHAR, PDWORD);
45  RESPONSECODE (*pvfTransmitToICC)(DWORD, SCARD_IO_HEADER, PUCHAR,
46  DWORD, PUCHAR, PDWORD, PSCARD_IO_HEADER);
47  RESPONSECODE (*pvfICCPresence)(DWORD);
48 
49  /* API v2.0 only */
50  RESPONSECODE (*pvfControl)(DWORD, PUCHAR, DWORD, PUCHAR, PDWORD);
51  };
52 
53  typedef struct FctMap_V2 FCT_MAP_V2;
54 
55  struct FctMap_V3
56  {
57  /* the common fields SHALL be in the same order as in FctMap_V2 */
58  RESPONSECODE (*pvfCreateChannel)(DWORD, DWORD);
59  RESPONSECODE (*pvfCloseChannel)(DWORD);
60  RESPONSECODE (*pvfGetCapabilities)(DWORD, DWORD, PDWORD, PUCHAR);
61  RESPONSECODE (*pvfSetCapabilities)(DWORD, DWORD, DWORD, PUCHAR);
62  RESPONSECODE (*pvfSetProtocolParameters)(DWORD, DWORD, UCHAR, UCHAR,
63  UCHAR, UCHAR);
64  RESPONSECODE (*pvfPowerICC)(DWORD, DWORD, PUCHAR, PDWORD);
65  RESPONSECODE (*pvfTransmitToICC)(DWORD, SCARD_IO_HEADER, PUCHAR,
66  DWORD, PUCHAR, PDWORD, PSCARD_IO_HEADER);
67  RESPONSECODE (*pvfICCPresence)(DWORD);
68 
69  /* API V3.0 only */
70  RESPONSECODE (*pvfControl)(DWORD, DWORD, LPCVOID, DWORD, LPVOID,
71  DWORD, LPDWORD);
72  RESPONSECODE (*pvfCreateChannelByName)(DWORD, LPSTR);
73  };
74 
75  typedef struct FctMap_V3 FCT_MAP_V3;
76 
78  {
80  DWORD dwEventStatus;
81  };
82 
83  typedef struct RdrCliHandles RDR_CLIHANDLES;
84 
86  {
87  char *library;
88  char *device;
89  pthread_t pthThread;
90  RESPONSECODE (*pthCardEvent)(DWORD, int);
91  pthread_mutex_t *mMutex;
92  list_t handlesList;
93  pthread_mutex_t handlesList_lock;
95  union
96  {
99  } psFunctions;
101  LPVOID vHandle;
102  int version;
103  int port;
104  int slot;
105  volatile SCARDHANDLE hLockId;
106  int LockCount;
107  int32_t contexts;
108  int * pFeeds;
109  int * pMutex;
111  pthread_mutex_t powerState_lock;
112  int reference;
113  pthread_mutex_t reference_lock;
116  /* we can't use READER_STATE * here since eventhandler.h can't be
117  * included because of circular dependencies */
118  };
119 
120  typedef struct ReaderContext READER_CONTEXT;
121 
122  LONG _RefReader(READER_CONTEXT * sReader);
123  LONG _UnrefReader(READER_CONTEXT * sReader);
124 
125 #define REF_READER(reader) { LONG rv; Log2(PCSC_LOG_DEBUG, "RefReader() count was: %d", reader->reference); rv = _RefReader(reader); if (rv != SCARD_S_SUCCESS) return rv; }
126 #define UNREF_READER(reader) {Log2(PCSC_LOG_DEBUG, "UnrefReader() count was: %d", reader->reference); _UnrefReader(reader);}
127 
128  LONG RFAllocateReaderSpace(unsigned int);
129  LONG RFAddReader(const char *, int, const char *, const char *);
130  LONG RFRemoveReader(const char *, int);
131  LONG RFSetReaderName(READER_CONTEXT *, const char *, const char *, int);
132  LONG RFReaderInfo(const char *, /*@out@*/ struct ReaderContext **);
133  LONG RFReaderInfoById(SCARDHANDLE, /*@out@*/ struct ReaderContext **);
134  LONG RFCheckSharing(SCARDHANDLE, READER_CONTEXT *);
135  LONG RFLockSharing(SCARDHANDLE, READER_CONTEXT *);
136  LONG RFUnlockSharing(SCARDHANDLE, READER_CONTEXT *);
137  LONG RFUnlockAllSharing(SCARDHANDLE, READER_CONTEXT *);
138  LONG RFLoadReader(READER_CONTEXT *);
139  LONG RFBindFunctions(READER_CONTEXT *);
140  LONG RFUnBindFunctions(READER_CONTEXT *);
141  LONG RFUnloadReader(READER_CONTEXT *);
142  LONG RFInitializeReader(READER_CONTEXT *);
143  LONG RFUnInitializeReader(READER_CONTEXT *);
144  SCARDHANDLE RFCreateReaderHandle(READER_CONTEXT *);
145  LONG RFDestroyReaderHandle(SCARDHANDLE hCard);
146  LONG RFAddReaderHandle(READER_CONTEXT *, SCARDHANDLE);
147  LONG RFRemoveReaderHandle(READER_CONTEXT *, SCARDHANDLE);
148  LONG RFSetReaderEventState(READER_CONTEXT *, DWORD);
149  LONG RFCheckReaderEventState(READER_CONTEXT *, SCARDHANDLE);
150  LONG RFClearReaderEventState(READER_CONTEXT *, SCARDHANDLE);
151  LONG RFCheckReaderStatus(READER_CONTEXT *);
152  void RFCleanupReaders(void);
153  void RFWaitForReaderInit(void);
154  int RFStartSerialReaders(const char *readerconf);
155  void RFReCheckReaderConf(void);
156 
157 #endif
struct pubReaderStatesList * readerState
link to the reader state
list object
Definition: simclist.h:181
int32_t contexts
Number of open contexts.
volatile SCARDHANDLE hLockId
Lock Id.
int port
Port ID.
pthread_t pthThread
Event polling thread.
Definition: readerfactory.h:89
FCT_MAP_V2 psFunctions_v2
API V2.0.
Definition: readerfactory.h:97
RESPONSECODE(* pthCardEvent)(DWORD, int)
Card Event sync.
Definition: readerfactory.h:90
DWORD dwEventStatus
Recent event that must be sent.
Definition: readerfactory.h:80
int slot
Current Reader Slot.
union ReaderContext::@3 psFunctions
driver functions
int * pMutex
Number of client to mutex.
pthread_mutex_t handlesList_lock
lock for the above list
Definition: readerfactory.h:93
struct _SCARD_IO_HEADER SCARD_IO_HEADER
Use by SCardTransmit()
char * library
Library Path.
Definition: readerfactory.h:87
char * pcLibpath
LIBPATH.
Definition: readerfactory.h:31
FCT_MAP_V3 psFunctions_v3
API V3.0.
Definition: readerfactory.h:98
int * pFeeds
Number of shared client to lib.
int version
IFD Handler version number.
pthread_mutex_t * mMutex
Mutex for this connection.
Definition: readerfactory.h:91
int powerState
auto power off state
LONG SCARDHANDLE
hCard returned by SCardConnect()
Definition: pcsclite.h:34
int LockCount
number of recursive locks
LPVOID vHandle
Dlopen handle.
This keeps a list of defines for pcsc-lite.
pthread_mutex_t reference_lock
reference mutex
Define an exported public reader state structure so each application gets instant notification of cha...
Definition: eventhandler.h:27
char * device
Device Name.
Definition: readerfactory.h:88
int channelId
CHANNELID.
Definition: readerfactory.h:32
char * pcDevicename
DEVICENAME.
Definition: readerfactory.h:30
int reference
number of users of the structure
pthread_mutex_t powerState_lock
powerState mutex
char * pcFriendlyname
FRIENDLYNAME.
Definition: readerfactory.h:29
Use by SCardTransmit()
Definition: ifdhandler.h:288
SCARDHANDLE hCard
hCard for this connection
Definition: readerfactory.h:79