← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/pcsc-lite/jaunty-security

« back to all changes in this revision

Viewing changes to src/readerfactory.h

  • Committer: Bazaar Package Importer
  • Author(s): Ludovic Rousseau
  • Date: 2005-11-27 18:04:59 UTC
  • mfrom: (1.2.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051127180459-qrex2gzpq9d8jexd
Tags: 1.2.9-beta9-1
* New upstream version
* debian/compat: change from 3 to 4

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/readerfactory.h
 
1
/*
 
2
 * MUSCLE SmartCard Development ( http://www.linuxnet.com )
 
3
 *
 
4
 * Copyright (C) 1999
 
5
 *  David Corcoran <corcoran@linuxnet.com>
 
6
 * Copyright (C) 2004
 
7
 *  Ludovic Rousseau <ludovic.rousseau@free.fr>
 
8
 *
 
9
 * $Id: readerfactory.h 1530 2005-05-26 12:52:07Z rousseau $
 
10
 */
 
11
 
 
12
/**
 
13
 * @file
 
14
 * @brief This keeps track of a list of currently available reader structures.
 
15
 */
 
16
 
 
17
#ifndef __readerfactory_h__
 
18
#define __readerfactory_h__
 
19
 
 
20
#include "thread_generic.h"
 
21
#include "ifdhandler.h"
 
22
 
 
23
#ifdef __cplusplus
 
24
extern "C"
 
25
{
 
26
#endif
 
27
 
 
28
        typedef struct
 
29
        {
 
30
                char *pcFriendlyname;
 
31
                char *pcDevicename;
 
32
                char *pcLibpath;
 
33
                int dwChannelId;
 
34
        } SerialReader;
 
35
 
 
36
        struct FctMap_V1
 
37
        {
 
38
                RESPONSECODE (*pvfCreateChannel)(DWORD);
 
39
                RESPONSECODE (*pvfCloseChannel)(void);
 
40
                RESPONSECODE (*pvfGetCapabilities)(DWORD, PUCHAR);
 
41
                RESPONSECODE (*pvfSetCapabilities)(DWORD, PUCHAR);
 
42
                RESPONSECODE (*pvfSetProtocolParameters)(DWORD, UCHAR, UCHAR, UCHAR,
 
43
                        UCHAR);
 
44
                RESPONSECODE (*pvfPowerICC)(DWORD);
 
45
                RESPONSECODE (*pvfTransmitToICC)(SCARD_IO_HEADER, PUCHAR, DWORD,
 
46
                        PUCHAR, PDWORD, PSCARD_IO_HEADER);
 
47
                RESPONSECODE (*pvfICCPresence)(void);
 
48
        };
 
49
 
 
50
        typedef struct FctMap_V1 FCT_MAP_V1, *PFCT_MAP_V1;
 
51
 
 
52
        struct FctMap_V2
 
53
        {
 
54
                /* shared with API 3.0 */
 
55
                RESPONSECODE (*pvfCreateChannel)(DWORD, DWORD);
 
56
                RESPONSECODE (*pvfCloseChannel)(DWORD);
 
57
                RESPONSECODE (*pvfGetCapabilities)(DWORD, DWORD, PDWORD, PUCHAR);
 
58
                RESPONSECODE (*pvfSetCapabilities)(DWORD, DWORD, DWORD, PUCHAR);
 
59
                RESPONSECODE (*pvfSetProtocolParameters)(DWORD, DWORD, UCHAR, UCHAR,
 
60
                        UCHAR, UCHAR);
 
61
                RESPONSECODE (*pvfPowerICC)(DWORD, DWORD, PUCHAR, PDWORD);
 
62
                RESPONSECODE (*pvfTransmitToICC)(DWORD, SCARD_IO_HEADER, PUCHAR,
 
63
                        DWORD, PUCHAR, PDWORD, PSCARD_IO_HEADER);
 
64
                RESPONSECODE (*pvfICCPresence)(DWORD);
 
65
 
 
66
                /* API v2.0 only */
 
67
                RESPONSECODE (*pvfControl)(DWORD, PUCHAR, DWORD, PUCHAR, PDWORD);
 
68
        };
 
69
 
 
70
        typedef struct FctMap_V2 FCT_MAP_V2, *PFCT_MAP_V2;
 
71
 
 
72
        struct FctMap_V3
 
73
        {
 
74
                /* the common fields SHALL be in the same order as in FctMap_V2 */
 
75
                RESPONSECODE (*pvfCreateChannel)(DWORD, DWORD);
 
76
                RESPONSECODE (*pvfCloseChannel)(DWORD);
 
77
                RESPONSECODE (*pvfGetCapabilities)(DWORD, DWORD, PDWORD, PUCHAR);
 
78
                RESPONSECODE (*pvfSetCapabilities)(DWORD, DWORD, DWORD, PUCHAR);
 
79
                RESPONSECODE (*pvfSetProtocolParameters)(DWORD, DWORD, UCHAR, UCHAR,
 
80
                                UCHAR, UCHAR);
 
81
                RESPONSECODE (*pvfPowerICC)(DWORD, DWORD, PUCHAR, PDWORD);
 
82
                RESPONSECODE (*pvfTransmitToICC)(DWORD, SCARD_IO_HEADER, PUCHAR,
 
83
                        DWORD, PUCHAR, PDWORD, PSCARD_IO_HEADER);
 
84
                RESPONSECODE (*pvfICCPresence)(DWORD);
 
85
 
 
86
                /* API V3.0 only */
 
87
                RESPONSECODE (*pvfControl)(DWORD, DWORD, LPCVOID, DWORD, LPVOID,
 
88
                        DWORD, LPDWORD);
 
89
                RESPONSECODE (*pvfCreateChannelByName)(DWORD, LPTSTR);
 
90
        };
 
91
 
 
92
        typedef struct FctMap_V3 FCT_MAP_V3, *PFCT_MAP_V3;
 
93
 
 
94
        /*
 
95
         * The following is not currently used but in place if needed 
 
96
         */
 
97
 
 
98
        struct RdrCapabilities
 
99
        {
 
100
                DWORD dwAsynch_Supported;       /* Asynchronous Support */
 
101
                DWORD dwDefault_Clock;  /* Default Clock Rate */
 
102
                DWORD dwMax_Clock;              /* Max Clock Rate */
 
103
                DWORD dwDefault_Data_Rate;      /* Default Data Rate */
 
104
                DWORD dwMax_Data_Rate;  /* Max Data Rate */
 
105
                DWORD dwMax_IFSD;               /* Maximum IFSD Size */
 
106
                DWORD dwSynch_Supported;        /* Synchronous Support */
 
107
                DWORD dwPower_Mgmt;             /* Power Mgmt Features */
 
108
                DWORD dwCard_Auth_Devices;      /* Card Auth Devices */
 
109
                DWORD dwUser_Auth_Device;       /* User Auth Devices */
 
110
                DWORD dwMechanics_Supported;    /* Machanics Supported */
 
111
                DWORD dwVendor_Features;        /* User Defined.  */
 
112
        };
 
113
 
 
114
        typedef struct RdrCapabilities RDR_CAPABILITIES, *PRDR_CAPABILITIES;
 
115
 
 
116
        struct ProtOptions
 
117
        {
 
118
                DWORD dwProtocol_Type;  /* Protocol Type */
 
119
                DWORD dwCurrent_Clock;  /* Current Clock */
 
120
                DWORD dwCurrent_F;              /* Current F */
 
121
                DWORD dwCurrent_D;              /* Current D */
 
122
                DWORD dwCurrent_N;              /* Current N */
 
123
                DWORD dwCurrent_W;              /* Current W */
 
124
                DWORD dwCurrent_IFSC;   /* Current IFSC */
 
125
                DWORD dwCurrent_IFSD;   /* Current IFSD */
 
126
                DWORD dwCurrent_BWT;    /* Current BWT */
 
127
                DWORD dwCurrent_CWT;    /* Current CWT */
 
128
                DWORD dwCurrent_EBC;    /* Current EBC */
 
129
        };
 
130
 
 
131
        typedef struct ProtOptions PROT_OPTIONS, *PPROT_OPTIONS;
 
132
 
 
133
        struct RdrCliHandles
 
134
        {
 
135
                SCARDHANDLE hCard;              /* hCard for this connection */
 
136
                DWORD dwEventStatus;    /* Recent event that must be sent */
 
137
        };
 
138
 
 
139
        typedef struct RdrCliHandles RDR_CLIHANDLES, *PRDR_CLIHANDLES;
 
140
 
 
141
        struct ReaderContext
 
142
        {
 
143
                char lpcReader[MAX_READERNAME]; /* Reader Name */
 
144
                char lpcLibrary[MAX_LIBNAME];   /* Library Path */
 
145
                char lpcDevice[MAX_DEVICENAME]; /* Device Name */
 
146
                PCSCLITE_THREAD_T pthThread;    /* Event polling thread */
 
147
                PCSCLITE_MUTEX_T mMutex;        /* Mutex for this connection */
 
148
                RDR_CLIHANDLES psHandles[PCSCLITE_MAX_READER_CONTEXT_CHANNELS]; 
 
149
                                         /* Structure of connected handles */
 
150
                union
 
151
                {
 
152
                        FCT_MAP_V1 psFunctions_v1;      /* API V1.0 */
 
153
                        FCT_MAP_V2 psFunctions_v2;      /* API V2.0 */
 
154
                        FCT_MAP_V3 psFunctions_v3;      /* API V3.0 */
 
155
                } psFunctions;
 
156
 
 
157
                LPVOID vHandle;                 /* Dlopen handle */
 
158
                DWORD dwVersion;                /* IFD Handler version number */
 
159
                DWORD dwPort;                   /* Port ID */
 
160
                DWORD dwSlot;                   /* Current Reader Slot */
 
161
                DWORD dwBlockStatus;    /* Current blocking status */
 
162
                DWORD dwLockId;                 /* Lock Id */
 
163
                DWORD dwIdentity;               /* Shared ID High Nibble */
 
164
                DWORD dwContexts;               /* Number of open contexts */
 
165
                PDWORD pdwFeeds;                /* Number of shared client to lib */
 
166
                PDWORD pdwMutex;                /* Number of client to mutex */
 
167
 
 
168
                struct pubReaderStatesList *readerState; /* link to the reader state */
 
169
                /* we can't use PREADER_STATE here since eventhandler.h can't be
 
170
                 * included because of circular dependencies */
 
171
 
 
172
                /* these structures are unused */
 
173
#if 0
 
174
                RDR_CAPABILITIES psCapabilites; /* Structure of reader
 
175
                                                   capabilities */
 
176
                PROT_OPTIONS psProtOptions;     /* Structure of protocol options */
 
177
#endif
 
178
        };
 
179
 
 
180
        typedef struct ReaderContext READER_CONTEXT, *PREADER_CONTEXT;
 
181
 
 
182
        LONG RFAllocateReaderSpace(void);
 
183
        LONG RFAddReader(LPTSTR, DWORD, LPTSTR, LPTSTR);
 
184
        LONG RFRemoveReader(LPTSTR, DWORD);
 
185
        LONG RFSetReaderName(PREADER_CONTEXT, LPTSTR, LPTSTR, DWORD, DWORD);
 
186
        LONG RFListReaders(LPTSTR, LPDWORD);
 
187
        LONG RFReaderInfo(LPTSTR, struct ReaderContext **);
 
188
        LONG RFReaderInfoNamePort(DWORD, LPTSTR, struct ReaderContext **);
 
189
        LONG RFReaderInfoById(DWORD, struct ReaderContext **);
 
190
        LONG RFCheckSharing(DWORD);
 
191
        LONG RFLockSharing(DWORD);
 
192
        LONG RFUnlockSharing(DWORD);
 
193
        LONG RFUnblockReader(PREADER_CONTEXT);
 
194
        LONG RFUnblockContext(SCARDCONTEXT);
 
195
        LONG RFLoadReader(PREADER_CONTEXT);
 
196
        LONG RFBindFunctions(PREADER_CONTEXT);
 
197
        LONG RFUnBindFunctions(PREADER_CONTEXT);
 
198
        LONG RFUnloadReader(PREADER_CONTEXT);
 
199
        LONG RFInitializeReader(PREADER_CONTEXT);
 
200
        LONG RFUnInitializeReader(PREADER_CONTEXT);
 
201
        SCARDHANDLE RFCreateReaderHandle(PREADER_CONTEXT);
 
202
        LONG RFDestroyReaderHandle(SCARDHANDLE hCard);
 
203
        LONG RFAddReaderHandle(PREADER_CONTEXT, SCARDHANDLE);
 
204
        LONG RFFindReaderHandle(SCARDHANDLE);
 
205
        LONG RFRemoveReaderHandle(PREADER_CONTEXT, SCARDHANDLE);
 
206
        LONG RFSetReaderEventState(PREADER_CONTEXT, DWORD);
 
207
        LONG RFCheckReaderEventState(PREADER_CONTEXT, SCARDHANDLE);
 
208
        LONG RFClearReaderEventState(PREADER_CONTEXT, SCARDHANDLE);
 
209
        LONG RFCheckReaderStatus(PREADER_CONTEXT);
 
210
        void RFCleanupReaders(int);
 
211
        int RFStartSerialReaders(char *readerconf);
 
212
        void RFReCheckReaderConf(void);
 
213
        void RFSuspendAllReaders(void); 
 
214
        void RFAwakeAllReaders(void); 
 
215
 
 
216
#ifdef __cplusplus
 
217
}
 
218
#endif
 
219
 
 
220
#endif