pcsc-lite  1.8.11
readerfactory.h
Go to the documentation of this file.
1 /*
2  * MUSCLE SmartCard Development ( http://pcsclite.alioth.debian.org/pcsclite.html )
3  *
4  * Copyright (C) 1999
5  * David Corcoran <corcoran@musclecard.com>
6  * Copyright (C) 2002-2011
7  * Ludovic Rousseau <ludovic.rousseau@free.fr>
8  *
9 Redistribution and use in source and binary forms, with or without
10 modification, are permitted provided that the following conditions
11 are met:
12 
13 1. Redistributions of source code must retain the above copyright
14  notice, this list of conditions and the following disclaimer.
15 2. Redistributions in binary form must reproduce the above copyright
16  notice, this list of conditions and the following disclaimer in the
17  documentation and/or other materials provided with the distribution.
18 3. The name of the author may not be used to endorse or promote products
19  derived from this software without specific prior written permission.
20 
21 Changes to this license can be made only by the copyright author with
22 explicit written consent.
23 
24 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
25 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
26 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
27 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
28 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
29 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
33 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34  *
35  * $Id: readerfactory.h 6851 2014-02-14 15:43:32Z rousseau $
36  */
37 
43 #ifndef __readerfactory_h__
44 #define __readerfactory_h__
45 
46 #include <inttypes.h>
47 #include <pthread.h>
48 
49 #include "ifdhandler.h"
50 #include "pcscd.h"
51 #include "simclist.h"
52 
53  typedef struct
54  {
56  char *pcDevicename;
57  char *pcLibpath;
58  int channelId;
59  } SerialReader;
60 
61  struct FctMap_V2
62  {
63  /* shared with API 3.0 */
64  RESPONSECODE (*pvfCreateChannel)(DWORD, DWORD);
65  RESPONSECODE (*pvfCloseChannel)(DWORD);
66  RESPONSECODE (*pvfGetCapabilities)(DWORD, DWORD, PDWORD, PUCHAR);
67  RESPONSECODE (*pvfSetCapabilities)(DWORD, DWORD, DWORD, PUCHAR);
68  RESPONSECODE (*pvfSetProtocolParameters)(DWORD, DWORD, UCHAR, UCHAR,
69  UCHAR, UCHAR);
70  RESPONSECODE (*pvfPowerICC)(DWORD, DWORD, PUCHAR, PDWORD);
71  RESPONSECODE (*pvfTransmitToICC)(DWORD, SCARD_IO_HEADER, PUCHAR,
72  DWORD, PUCHAR, PDWORD, PSCARD_IO_HEADER);
73  RESPONSECODE (*pvfICCPresence)(DWORD);
74 
75  /* API v2.0 only */
76  RESPONSECODE (*pvfControl)(DWORD, PUCHAR, DWORD, PUCHAR, PDWORD);
77  };
78 
79  typedef struct FctMap_V2 FCT_MAP_V2;
80 
81  struct FctMap_V3
82  {
83  /* the common fields SHALL be in the same order as in FctMap_V2 */
84  RESPONSECODE (*pvfCreateChannel)(DWORD, DWORD);
85  RESPONSECODE (*pvfCloseChannel)(DWORD);
86  RESPONSECODE (*pvfGetCapabilities)(DWORD, DWORD, PDWORD, PUCHAR);
87  RESPONSECODE (*pvfSetCapabilities)(DWORD, DWORD, DWORD, PUCHAR);
88  RESPONSECODE (*pvfSetProtocolParameters)(DWORD, DWORD, UCHAR, UCHAR,
89  UCHAR, UCHAR);
90  RESPONSECODE (*pvfPowerICC)(DWORD, DWORD, PUCHAR, PDWORD);
91  RESPONSECODE (*pvfTransmitToICC)(DWORD, SCARD_IO_HEADER, PUCHAR,
92  DWORD, PUCHAR, PDWORD, PSCARD_IO_HEADER);
93  RESPONSECODE (*pvfICCPresence)(DWORD);
94 
95  /* API V3.0 only */
96  RESPONSECODE (*pvfControl)(DWORD, DWORD, LPCVOID, DWORD, LPVOID,
97  DWORD, LPDWORD);
98  RESPONSECODE (*pvfCreateChannelByName)(DWORD, LPSTR);
99  };
100 
101  typedef struct FctMap_V3 FCT_MAP_V3;
102 
104  {
107  };
108 
109  typedef struct RdrCliHandles RDR_CLIHANDLES;
110 
112  {
113  char *library;
114  char *device;
115  pthread_t pthThread;
116  RESPONSECODE (*pthCardEvent)(DWORD, int);
117  pthread_mutex_t *mMutex;
118  list_t handlesList;
119  pthread_mutex_t handlesList_lock;
121  union
122  {
125  } psFunctions;
127  LPVOID vHandle;
128  int version;
129  int port;
130  int slot;
131  volatile SCARDHANDLE hLockId;
132  int LockCount;
133  int32_t contexts;
134  int * pFeeds;
135  int * pMutex;
137  pthread_mutex_t powerState_lock;
138  int reference;
139  pthread_mutex_t reference_lock;
142  /* we can't use READER_STATE * here since eventhandler.h can't be
143  * included because of circular dependencies */
144  };
145 
146  typedef struct ReaderContext READER_CONTEXT;
147 
148  LONG _RefReader(READER_CONTEXT * sReader);
149  LONG _UnrefReader(READER_CONTEXT * sReader);
150 
151 #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; }
152 #define UNREF_READER(reader) {Log2(PCSC_LOG_DEBUG, "UnrefReader() count was: %d", reader->reference); _UnrefReader(reader);}
153 
154  LONG RFAllocateReaderSpace(unsigned int);
155  LONG RFAddReader(const char *, int, const char *, const char *);
156  LONG RFRemoveReader(const char *, int);
157  LONG RFSetReaderName(READER_CONTEXT *, const char *, const char *, int);
158  LONG RFReaderInfo(const char *, /*@out@*/ struct ReaderContext **);
159  LONG RFReaderInfoById(SCARDHANDLE, /*@out@*/ struct ReaderContext **);
160  LONG RFCheckSharing(SCARDHANDLE, READER_CONTEXT *);
161  LONG RFLockSharing(SCARDHANDLE, READER_CONTEXT *);
162  LONG RFUnlockSharing(SCARDHANDLE, READER_CONTEXT *);
163  LONG RFUnlockAllSharing(SCARDHANDLE, READER_CONTEXT *);
164  LONG RFLoadReader(READER_CONTEXT *);
165  LONG RFBindFunctions(READER_CONTEXT *);
166  LONG RFUnBindFunctions(READER_CONTEXT *);
167  LONG RFUnloadReader(READER_CONTEXT *);
168  LONG RFInitializeReader(READER_CONTEXT *);
169  LONG RFUnInitializeReader(READER_CONTEXT *);
170  SCARDHANDLE RFCreateReaderHandle(READER_CONTEXT *);
171  LONG RFDestroyReaderHandle(SCARDHANDLE hCard);
172  LONG RFAddReaderHandle(READER_CONTEXT *, SCARDHANDLE);
173  LONG RFRemoveReaderHandle(READER_CONTEXT *, SCARDHANDLE);
174  LONG RFSetReaderEventState(READER_CONTEXT *, DWORD);
175  LONG RFCheckReaderEventState(READER_CONTEXT *, SCARDHANDLE);
176  LONG RFClearReaderEventState(READER_CONTEXT *, SCARDHANDLE);
177  LONG RFCheckReaderStatus(READER_CONTEXT *);
178  void RFCleanupReaders(void);
179  void RFWaitForReaderInit(void);
180  int RFStartSerialReaders(const char *readerconf);
181  void RFReCheckReaderConf(void);
182 
183 #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.
FCT_MAP_V2 psFunctions_v2
API V2.0.
RESPONSECODE(* pthCardEvent)(DWORD, int)
Card Event sync.
DWORD dwEventStatus
Recent event that must be sent.
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
struct _SCARD_IO_HEADER SCARD_IO_HEADER
Use by SCardTransmit()
char * library
Library Path.
char * pcLibpath
LIBPATH.
Definition: readerfactory.h:57
FCT_MAP_V3 psFunctions_v3
API V3.0.
int * pFeeds
Number of shared client to lib.
int version
IFD Handler version number.
pthread_mutex_t * mMutex
Mutex for this connection.
int powerState
auto power off state
LONG SCARDHANDLE
hCard returned by SCardConnect()
Definition: pcsclite.h:60
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:53
char * device
Device Name.
int channelId
CHANNELID.
Definition: readerfactory.h:58
char * pcDevicename
DEVICENAME.
Definition: readerfactory.h:56
int reference
number of users of the structure
pthread_mutex_t powerState_lock
powerState mutex
char * pcFriendlyname
FRIENDLYNAME.
Definition: readerfactory.h:55
Use by SCardTransmit()
Definition: ifdhandler.h:314
SCARDHANDLE hCard
hCard for this connection