scd: more pinpad fix.
[gnupg.git] / scd / apdu.c
1 /* apdu.c - ISO 7816 APDU functions and low level I/O
2  * Copyright (C) 2003, 2004, 2008, 2009, 2010,
3  *               2011 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 /* NOTE: This module is also used by other software, thus the use of
22    the macro USE_NPTH is mandatory.  For GnuPG this macro is
23    guaranteed to be defined true. */
24
25 #include <config.h>
26 #include <errno.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <assert.h>
31 #include <signal.h>
32 #ifdef USE_NPTH
33 # include <unistd.h>
34 # include <fcntl.h>
35 # include <npth.h>
36 #endif
37
38
39 /* If requested include the definitions for the remote APDU protocol
40    code. */
41 #ifdef USE_G10CODE_RAPDU
42 #include "rapdu.h"
43 #endif /*USE_G10CODE_RAPDU*/
44
45 #if defined(GNUPG_SCD_MAIN_HEADER)
46 #include GNUPG_SCD_MAIN_HEADER
47 #elif GNUPG_MAJOR_VERSION == 1
48 /* This is used with GnuPG version < 1.9.  The code has been source
49    copied from the current GnuPG >= 1.9  and is maintained over
50    there. */
51 #include "options.h"
52 #include "errors.h"
53 #include "memory.h"
54 #include "util.h"
55 #include "i18n.h"
56 #include "dynload.h"
57 #include "cardglue.h"
58 #else /* GNUPG_MAJOR_VERSION != 1 */
59 #include "scdaemon.h"
60 #include "exechelp.h"
61 #endif /* GNUPG_MAJOR_VERSION != 1 */
62
63 #include "iso7816.h"
64 #include "apdu.h"
65 #define CCID_DRIVER_INCLUDE_USB_IDS 1
66 #include "ccid-driver.h"
67
68 /* Due to conflicting use of threading libraries we usually can't link
69    against libpcsclite.   Instead we use a wrapper program.  */
70 #ifdef USE_NPTH
71 #if !defined(HAVE_W32_SYSTEM) && !defined(__CYGWIN__)
72 #define NEED_PCSC_WRAPPER 1
73 #endif
74 #endif
75
76
77 #define MAX_READER 4 /* Number of readers we support concurrently. */
78
79
80 #if defined(_WIN32) || defined(__CYGWIN__)
81 #define DLSTDCALL __stdcall
82 #else
83 #define DLSTDCALL
84 #endif
85
86 #if defined(__APPLE__) || defined(_WIN32) || defined(__CYGWIN__)
87 typedef unsigned int pcsc_dword_t;
88 #else
89 typedef unsigned long pcsc_dword_t;
90 #endif
91
92 /* A structure to collect information pertaining to one reader
93    slot. */
94 struct reader_table_s {
95   int used;            /* True if slot is used. */
96   unsigned short port; /* Port number:  0 = unused, 1 - dev/tty */
97
98   /* Function pointers intialized to the various backends.  */
99   int (*connect_card)(int);
100   int (*disconnect_card)(int);
101   int (*close_reader)(int);
102   int (*shutdown_reader)(int);
103   int (*reset_reader)(int);
104   int (*get_status_reader)(int, unsigned int *);
105   int (*send_apdu_reader)(int,unsigned char *,size_t,
106                           unsigned char *, size_t *, pininfo_t *);
107   int (*check_pinpad)(int, int, pininfo_t *);
108   void (*dump_status_reader)(int);
109   int (*set_progress_cb)(int, gcry_handler_progress_t, void*);
110   int (*pinpad_verify)(int, int, int, int, int, pininfo_t *);
111   int (*pinpad_modify)(int, int, int, int, int, pininfo_t *);
112
113   struct {
114     ccid_driver_t handle;
115   } ccid;
116   struct {
117     long context;
118     long card;
119     pcsc_dword_t protocol;
120     pcsc_dword_t verify_ioctl;
121     pcsc_dword_t modify_ioctl;
122     int pinmin;
123     int pinmax;
124 #ifdef NEED_PCSC_WRAPPER
125     int req_fd;
126     int rsp_fd;
127     pid_t pid;
128 #endif /*NEED_PCSC_WRAPPER*/
129   } pcsc;
130 #ifdef USE_G10CODE_RAPDU
131   struct {
132     rapdu_t handle;
133   } rapdu;
134 #endif /*USE_G10CODE_RAPDU*/
135   char *rdrname;     /* Name of the connected reader or NULL if unknown. */
136   int any_status;    /* True if we have seen any status.  */
137   int last_status;
138   int status;
139   int is_t0;         /* True if we know that we are running T=0. */
140   int is_spr532;     /* True if we know that the reader is a SPR532.  */
141   int pinpad_varlen_supported;  /* True if we know that the reader
142                                    supports variable length pinpad
143                                    input.  */
144   unsigned char atr[33];
145   size_t atrlen;           /* A zero length indicates that the ATR has
146                               not yet been read; i.e. the card is not
147                               ready for use. */
148   unsigned int change_counter;
149 #ifdef USE_NPTH
150   int lock_initialized;
151   npth_mutex_t lock;
152 #endif
153 };
154 typedef struct reader_table_s *reader_table_t;
155
156 /* A global table to keep track of active readers. */
157 static struct reader_table_s reader_table[MAX_READER];
158
159
160 /* ct API function pointer. */
161 static char (* DLSTDCALL CT_init) (unsigned short ctn, unsigned short Pn);
162 static char (* DLSTDCALL CT_data) (unsigned short ctn, unsigned char *dad,
163                                    unsigned char *sad, unsigned short lc,
164                                    unsigned char *cmd, unsigned short *lr,
165                                    unsigned char *rsp);
166 static char (* DLSTDCALL CT_close) (unsigned short ctn);
167
168 /* PC/SC constants and function pointer. */
169 #define PCSC_SCOPE_USER      0
170 #define PCSC_SCOPE_TERMINAL  1
171 #define PCSC_SCOPE_SYSTEM    2
172 #define PCSC_SCOPE_GLOBAL    3
173
174 #define PCSC_PROTOCOL_T0     1
175 #define PCSC_PROTOCOL_T1     2
176 #ifdef HAVE_W32_SYSTEM
177 # define PCSC_PROTOCOL_RAW   0x00010000  /* The active protocol.  */
178 #else
179 # define PCSC_PROTOCOL_RAW   4
180 #endif
181
182 #define PCSC_SHARE_EXCLUSIVE 1
183 #define PCSC_SHARE_SHARED    2
184 #define PCSC_SHARE_DIRECT    3
185
186 #define PCSC_LEAVE_CARD      0
187 #define PCSC_RESET_CARD      1
188 #define PCSC_UNPOWER_CARD    2
189 #define PCSC_EJECT_CARD      3
190
191 #ifdef HAVE_W32_SYSTEM
192 # define PCSC_UNKNOWN    0x0000  /* The driver is not aware of the status.  */
193 # define PCSC_ABSENT     0x0001  /* Card is absent.  */
194 # define PCSC_PRESENT    0x0002  /* Card is present.  */
195 # define PCSC_SWALLOWED  0x0003  /* Card is present and electrical connected. */
196 # define PCSC_POWERED    0x0004  /* Card is powered.  */
197 # define PCSC_NEGOTIABLE 0x0005  /* Card is awaiting PTS.  */
198 # define PCSC_SPECIFIC   0x0006  /* Card is ready for use.  */
199 #else
200 # define PCSC_UNKNOWN    0x0001
201 # define PCSC_ABSENT     0x0002  /* Card is absent.  */
202 # define PCSC_PRESENT    0x0004  /* Card is present.  */
203 # define PCSC_SWALLOWED  0x0008  /* Card is present and electrical connected. */
204 # define PCSC_POWERED    0x0010  /* Card is powered.  */
205 # define PCSC_NEGOTIABLE 0x0020  /* Card is awaiting PTS.  */
206 # define PCSC_SPECIFIC   0x0040  /* Card is ready for use.  */
207 #endif
208
209 #define PCSC_STATE_UNAWARE     0x0000  /* Want status.  */
210 #define PCSC_STATE_IGNORE      0x0001  /* Ignore this reader.  */
211 #define PCSC_STATE_CHANGED     0x0002  /* State has changed.  */
212 #define PCSC_STATE_UNKNOWN     0x0004  /* Reader unknown.  */
213 #define PCSC_STATE_UNAVAILABLE 0x0008  /* Status unavailable.  */
214 #define PCSC_STATE_EMPTY       0x0010  /* Card removed.  */
215 #define PCSC_STATE_PRESENT     0x0020  /* Card inserted.  */
216 #define PCSC_STATE_ATRMATCH    0x0040  /* ATR matches card. */
217 #define PCSC_STATE_EXCLUSIVE   0x0080  /* Exclusive Mode.  */
218 #define PCSC_STATE_INUSE       0x0100  /* Shared mode.  */
219 #define PCSC_STATE_MUTE        0x0200  /* Unresponsive card.  */
220 #ifdef HAVE_W32_SYSTEM
221 # define PCSC_STATE_UNPOWERED  0x0400  /* Card not powerred up.  */
222 #endif
223
224 /* Some PC/SC error codes.  */
225 #define PCSC_E_CANCELLED               0x80100002
226 #define PCSC_E_CANT_DISPOSE            0x8010000E
227 #define PCSC_E_INSUFFICIENT_BUFFER     0x80100008
228 #define PCSC_E_INVALID_ATR             0x80100015
229 #define PCSC_E_INVALID_HANDLE          0x80100003
230 #define PCSC_E_INVALID_PARAMETER       0x80100004
231 #define PCSC_E_INVALID_TARGET          0x80100005
232 #define PCSC_E_INVALID_VALUE           0x80100011
233 #define PCSC_E_NO_MEMORY               0x80100006
234 #define PCSC_E_UNKNOWN_READER          0x80100009
235 #define PCSC_E_TIMEOUT                 0x8010000A
236 #define PCSC_E_SHARING_VIOLATION       0x8010000B
237 #define PCSC_E_NO_SMARTCARD            0x8010000C
238 #define PCSC_E_UNKNOWN_CARD            0x8010000D
239 #define PCSC_E_PROTO_MISMATCH          0x8010000F
240 #define PCSC_E_NOT_READY               0x80100010
241 #define PCSC_E_SYSTEM_CANCELLED        0x80100012
242 #define PCSC_E_NOT_TRANSACTED          0x80100016
243 #define PCSC_E_READER_UNAVAILABLE      0x80100017
244 #define PCSC_E_NO_SERVICE              0x8010001D
245 #define PCSC_W_REMOVED_CARD            0x80100069
246
247 /* Fix pcsc-lite ABI incompatibilty.  */
248 #ifndef SCARD_CTL_CODE
249 #ifdef _WIN32
250 #include <winioctl.h>
251 #define SCARD_CTL_CODE(code) CTL_CODE(FILE_DEVICE_SMARTCARD, (code), \
252                                       METHOD_BUFFERED, FILE_ANY_ACCESS)
253 #else
254 #define SCARD_CTL_CODE(code) (0x42000000 + (code))
255 #endif
256 #endif
257
258 #define CM_IOCTL_GET_FEATURE_REQUEST     SCARD_CTL_CODE(3400)
259 #define CM_IOCTL_VENDOR_IFD_EXCHANGE     SCARD_CTL_CODE(1)
260 #define FEATURE_VERIFY_PIN_DIRECT        0x06
261 #define FEATURE_MODIFY_PIN_DIRECT        0x07
262 #define FEATURE_GET_TLV_PROPERTIES       0x12
263
264 #define PCSCv2_PART10_PROPERTY_bEntryValidationCondition 2
265 #define PCSCv2_PART10_PROPERTY_bTimeOut2                 3
266 #define PCSCv2_PART10_PROPERTY_bMinPINSize               6
267 #define PCSCv2_PART10_PROPERTY_bMaxPINSize               7
268 #define PCSCv2_PART10_PROPERTY_wIdVendor                11
269 #define PCSCv2_PART10_PROPERTY_wIdProduct               12
270
271
272 /* The PC/SC error is defined as a long as per specs.  Due to left
273    shifts bit 31 will get sign extended.  We use this mask to fix
274    it. */
275 #define PCSC_ERR_MASK(a)  ((a) & 0xffffffff)
276
277
278 struct pcsc_io_request_s
279 {
280   unsigned long protocol;
281   unsigned long pci_len;
282 };
283
284 typedef struct pcsc_io_request_s *pcsc_io_request_t;
285
286 #ifdef __APPLE__
287 #pragma pack(1)
288 #endif
289
290 struct pcsc_readerstate_s
291 {
292   const char *reader;
293   void *user_data;
294   pcsc_dword_t current_state;
295   pcsc_dword_t event_state;
296   pcsc_dword_t atrlen;
297   unsigned char atr[33];
298 };
299
300 #ifdef __APPLE__
301 #pragma pack()
302 #endif
303
304 typedef struct pcsc_readerstate_s *pcsc_readerstate_t;
305
306 long (* DLSTDCALL pcsc_establish_context) (pcsc_dword_t scope,
307                                            const void *reserved1,
308                                            const void *reserved2,
309                                            long *r_context);
310 long (* DLSTDCALL pcsc_release_context) (long context);
311 long (* DLSTDCALL pcsc_list_readers) (long context,
312                                       const char *groups,
313                                       char *readers, pcsc_dword_t*readerslen);
314 long (* DLSTDCALL pcsc_get_status_change) (long context,
315                                            pcsc_dword_t timeout,
316                                            pcsc_readerstate_t readerstates,
317                                            pcsc_dword_t nreaderstates);
318 long (* DLSTDCALL pcsc_connect) (long context,
319                                  const char *reader,
320                                  pcsc_dword_t share_mode,
321                                  pcsc_dword_t preferred_protocols,
322                                  long *r_card,
323                                  pcsc_dword_t *r_active_protocol);
324 long (* DLSTDCALL pcsc_reconnect) (long card,
325                                    pcsc_dword_t share_mode,
326                                    pcsc_dword_t preferred_protocols,
327                                    pcsc_dword_t initialization,
328                                    pcsc_dword_t *r_active_protocol);
329 long (* DLSTDCALL pcsc_disconnect) (long card,
330                                     pcsc_dword_t disposition);
331 long (* DLSTDCALL pcsc_status) (long card,
332                                 char *reader, pcsc_dword_t *readerlen,
333                                 pcsc_dword_t *r_state,
334                                 pcsc_dword_t *r_protocol,
335                                 unsigned char *atr, pcsc_dword_t *atrlen);
336 long (* DLSTDCALL pcsc_begin_transaction) (long card);
337 long (* DLSTDCALL pcsc_end_transaction) (long card,
338                                          pcsc_dword_t disposition);
339 long (* DLSTDCALL pcsc_transmit) (long card,
340                                   const pcsc_io_request_t send_pci,
341                                   const unsigned char *send_buffer,
342                                   pcsc_dword_t send_len,
343                                   pcsc_io_request_t recv_pci,
344                                   unsigned char *recv_buffer,
345                                   pcsc_dword_t *recv_len);
346 long (* DLSTDCALL pcsc_set_timeout) (long context,
347                                      pcsc_dword_t timeout);
348 long (* DLSTDCALL pcsc_control) (long card,
349                                  pcsc_dword_t control_code,
350                                  const void *send_buffer,
351                                  pcsc_dword_t send_len,
352                                  void *recv_buffer,
353                                  pcsc_dword_t recv_len,
354                                  pcsc_dword_t *bytes_returned);
355
356
357 /*  Prototypes.  */
358 static int pcsc_vendor_specific_init (int slot);
359 static int pcsc_get_status (int slot, unsigned int *status);
360 static int reset_pcsc_reader (int slot);
361 static int apdu_get_status_internal (int slot, int hang, int no_atr_reset,
362                                      unsigned int *status,
363                                      unsigned int *changed);
364 static int check_pcsc_pinpad (int slot, int command, pininfo_t *pininfo);
365 static int pcsc_pinpad_verify (int slot, int class, int ins, int p0, int p1,
366                                pininfo_t *pininfo);
367 static int pcsc_pinpad_modify (int slot, int class, int ins, int p0, int p1,
368                                pininfo_t *pininfo);
369
370
371 \f
372 /*
373       Helper
374  */
375
376
377 /* Find an unused reader slot for PORTSTR and put it into the reader
378    table.  Return -1 on error or the index into the reader table. */
379 static int
380 new_reader_slot (void)
381 {
382   int i, reader = -1;
383   int err;
384
385   for (i=0; i < MAX_READER; i++)
386     {
387       if (!reader_table[i].used && reader == -1)
388         reader = i;
389     }
390   if (reader == -1)
391     {
392       log_error ("new_reader_slot: out of slots\n");
393       return -1;
394     }
395 #ifdef USE_NPTH
396   if (!reader_table[reader].lock_initialized)
397     {
398       err = npth_mutex_init (&reader_table[reader].lock, NULL);
399       if (err)
400         {
401           log_error ("error initializing mutex: %s\n", strerror (err));
402           return -1;
403         }
404       reader_table[reader].lock_initialized = 1;
405     }
406 #endif /*USE_NPTH*/
407   reader_table[reader].connect_card = NULL;
408   reader_table[reader].disconnect_card = NULL;
409   reader_table[reader].close_reader = NULL;
410   reader_table[reader].shutdown_reader = NULL;
411   reader_table[reader].reset_reader = NULL;
412   reader_table[reader].get_status_reader = NULL;
413   reader_table[reader].send_apdu_reader = NULL;
414   reader_table[reader].check_pinpad = check_pcsc_pinpad;
415   reader_table[reader].dump_status_reader = NULL;
416   reader_table[reader].set_progress_cb = NULL;
417   reader_table[reader].pinpad_verify = pcsc_pinpad_verify;
418   reader_table[reader].pinpad_modify = pcsc_pinpad_modify;
419
420   reader_table[reader].used = 1;
421   reader_table[reader].any_status = 0;
422   reader_table[reader].last_status = 0;
423   reader_table[reader].is_t0 = 1;
424   reader_table[reader].is_spr532 = 0;
425   reader_table[reader].pinpad_varlen_supported = 0;
426 #ifdef NEED_PCSC_WRAPPER
427   reader_table[reader].pcsc.req_fd = -1;
428   reader_table[reader].pcsc.rsp_fd = -1;
429   reader_table[reader].pcsc.pid = (pid_t)(-1);
430 #endif
431   reader_table[reader].pcsc.verify_ioctl = 0;
432   reader_table[reader].pcsc.modify_ioctl = 0;
433   reader_table[reader].pcsc.pinmin = -1;
434   reader_table[reader].pcsc.pinmax = -1;
435
436   return reader;
437 }
438
439
440 static void
441 dump_reader_status (int slot)
442 {
443   if (!opt.verbose)
444     return;
445
446   if (reader_table[slot].dump_status_reader)
447     reader_table[slot].dump_status_reader (slot);
448
449   if (reader_table[slot].status != -1
450       && reader_table[slot].atrlen)
451     {
452       log_info ("slot %d: ATR=", slot);
453       log_printhex ("", reader_table[slot].atr, reader_table[slot].atrlen);
454     }
455 }
456
457
458
459 static const char *
460 host_sw_string (long err)
461 {
462   switch (err)
463     {
464     case 0: return "okay";
465     case SW_HOST_OUT_OF_CORE: return "out of core";
466     case SW_HOST_INV_VALUE: return "invalid value";
467     case SW_HOST_NO_DRIVER: return "no driver";
468     case SW_HOST_NOT_SUPPORTED: return "not supported";
469     case SW_HOST_LOCKING_FAILED: return "locking failed";
470     case SW_HOST_BUSY: return "busy";
471     case SW_HOST_NO_CARD: return "no card";
472     case SW_HOST_CARD_INACTIVE: return "card inactive";
473     case SW_HOST_CARD_IO_ERROR: return "card I/O error";
474     case SW_HOST_GENERAL_ERROR: return "general error";
475     case SW_HOST_NO_READER: return "no reader";
476     case SW_HOST_ABORTED: return "aborted";
477     case SW_HOST_NO_PINPAD: return "no pinpad";
478     case SW_HOST_ALREADY_CONNECTED: return "already connected";
479     default: return "unknown host status error";
480     }
481 }
482
483
484 const char *
485 apdu_strerror (int rc)
486 {
487   switch (rc)
488     {
489     case SW_EOF_REACHED    : return "eof reached";
490     case SW_EEPROM_FAILURE : return "eeprom failure";
491     case SW_WRONG_LENGTH   : return "wrong length";
492     case SW_CHV_WRONG      : return "CHV wrong";
493     case SW_CHV_BLOCKED    : return "CHV blocked";
494     case SW_USE_CONDITIONS : return "use conditions not satisfied";
495     case SW_BAD_PARAMETER  : return "bad parameter";
496     case SW_NOT_SUPPORTED  : return "not supported";
497     case SW_FILE_NOT_FOUND : return "file not found";
498     case SW_RECORD_NOT_FOUND:return "record not found";
499     case SW_REF_NOT_FOUND  : return "reference not found";
500     case SW_NOT_ENOUGH_MEMORY: return "not enough memory space in the file";
501     case SW_INCONSISTENT_LC: return "Lc inconsistent with TLV structure.";
502     case SW_INCORRECT_P0_P1: return "incorrect parameters P0,P1";
503     case SW_BAD_LC         : return "Lc inconsistent with P0,P1";
504     case SW_BAD_P0_P1      : return "bad P0,P1";
505     case SW_INS_NOT_SUP    : return "instruction not supported";
506     case SW_CLA_NOT_SUP    : return "class not supported";
507     case SW_SUCCESS        : return "success";
508     default:
509       if ((rc & ~0x00ff) == SW_MORE_DATA)
510         return "more data available";
511       if ( (rc & 0x10000) )
512         return host_sw_string (rc);
513       return "unknown status error";
514     }
515 }
516
517
518 \f
519 /*
520        ct API Interface
521  */
522
523 static const char *
524 ct_error_string (long err)
525 {
526   switch (err)
527     {
528     case 0: return "okay";
529     case -1: return "invalid data";
530     case -8: return "ct error";
531     case -10: return "transmission error";
532     case -11: return "memory allocation error";
533     case -128: return "HTSI error";
534     default: return "unknown CT-API error";
535     }
536 }
537
538
539 static void
540 ct_dump_reader_status (int slot)
541 {
542   log_info ("reader slot %d: %s\n", slot,
543             reader_table[slot].status == 1? "Processor ICC present" :
544             reader_table[slot].status == 0? "Memory ICC present" :
545             "ICC not present" );
546 }
547
548
549 /* Wait for the card in SLOT and activate it.  Return a status word
550    error or 0 on success. */
551 static int
552 ct_activate_card (int slot)
553 {
554   int rc;
555   unsigned char dad[1], sad[1], cmd[11], buf[256];
556   unsigned short buflen;
557
558   /* Check whether card has been inserted. */
559   dad[0] = 1;     /* Destination address: CT. */
560   sad[0] = 2;     /* Source address: Host. */
561
562   cmd[0] = 0x20;  /* Class byte. */
563   cmd[1] = 0x13;  /* Request status. */
564   cmd[2] = 0x00;  /* From kernel. */
565   cmd[3] = 0x80;  /* Return card's DO. */
566   cmd[4] = 0x00;
567
568   buflen = DIM(buf);
569
570   rc = CT_data (slot, dad, sad, 5, cmd, &buflen, buf);
571   if (rc || buflen < 2 || buf[buflen-2] != 0x90)
572     {
573       log_error ("ct_activate_card: can't get status of reader %d: %s\n",
574                  slot, ct_error_string (rc));
575       return SW_HOST_CARD_IO_ERROR;
576     }
577
578   /* Connected, now activate the card. */
579   dad[0] = 1;    /* Destination address: CT. */
580   sad[0] = 2;    /* Source address: Host. */
581
582   cmd[0] = 0x20;  /* Class byte. */
583   cmd[1] = 0x12;  /* Request ICC. */
584   cmd[2] = 0x01;  /* From first interface. */
585   cmd[3] = 0x01;  /* Return card's ATR. */
586   cmd[4] = 0x00;
587
588   buflen = DIM(buf);
589
590   rc = CT_data (slot, dad, sad, 5, cmd, &buflen, buf);
591   if (rc || buflen < 2 || buf[buflen-2] != 0x90)
592     {
593       log_error ("ct_activate_card(%d): activation failed: %s\n",
594                  slot, ct_error_string (rc));
595       if (!rc)
596         log_printhex ("  received data:", buf, buflen);
597       return SW_HOST_CARD_IO_ERROR;
598     }
599
600   /* Store the type and the ATR. */
601   if (buflen - 2 > DIM (reader_table[0].atr))
602     {
603       log_error ("ct_activate_card(%d): ATR too long\n", slot);
604       return SW_HOST_CARD_IO_ERROR;
605     }
606
607   reader_table[slot].status = buf[buflen - 1];
608   memcpy (reader_table[slot].atr, buf, buflen - 2);
609   reader_table[slot].atrlen = buflen - 2;
610   return 0;
611 }
612
613
614 static int
615 close_ct_reader (int slot)
616 {
617   CT_close (slot);
618   reader_table[slot].used = 0;
619   return 0;
620 }
621
622 static int
623 reset_ct_reader (int slot)
624 {
625   /* FIXME: Check is this is sufficient do do a reset. */
626   return ct_activate_card (slot);
627 }
628
629
630 static int
631 ct_get_status (int slot, unsigned int *status)
632 {
633   (void)slot;
634   /* The status we returned is wrong but we don't care becuase ctAPI
635      is not anymore required.  */
636   *status = APDU_CARD_USABLE|APDU_CARD_PRESENT|APDU_CARD_ACTIVE;
637   return 0;
638 }
639
640 /* Actually send the APDU of length APDULEN to SLOT and return a
641    maximum of *BUFLEN data in BUFFER, the actual retruned size will be
642    set to BUFLEN.  Returns: CT API error code. */
643 static int
644 ct_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
645               unsigned char *buffer, size_t *buflen, pininfo_t *pininfo)
646 {
647   int rc;
648   unsigned char dad[1], sad[1];
649   unsigned short ctbuflen;
650
651   (void)pininfo;
652
653   /* If we don't have an ATR, we need to reset the reader first. */
654   if (!reader_table[slot].atrlen
655       && (rc = reset_ct_reader (slot)))
656     return rc;
657
658   dad[0] = 0;     /* Destination address: Card. */
659   sad[0] = 2;     /* Source address: Host. */
660   ctbuflen = *buflen;
661   if (DBG_CARD_IO)
662     log_printhex ("  CT_data:", apdu, apdulen);
663   rc = CT_data (slot, dad, sad, apdulen, apdu, &ctbuflen, buffer);
664   *buflen = ctbuflen;
665
666   return rc? SW_HOST_CARD_IO_ERROR: 0;
667 }
668
669
670
671 /* Open a reader and return an internal handle for it.  PORT is a
672    non-negative value with the port number of the reader. USB readers
673    do have port numbers starting at 32769. */
674 static int
675 open_ct_reader (int port)
676 {
677   int rc, reader;
678
679   if (port < 0 || port > 0xffff)
680     {
681       log_error ("open_ct_reader: invalid port %d requested\n", port);
682       return -1;
683     }
684   reader = new_reader_slot ();
685   if (reader == -1)
686     return reader;
687   reader_table[reader].port = port;
688
689   rc = CT_init (reader, (unsigned short)port);
690   if (rc)
691     {
692       log_error ("apdu_open_ct_reader failed on port %d: %s\n",
693                  port, ct_error_string (rc));
694       reader_table[reader].used = 0;
695       return -1;
696     }
697
698   /* Only try to activate the card. */
699   rc = ct_activate_card (reader);
700   if (rc)
701     {
702       reader_table[reader].atrlen = 0;
703       rc = 0;
704     }
705
706   reader_table[reader].close_reader = close_ct_reader;
707   reader_table[reader].reset_reader = reset_ct_reader;
708   reader_table[reader].get_status_reader = ct_get_status;
709   reader_table[reader].send_apdu_reader = ct_send_apdu;
710   reader_table[reader].check_pinpad = NULL;
711   reader_table[reader].dump_status_reader = ct_dump_reader_status;
712   reader_table[reader].pinpad_verify = NULL;
713   reader_table[reader].pinpad_modify = NULL;
714
715   dump_reader_status (reader);
716   return reader;
717 }
718
719 \f
720 /*
721        PC/SC Interface
722  */
723
724 #ifdef NEED_PCSC_WRAPPER
725 static int
726 writen (int fd, const void *buf, size_t nbytes)
727 {
728   size_t nleft = nbytes;
729   int nwritten;
730
731 /*   log_printhex (" writen:", buf, nbytes); */
732
733   while (nleft > 0)
734     {
735 #ifdef USE_NPTH
736       nwritten = npth_write (fd, buf, nleft);
737 #else
738       nwritten = write (fd, buf, nleft);
739 #endif
740       if (nwritten < 0 && errno == EINTR)
741         continue;
742       if (nwritten < 0)
743         return -1;
744       nleft -= nwritten;
745       buf = (const char*)buf + nwritten;
746     }
747   return 0;
748 }
749
750 /* Read up to BUFLEN bytes from FD and return the number of bytes
751    actually read in NREAD.  Returns -1 on error or 0 on success. */
752 static int
753 readn (int fd, void *buf, size_t buflen, size_t *nread)
754 {
755   size_t nleft = buflen;
756   int n;
757 /*   void *orig_buf = buf; */
758
759   while (nleft > 0)
760     {
761 #ifdef USE_NPTH
762 # ifdef HAVE_W32_SYSTEM
763 #  error Cannot use npth_read here because it expects a system HANDLE.
764 # endif
765       n = npth_read (fd, buf, nleft);
766 #else
767       n = read (fd, buf, nleft);
768 #endif
769       if (n < 0 && errno == EINTR)
770         continue;
771       if (n < 0)
772         return -1; /* read error. */
773       if (!n)
774         break; /* EOF */
775       nleft -= n;
776       buf = (char*)buf + n;
777     }
778   if (nread)
779     *nread = buflen - nleft;
780
781 /*   log_printhex ("  readn:", orig_buf, *nread); */
782
783   return 0;
784 }
785 #endif /*NEED_PCSC_WRAPPER*/
786
787 static const char *
788 pcsc_error_string (long err)
789 {
790   const char *s;
791
792   if (!err)
793     return "okay";
794   if ((err & 0x80100000) != 0x80100000)
795     return "invalid PC/SC error code";
796   err &= 0xffff;
797   switch (err)
798     {
799     case 0x0002: s = "cancelled"; break;
800     case 0x000e: s = "can't dispose"; break;
801     case 0x0008: s = "insufficient buffer"; break;
802     case 0x0015: s = "invalid ATR"; break;
803     case 0x0003: s = "invalid handle"; break;
804     case 0x0004: s = "invalid parameter"; break;
805     case 0x0005: s = "invalid target"; break;
806     case 0x0011: s = "invalid value"; break;
807     case 0x0006: s = "no memory"; break;
808     case 0x0013: s = "comm error"; break;
809     case 0x0001: s = "internal error"; break;
810     case 0x0014: s = "unknown error"; break;
811     case 0x0007: s = "waited too long"; break;
812     case 0x0009: s = "unknown reader"; break;
813     case 0x000a: s = "timeout"; break;
814     case 0x000b: s = "sharing violation"; break;
815     case 0x000c: s = "no smartcard"; break;
816     case 0x000d: s = "unknown card"; break;
817     case 0x000f: s = "proto mismatch"; break;
818     case 0x0010: s = "not ready"; break;
819     case 0x0012: s = "system cancelled"; break;
820     case 0x0016: s = "not transacted"; break;
821     case 0x0017: s = "reader unavailable"; break;
822     case 0x0065: s = "unsupported card"; break;
823     case 0x0066: s = "unresponsive card"; break;
824     case 0x0067: s = "unpowered card"; break;
825     case 0x0068: s = "reset card"; break;
826     case 0x0069: s = "removed card"; break;
827     case 0x006a: s = "inserted card"; break;
828     case 0x001f: s = "unsupported feature"; break;
829     case 0x0019: s = "PCI too small"; break;
830     case 0x001a: s = "reader unsupported"; break;
831     case 0x001b: s = "duplicate reader"; break;
832     case 0x001c: s = "card unsupported"; break;
833     case 0x001d: s = "no service"; break;
834     case 0x001e: s = "service stopped"; break;
835     default:     s = "unknown PC/SC error code"; break;
836     }
837   return s;
838 }
839
840 /* Map PC/SC error codes to our special host status words.  */
841 static int
842 pcsc_error_to_sw (long ec)
843 {
844   int rc;
845
846   switch ( PCSC_ERR_MASK (ec) )
847     {
848     case 0:  rc = 0; break;
849
850     case PCSC_E_CANCELLED:           rc = SW_HOST_ABORTED; break;
851     case PCSC_E_NO_MEMORY:           rc = SW_HOST_OUT_OF_CORE; break;
852     case PCSC_E_TIMEOUT:             rc = SW_HOST_CARD_IO_ERROR; break;
853     case PCSC_E_UNKNOWN_READER:      rc = SW_HOST_NO_READER; break;
854     case PCSC_E_SHARING_VIOLATION:   rc = SW_HOST_LOCKING_FAILED; break;
855     case PCSC_E_NO_SMARTCARD:        rc = SW_HOST_NO_CARD; break;
856     case PCSC_W_REMOVED_CARD:        rc = SW_HOST_NO_CARD; break;
857
858     case PCSC_E_INVALID_TARGET:
859     case PCSC_E_INVALID_VALUE:
860     case PCSC_E_INVALID_HANDLE:
861     case PCSC_E_INVALID_PARAMETER:
862     case PCSC_E_INSUFFICIENT_BUFFER: rc = SW_HOST_INV_VALUE; break;
863
864     default:  rc = SW_HOST_GENERAL_ERROR; break;
865     }
866
867   return rc;
868 }
869
870 static void
871 dump_pcsc_reader_status (int slot)
872 {
873   if (reader_table[slot].pcsc.card)
874     {
875       log_info ("reader slot %d: active protocol:", slot);
876       if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T0))
877         log_printf (" T0");
878       else if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
879         log_printf (" T1");
880       else if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_RAW))
881         log_printf (" raw");
882       log_printf ("\n");
883     }
884   else
885     log_info ("reader slot %d: not connected\n", slot);
886 }
887
888
889 #ifndef NEED_PCSC_WRAPPER
890 static int
891 pcsc_get_status_direct (int slot, unsigned int *status)
892 {
893   long err;
894   struct pcsc_readerstate_s rdrstates[1];
895
896   memset (rdrstates, 0, sizeof *rdrstates);
897   rdrstates[0].reader = reader_table[slot].rdrname;
898   rdrstates[0].current_state = PCSC_STATE_UNAWARE;
899   err = pcsc_get_status_change (reader_table[slot].pcsc.context,
900                                 0,
901                                 rdrstates, 1);
902   if (err == PCSC_E_TIMEOUT)
903     err = 0; /* Timeout is no error error here. */
904   if (err)
905     {
906       log_error ("pcsc_get_status_change failed: %s (0x%lx)\n",
907                  pcsc_error_string (err), err);
908       return pcsc_error_to_sw (err);
909     }
910
911   /*   log_debug  */
912   /*     ("pcsc_get_status_change: %s%s%s%s%s%s%s%s%s%s\n", */
913   /*      (rdrstates[0].event_state & PCSC_STATE_IGNORE)? " ignore":"", */
914   /*      (rdrstates[0].event_state & PCSC_STATE_CHANGED)? " changed":"", */
915   /*      (rdrstates[0].event_state & PCSC_STATE_UNKNOWN)? " unknown":"", */
916   /*      (rdrstates[0].event_state & PCSC_STATE_UNAVAILABLE)?" unavail":"", */
917   /*      (rdrstates[0].event_state & PCSC_STATE_EMPTY)? " empty":"", */
918   /*      (rdrstates[0].event_state & PCSC_STATE_PRESENT)? " present":"", */
919   /*      (rdrstates[0].event_state & PCSC_STATE_ATRMATCH)? " atr":"", */
920   /*      (rdrstates[0].event_state & PCSC_STATE_EXCLUSIVE)? " excl":"", */
921   /*      (rdrstates[0].event_state & PCSC_STATE_INUSE)? " unuse":"", */
922   /*      (rdrstates[0].event_state & PCSC_STATE_MUTE)? " mute":"" ); */
923
924   *status = 0;
925   if ( (rdrstates[0].event_state & PCSC_STATE_PRESENT) )
926     {
927       *status |= APDU_CARD_PRESENT;
928       if ( !(rdrstates[0].event_state & PCSC_STATE_MUTE) )
929         *status |= APDU_CARD_ACTIVE;
930     }
931 #ifndef HAVE_W32_SYSTEM
932   /* We indicate a useful card if it is not in use by another
933      application.  This is because we only use exclusive access
934      mode.  */
935   if ( (*status & (APDU_CARD_PRESENT|APDU_CARD_ACTIVE))
936        == (APDU_CARD_PRESENT|APDU_CARD_ACTIVE)
937        && !(rdrstates[0].event_state & PCSC_STATE_INUSE) )
938     *status |= APDU_CARD_USABLE;
939 #else
940   /* Some winscard drivers may set EXCLUSIVE and INUSE at the same
941      time when we are the only user (SCM SCR335) under Windows.  */
942   if ((*status & (APDU_CARD_PRESENT|APDU_CARD_ACTIVE))
943       == (APDU_CARD_PRESENT|APDU_CARD_ACTIVE))
944     *status |= APDU_CARD_USABLE;
945 #endif
946
947   return 0;
948 }
949 #endif /*!NEED_PCSC_WRAPPER*/
950
951
952 #ifdef NEED_PCSC_WRAPPER
953 static int
954 pcsc_get_status_wrapped (int slot, unsigned int *status)
955 {
956   long err;
957   reader_table_t slotp;
958   size_t len, full_len;
959   int i, n;
960   unsigned char msgbuf[9];
961   unsigned char buffer[16];
962   int sw = SW_HOST_CARD_IO_ERROR;
963
964   slotp = reader_table + slot;
965
966   if (slotp->pcsc.req_fd == -1
967       || slotp->pcsc.rsp_fd == -1
968       || slotp->pcsc.pid == (pid_t)(-1) )
969     {
970       log_error ("pcsc_get_status: pcsc-wrapper not running\n");
971       return sw;
972     }
973
974   msgbuf[0] = 0x04; /* STATUS command. */
975   len = 0;
976   msgbuf[1] = (len >> 24);
977   msgbuf[2] = (len >> 16);
978   msgbuf[3] = (len >>  8);
979   msgbuf[4] = (len      );
980   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
981     {
982       log_error ("error sending PC/SC STATUS request: %s\n",
983                  strerror (errno));
984       goto command_failed;
985     }
986
987   /* Read the response. */
988   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
989     {
990       log_error ("error receiving PC/SC STATUS response: %s\n",
991                  i? strerror (errno) : "premature EOF");
992       goto command_failed;
993     }
994   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
995   if (msgbuf[0] != 0x81 || len < 4)
996     {
997       log_error ("invalid response header from PC/SC received\n");
998       goto command_failed;
999     }
1000   len -= 4; /* Already read the error code. */
1001   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
1002                        | (msgbuf[7] << 8 ) | msgbuf[8]);
1003   if (err)
1004     {
1005       log_error ("pcsc_status failed: %s (0x%lx)\n",
1006                  pcsc_error_string (err), err);
1007       /* This is a proper error code, so return immediately.  */
1008       return pcsc_error_to_sw (err);
1009     }
1010
1011   full_len = len;
1012
1013   /* The current version returns 3 words but we allow also for old
1014      versions returning only 2 words. */
1015   n = 12 < len ? 12 : len;
1016   if ((i=readn (slotp->pcsc.rsp_fd, buffer, n, &len))
1017       || (len != 8 && len != 12))
1018     {
1019       log_error ("error receiving PC/SC STATUS response: %s\n",
1020                  i? strerror (errno) : "premature EOF");
1021       goto command_failed;
1022     }
1023
1024   slotp->is_t0 = (len == 12 && !!(buffer[11] & PCSC_PROTOCOL_T0));
1025
1026
1027   full_len -= len;
1028   /* Newer versions of the wrapper might send more status bytes.
1029      Read them. */
1030   while (full_len)
1031     {
1032       unsigned char dummybuf[128];
1033
1034       n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
1035       if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
1036         {
1037           log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1038                      i? strerror (errno) : "premature EOF");
1039           goto command_failed;
1040         }
1041       full_len -= n;
1042     }
1043
1044   /* We are lucky: The wrapper already returns the data in the
1045      required format. */
1046   *status = buffer[3];
1047   return 0;
1048
1049  command_failed:
1050   close (slotp->pcsc.req_fd);
1051   close (slotp->pcsc.rsp_fd);
1052   slotp->pcsc.req_fd = -1;
1053   slotp->pcsc.rsp_fd = -1;
1054   if (slotp->pcsc.pid != -1)
1055     kill (slotp->pcsc.pid, SIGTERM);
1056   slotp->pcsc.pid = (pid_t)(-1);
1057   slotp->used = 0;
1058   return sw;
1059 }
1060 #endif /*NEED_PCSC_WRAPPER*/
1061
1062
1063 static int
1064 pcsc_get_status (int slot, unsigned int *status)
1065 {
1066 #ifdef NEED_PCSC_WRAPPER
1067   return pcsc_get_status_wrapped (slot, status);
1068 #else
1069   return pcsc_get_status_direct (slot, status);
1070 #endif
1071 }
1072
1073
1074 #ifndef NEED_PCSC_WRAPPER
1075 static int
1076 pcsc_send_apdu_direct (int slot, unsigned char *apdu, size_t apdulen,
1077                        unsigned char *buffer, size_t *buflen,
1078                        pininfo_t *pininfo)
1079 {
1080   long err;
1081   struct pcsc_io_request_s send_pci;
1082   pcsc_dword_t recv_len;
1083
1084   if (!reader_table[slot].atrlen
1085       && (err = reset_pcsc_reader (slot)))
1086     return err;
1087
1088   if (DBG_CARD_IO)
1089     log_printhex ("  PCSC_data:", apdu, apdulen);
1090
1091   if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
1092       send_pci.protocol = PCSC_PROTOCOL_T1;
1093   else
1094       send_pci.protocol = PCSC_PROTOCOL_T0;
1095   send_pci.pci_len = sizeof send_pci;
1096   recv_len = *buflen;
1097   err = pcsc_transmit (reader_table[slot].pcsc.card,
1098                        &send_pci, apdu, apdulen,
1099                        NULL, buffer, &recv_len);
1100   *buflen = recv_len;
1101   if (err)
1102     log_error ("pcsc_transmit failed: %s (0x%lx)\n",
1103                pcsc_error_string (err), err);
1104
1105   return pcsc_error_to_sw (err);
1106 }
1107 #endif /*!NEED_PCSC_WRAPPER*/
1108
1109
1110 #ifdef NEED_PCSC_WRAPPER
1111 static int
1112 pcsc_send_apdu_wrapped (int slot, unsigned char *apdu, size_t apdulen,
1113                         unsigned char *buffer, size_t *buflen,
1114                         pininfo_t *pininfo)
1115 {
1116   long err;
1117   reader_table_t slotp;
1118   size_t len, full_len;
1119   int i, n;
1120   unsigned char msgbuf[9];
1121   int sw = SW_HOST_CARD_IO_ERROR;
1122
1123   (void)pininfo;
1124
1125   if (!reader_table[slot].atrlen
1126       && (err = reset_pcsc_reader (slot)))
1127     return err;
1128
1129   if (DBG_CARD_IO)
1130     log_printhex ("  PCSC_data:", apdu, apdulen);
1131
1132   slotp = reader_table + slot;
1133
1134   if (slotp->pcsc.req_fd == -1
1135       || slotp->pcsc.rsp_fd == -1
1136       || slotp->pcsc.pid == (pid_t)(-1) )
1137     {
1138       log_error ("pcsc_send_apdu: pcsc-wrapper not running\n");
1139       return sw;
1140     }
1141
1142   msgbuf[0] = 0x03; /* TRANSMIT command. */
1143   len = apdulen;
1144   msgbuf[1] = (len >> 24);
1145   msgbuf[2] = (len >> 16);
1146   msgbuf[3] = (len >>  8);
1147   msgbuf[4] = (len      );
1148   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
1149        || writen (slotp->pcsc.req_fd, apdu, len))
1150     {
1151       log_error ("error sending PC/SC TRANSMIT request: %s\n",
1152                  strerror (errno));
1153       goto command_failed;
1154     }
1155
1156   /* Read the response. */
1157   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1158     {
1159       log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1160                  i? strerror (errno) : "premature EOF");
1161       goto command_failed;
1162     }
1163   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1164   if (msgbuf[0] != 0x81 || len < 4)
1165     {
1166       log_error ("invalid response header from PC/SC received\n");
1167       goto command_failed;
1168     }
1169   len -= 4; /* Already read the error code. */
1170   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
1171                        | (msgbuf[7] << 8 ) | msgbuf[8]);
1172   if (err)
1173     {
1174       log_error ("pcsc_transmit failed: %s (0x%lx)\n",
1175                  pcsc_error_string (err), err);
1176       return pcsc_error_to_sw (err);
1177     }
1178
1179    full_len = len;
1180
1181    n = *buflen < len ? *buflen : len;
1182    if ((i=readn (slotp->pcsc.rsp_fd, buffer, n, &len)) || len != n)
1183      {
1184        log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1185                   i? strerror (errno) : "premature EOF");
1186        goto command_failed;
1187      }
1188    *buflen = n;
1189
1190    full_len -= len;
1191    if (full_len)
1192      {
1193        log_error ("pcsc_send_apdu: provided buffer too short - truncated\n");
1194        err = SW_HOST_INV_VALUE;
1195      }
1196    /* We need to read any rest of the response, to keep the
1197       protocol running.  */
1198    while (full_len)
1199      {
1200        unsigned char dummybuf[128];
1201
1202        n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
1203        if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
1204          {
1205            log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1206                       i? strerror (errno) : "premature EOF");
1207            goto command_failed;
1208          }
1209        full_len -= n;
1210      }
1211
1212    return err;
1213
1214  command_failed:
1215   close (slotp->pcsc.req_fd);
1216   close (slotp->pcsc.rsp_fd);
1217   slotp->pcsc.req_fd = -1;
1218   slotp->pcsc.rsp_fd = -1;
1219   if (slotp->pcsc.pid != -1)
1220     kill (slotp->pcsc.pid, SIGTERM);
1221   slotp->pcsc.pid = (pid_t)(-1);
1222   slotp->used = 0;
1223   return sw;
1224 }
1225 #endif /*NEED_PCSC_WRAPPER*/
1226
1227
1228 /* Send the APDU of length APDULEN to SLOT and return a maximum of
1229    *BUFLEN data in BUFFER, the actual returned size will be stored at
1230    BUFLEN.  Returns: A status word. */
1231 static int
1232 pcsc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
1233                 unsigned char *buffer, size_t *buflen,
1234                 pininfo_t *pininfo)
1235 {
1236 #ifdef NEED_PCSC_WRAPPER
1237   return pcsc_send_apdu_wrapped (slot, apdu, apdulen, buffer, buflen, pininfo);
1238 #else
1239   return pcsc_send_apdu_direct (slot, apdu, apdulen, buffer, buflen, pininfo);
1240 #endif
1241 }
1242
1243
1244 #ifndef NEED_PCSC_WRAPPER
1245 static int
1246 control_pcsc_direct (int slot, pcsc_dword_t ioctl_code,
1247                      const unsigned char *cntlbuf, size_t len,
1248                      unsigned char *buffer, pcsc_dword_t *buflen)
1249 {
1250   long err;
1251
1252   err = pcsc_control (reader_table[slot].pcsc.card, ioctl_code,
1253                       cntlbuf, len, buffer, *buflen, buflen);
1254   if (err)
1255     {
1256       log_error ("pcsc_control failed: %s (0x%lx)\n",
1257                  pcsc_error_string (err), err);
1258       return pcsc_error_to_sw (err);
1259     }
1260
1261   return 0;
1262 }
1263 #endif /*!NEED_PCSC_WRAPPER*/
1264
1265
1266 #ifdef NEED_PCSC_WRAPPER
1267 static int
1268 control_pcsc_wrapped (int slot, pcsc_dword_t ioctl_code,
1269                       const unsigned char *cntlbuf, size_t len,
1270                       unsigned char *buffer, pcsc_dword_t *buflen)
1271 {
1272   long err = PCSC_E_NOT_TRANSACTED;
1273   reader_table_t slotp;
1274   unsigned char msgbuf[9];
1275   int i, n;
1276   size_t full_len;
1277
1278   slotp = reader_table + slot;
1279
1280   msgbuf[0] = 0x06; /* CONTROL command. */
1281   msgbuf[1] = ((len + 4) >> 24);
1282   msgbuf[2] = ((len + 4) >> 16);
1283   msgbuf[3] = ((len + 4) >>  8);
1284   msgbuf[4] = ((len + 4)      );
1285   msgbuf[5] = (ioctl_code >> 24);
1286   msgbuf[6] = (ioctl_code >> 16);
1287   msgbuf[7] = (ioctl_code >>  8);
1288   msgbuf[8] = (ioctl_code      );
1289   if ( writen (slotp->pcsc.req_fd, msgbuf, 9)
1290        || writen (slotp->pcsc.req_fd, cntlbuf, len))
1291     {
1292       log_error ("error sending PC/SC CONTROL request: %s\n",
1293                  strerror (errno));
1294       goto command_failed;
1295     }
1296
1297   /* Read the response. */
1298   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1299     {
1300       log_error ("error receiving PC/SC CONTROL response: %s\n",
1301                  i? strerror (errno) : "premature EOF");
1302       goto command_failed;
1303     }
1304   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1305   if (msgbuf[0] != 0x81 || len < 4)
1306     {
1307       log_error ("invalid response header from PC/SC received\n");
1308       goto command_failed;
1309     }
1310   len -= 4; /* Already read the error code. */
1311   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
1312                        | (msgbuf[7] << 8 ) | msgbuf[8]);
1313   if (err)
1314     {
1315       log_error ("pcsc_control failed: %s (0x%lx)\n",
1316                  pcsc_error_string (err), err);
1317       return pcsc_error_to_sw (err);
1318     }
1319
1320   full_len = len;
1321
1322   n = *buflen < len ? *buflen : len;
1323   if ((i=readn (slotp->pcsc.rsp_fd, buffer, n, &len)) || len != n)
1324     {
1325       log_error ("error receiving PC/SC CONTROL response: %s\n",
1326                  i? strerror (errno) : "premature EOF");
1327       goto command_failed;
1328     }
1329   *buflen = n;
1330
1331   full_len -= len;
1332   if (full_len)
1333     {
1334       log_error ("pcsc_send_apdu: provided buffer too short - truncated\n");
1335       err = PCSC_E_INVALID_VALUE;
1336     }
1337   /* We need to read any rest of the response, to keep the
1338      protocol running.  */
1339   while (full_len)
1340     {
1341       unsigned char dummybuf[128];
1342
1343       n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
1344       if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
1345         {
1346           log_error ("error receiving PC/SC CONTROL response: %s\n",
1347                      i? strerror (errno) : "premature EOF");
1348           goto command_failed;
1349         }
1350       full_len -= n;
1351     }
1352
1353   if (!err)
1354     return 0;
1355
1356  command_failed:
1357   close (slotp->pcsc.req_fd);
1358   close (slotp->pcsc.rsp_fd);
1359   slotp->pcsc.req_fd = -1;
1360   slotp->pcsc.rsp_fd = -1;
1361   if (slotp->pcsc.pid != -1)
1362     kill (slotp->pcsc.pid, SIGTERM);
1363   slotp->pcsc.pid = (pid_t)(-1);
1364   slotp->used = 0;
1365   return pcsc_error_to_sw (err);
1366 }
1367 #endif /*NEED_PCSC_WRAPPER*/
1368
1369
1370
1371 /* Do some control with the value of IOCTL_CODE to the card inserted
1372    to SLOT.  Input buffer is specified by CNTLBUF of length LEN.
1373    Output buffer is specified by BUFFER of length *BUFLEN, and the
1374    actual output size will be stored at BUFLEN.  Returns: A status word.
1375    This routine is used for PIN pad input support.  */
1376 static int
1377 control_pcsc (int slot, pcsc_dword_t ioctl_code,
1378               const unsigned char *cntlbuf, size_t len,
1379               unsigned char *buffer, pcsc_dword_t *buflen)
1380 {
1381 #ifdef NEED_PCSC_WRAPPER
1382   return control_pcsc_wrapped (slot, ioctl_code, cntlbuf, len, buffer, buflen);
1383 #else
1384   return control_pcsc_direct (slot, ioctl_code, cntlbuf, len, buffer, buflen);
1385 #endif
1386 }
1387
1388
1389 #ifndef NEED_PCSC_WRAPPER
1390 static int
1391 close_pcsc_reader_direct (int slot)
1392 {
1393   pcsc_release_context (reader_table[slot].pcsc.context);
1394   xfree (reader_table[slot].rdrname);
1395   reader_table[slot].rdrname = NULL;
1396   reader_table[slot].used = 0;
1397   return 0;
1398 }
1399 #endif /*!NEED_PCSC_WRAPPER*/
1400
1401
1402 #ifdef NEED_PCSC_WRAPPER
1403 static int
1404 close_pcsc_reader_wrapped (int slot)
1405 {
1406   long err;
1407   reader_table_t slotp;
1408   size_t len;
1409   int i;
1410   unsigned char msgbuf[9];
1411
1412   slotp = reader_table + slot;
1413
1414   if (slotp->pcsc.req_fd == -1
1415       || slotp->pcsc.rsp_fd == -1
1416       || slotp->pcsc.pid == (pid_t)(-1) )
1417     {
1418       log_error ("close_pcsc_reader: pcsc-wrapper not running\n");
1419       return 0;
1420     }
1421
1422   msgbuf[0] = 0x02; /* CLOSE command. */
1423   len = 0;
1424   msgbuf[1] = (len >> 24);
1425   msgbuf[2] = (len >> 16);
1426   msgbuf[3] = (len >>  8);
1427   msgbuf[4] = (len      );
1428   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
1429     {
1430       log_error ("error sending PC/SC CLOSE request: %s\n",
1431                  strerror (errno));
1432       goto command_failed;
1433     }
1434
1435   /* Read the response. */
1436   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1437     {
1438       log_error ("error receiving PC/SC CLOSE response: %s\n",
1439                  i? strerror (errno) : "premature EOF");
1440       goto command_failed;
1441     }
1442   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1443   if (msgbuf[0] != 0x81 || len < 4)
1444     {
1445       log_error ("invalid response header from PC/SC received\n");
1446       goto command_failed;
1447     }
1448   len -= 4; /* Already read the error code. */
1449   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
1450                        | (msgbuf[7] << 8 ) | msgbuf[8]);
1451   if (err)
1452     log_error ("pcsc_close failed: %s (0x%lx)\n",
1453                pcsc_error_string (err), err);
1454
1455   /* We will close the wrapper in any case - errors are merely
1456      informational. */
1457
1458  command_failed:
1459   close (slotp->pcsc.req_fd);
1460   close (slotp->pcsc.rsp_fd);
1461   slotp->pcsc.req_fd = -1;
1462   slotp->pcsc.rsp_fd = -1;
1463   if (slotp->pcsc.pid != -1)
1464     kill (slotp->pcsc.pid, SIGTERM);
1465   slotp->pcsc.pid = (pid_t)(-1);
1466   slotp->used = 0;
1467   return 0;
1468 }
1469 #endif /*NEED_PCSC_WRAPPER*/
1470
1471
1472 static int
1473 close_pcsc_reader (int slot)
1474 {
1475 #ifdef NEED_PCSC_WRAPPER
1476   return close_pcsc_reader_wrapped (slot);
1477 #else
1478   return close_pcsc_reader_direct (slot);
1479 #endif
1480 }
1481
1482
1483 /* Connect a PC/SC card.  */
1484 #ifndef NEED_PCSC_WRAPPER
1485 static int
1486 connect_pcsc_card (int slot)
1487 {
1488   long err;
1489
1490   assert (slot >= 0 && slot < MAX_READER);
1491
1492   if (reader_table[slot].pcsc.card)
1493     return SW_HOST_ALREADY_CONNECTED;
1494
1495   reader_table[slot].atrlen = 0;
1496   reader_table[slot].last_status = 0;
1497   reader_table[slot].is_t0 = 0;
1498
1499   err = pcsc_connect (reader_table[slot].pcsc.context,
1500                       reader_table[slot].rdrname,
1501                       PCSC_SHARE_EXCLUSIVE,
1502                       PCSC_PROTOCOL_T0|PCSC_PROTOCOL_T1,
1503                       &reader_table[slot].pcsc.card,
1504                       &reader_table[slot].pcsc.protocol);
1505   if (err)
1506     {
1507       reader_table[slot].pcsc.card = 0;
1508       if (err != PCSC_E_NO_SMARTCARD)
1509         log_error ("pcsc_connect failed: %s (0x%lx)\n",
1510                    pcsc_error_string (err), err);
1511     }
1512   else
1513     {
1514       char reader[250];
1515       pcsc_dword_t readerlen, atrlen;
1516       long card_state, card_protocol;
1517
1518       pcsc_vendor_specific_init (slot);
1519
1520       atrlen = DIM (reader_table[0].atr);
1521       readerlen = sizeof reader -1 ;
1522       err = pcsc_status (reader_table[slot].pcsc.card,
1523                          reader, &readerlen,
1524                          &card_state, &card_protocol,
1525                          reader_table[slot].atr, &atrlen);
1526       if (err)
1527         log_error ("pcsc_status failed: %s (0x%lx) %lu\n",
1528                    pcsc_error_string (err), err, readerlen);
1529       else
1530         {
1531           if (atrlen > DIM (reader_table[0].atr))
1532             log_bug ("ATR returned by pcsc_status is too large\n");
1533           reader_table[slot].atrlen = atrlen;
1534           /* If we got to here we know that a card is present
1535              and usable.  Remember this.  */
1536           reader_table[slot].last_status = (   APDU_CARD_USABLE
1537                                              | APDU_CARD_PRESENT
1538                                              | APDU_CARD_ACTIVE);
1539           reader_table[slot].is_t0 = !!(card_protocol & PCSC_PROTOCOL_T0);
1540         }
1541     }
1542
1543   dump_reader_status (slot);
1544   return pcsc_error_to_sw (err);
1545 }
1546 #endif /*!NEED_PCSC_WRAPPER*/
1547
1548
1549 /* Disconnect a PC/SC card.  Note that this succeeds even if the card
1550    is not connected.  */
1551 #ifndef NEED_PCSC_WRAPPER
1552 static int
1553 disconnect_pcsc_card (int slot)
1554 {
1555   long err;
1556
1557   assert (slot >= 0 && slot < MAX_READER);
1558
1559   if (!reader_table[slot].pcsc.card)
1560     return 0;
1561
1562   err = pcsc_disconnect (reader_table[slot].pcsc.card, PCSC_LEAVE_CARD);
1563   if (err)
1564     {
1565       log_error ("pcsc_disconnect failed: %s (0x%lx)\n",
1566                  pcsc_error_string (err), err);
1567       return SW_HOST_CARD_IO_ERROR;
1568     }
1569   reader_table[slot].pcsc.card = 0;
1570   return 0;
1571 }
1572 #endif /*!NEED_PCSC_WRAPPER*/
1573
1574
1575 #ifndef NEED_PCSC_WRAPPER
1576 static int
1577 reset_pcsc_reader_direct (int slot)
1578 {
1579   int sw;
1580
1581   sw = disconnect_pcsc_card (slot);
1582   if (!sw)
1583     sw = connect_pcsc_card (slot);
1584
1585   return sw;
1586 }
1587 #endif /*NEED_PCSC_WRAPPER*/
1588
1589
1590 #ifdef NEED_PCSC_WRAPPER
1591 static int
1592 reset_pcsc_reader_wrapped (int slot)
1593 {
1594   long err;
1595   reader_table_t slotp;
1596   size_t len;
1597   int i, n;
1598   unsigned char msgbuf[9];
1599   unsigned int dummy_status;
1600   int sw = SW_HOST_CARD_IO_ERROR;
1601
1602   slotp = reader_table + slot;
1603
1604   if (slotp->pcsc.req_fd == -1
1605       || slotp->pcsc.rsp_fd == -1
1606       || slotp->pcsc.pid == (pid_t)(-1) )
1607     {
1608       log_error ("pcsc_get_status: pcsc-wrapper not running\n");
1609       return sw;
1610     }
1611
1612   msgbuf[0] = 0x05; /* RESET command. */
1613   len = 0;
1614   msgbuf[1] = (len >> 24);
1615   msgbuf[2] = (len >> 16);
1616   msgbuf[3] = (len >>  8);
1617   msgbuf[4] = (len      );
1618   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
1619     {
1620       log_error ("error sending PC/SC RESET request: %s\n",
1621                  strerror (errno));
1622       goto command_failed;
1623     }
1624
1625   /* Read the response. */
1626   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1627     {
1628       log_error ("error receiving PC/SC RESET response: %s\n",
1629                  i? strerror (errno) : "premature EOF");
1630       goto command_failed;
1631     }
1632   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1633   if (msgbuf[0] != 0x81 || len < 4)
1634     {
1635       log_error ("invalid response header from PC/SC received\n");
1636       goto command_failed;
1637     }
1638   len -= 4; /* Already read the error code. */
1639   if (len > DIM (slotp->atr))
1640     {
1641       log_error ("PC/SC returned a too large ATR (len=%lx)\n",
1642                  (unsigned long)len);
1643       sw = SW_HOST_GENERAL_ERROR;
1644       goto command_failed;
1645     }
1646   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
1647                        | (msgbuf[7] << 8 ) | msgbuf[8]);
1648   if (err)
1649     {
1650       log_error ("PC/SC RESET failed: %s (0x%lx)\n",
1651                  pcsc_error_string (err), err);
1652       /* If the error code is no smart card, we should not considere
1653          this a major error and close the wrapper.  */
1654       sw = pcsc_error_to_sw (err);
1655       if (err == PCSC_E_NO_SMARTCARD)
1656         return sw;
1657       goto command_failed;
1658     }
1659
1660   /* The open function may return a zero for the ATR length to
1661      indicate that no card is present.  */
1662   n = len;
1663   if (n)
1664     {
1665       if ((i=readn (slotp->pcsc.rsp_fd, slotp->atr, n, &len)) || len != n)
1666         {
1667           log_error ("error receiving PC/SC RESET response: %s\n",
1668                      i? strerror (errno) : "premature EOF");
1669           goto command_failed;
1670         }
1671     }
1672   slotp->atrlen = len;
1673
1674   /* Read the status so that IS_T0 will be set. */
1675   pcsc_get_status (slot, &dummy_status);
1676
1677   return 0;
1678
1679  command_failed:
1680   close (slotp->pcsc.req_fd);
1681   close (slotp->pcsc.rsp_fd);
1682   slotp->pcsc.req_fd = -1;
1683   slotp->pcsc.rsp_fd = -1;
1684   if (slotp->pcsc.pid != -1)
1685     kill (slotp->pcsc.pid, SIGTERM);
1686   slotp->pcsc.pid = (pid_t)(-1);
1687   slotp->used = 0;
1688   return sw;
1689 }
1690 #endif /* !NEED_PCSC_WRAPPER */
1691
1692
1693 /* Send an PC/SC reset command and return a status word on error or 0
1694    on success. */
1695 static int
1696 reset_pcsc_reader (int slot)
1697 {
1698 #ifdef NEED_PCSC_WRAPPER
1699   return reset_pcsc_reader_wrapped (slot);
1700 #else
1701   return reset_pcsc_reader_direct (slot);
1702 #endif
1703 }
1704
1705
1706 /* Examine reader specific parameters and initialize.  This is mostly
1707    for pinpad input.  Called at opening the connection to the reader.  */
1708 static int
1709 pcsc_vendor_specific_init (int slot)
1710 {
1711   unsigned char buf[256];
1712   pcsc_dword_t len;
1713   int sw;
1714   int vendor = 0;
1715   int product = 0;
1716   pcsc_dword_t get_tlv_ioctl = (pcsc_dword_t)-1;
1717   unsigned char *p;
1718
1719   len = sizeof (buf);
1720   sw = control_pcsc (slot, CM_IOCTL_GET_FEATURE_REQUEST, NULL, 0, buf, &len);
1721   if (sw)
1722     {
1723       log_error ("pcsc_vendor_specific_init: GET_FEATURE_REQUEST failed: %d\n",
1724                  sw);
1725       return SW_NOT_SUPPORTED;
1726     }
1727   else
1728     {
1729       p = buf;
1730       while (p < buf + len)
1731         {
1732           unsigned char code = *p++;
1733           int l = *p++;
1734           unsigned int v = 0;
1735
1736           if (l == 1)
1737             v = p[0];
1738           else if (l == 2)
1739             v = ((p[0] << 8) | p[1]);
1740           else if (l == 4)
1741             v = ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
1742
1743           if (code == FEATURE_VERIFY_PIN_DIRECT)
1744             reader_table[slot].pcsc.verify_ioctl = v;
1745           else if (code == FEATURE_MODIFY_PIN_DIRECT)
1746             reader_table[slot].pcsc.modify_ioctl = v;
1747           else if (code == FEATURE_GET_TLV_PROPERTIES)
1748             get_tlv_ioctl = v;
1749
1750           if (DBG_CARD_IO)
1751             log_debug ("feature: code=%02X, len=%d, v=%02X\n", code, l, v);
1752
1753           p += l;
1754         }
1755     }
1756
1757   if (get_tlv_ioctl == (pcsc_dword_t)-1)
1758     {
1759       /*
1760        * For system which doesn't support GET_TLV_PROPERTIES,
1761        * we put some heuristics here.
1762        */
1763       if (reader_table[slot].rdrname)
1764         {
1765           if (strstr (reader_table[slot].rdrname, "SPRx32"))
1766             {
1767               reader_table[slot].is_spr532 = 1;
1768               reader_table[slot].pinpad_varlen_supported = 1;
1769             }
1770           else if (strstr (reader_table[slot].rdrname, "ST-2xxx")
1771                    || strstr (reader_table[slot].rdrname, "cyberJack")
1772                    || strstr (reader_table[slot].rdrname, "DIGIPASS")
1773                    || strstr (reader_table[slot].rdrname, "Gnuk")
1774                    || strstr (reader_table[slot].rdrname, "KAAN"))
1775             reader_table[slot].pinpad_varlen_supported = 1;
1776         }
1777
1778       return 0;
1779     }
1780
1781   len = sizeof (buf);
1782   sw = control_pcsc (slot, get_tlv_ioctl, NULL, 0, buf, &len);
1783   if (sw)
1784     {
1785       log_error ("pcsc_vendor_specific_init: GET_TLV_IOCTL failed: %d\n", sw);
1786       return SW_NOT_SUPPORTED;
1787     }
1788
1789   p = buf;
1790   while (p < buf + len)
1791     {
1792       unsigned char tag = *p++;
1793       int l = *p++;
1794       unsigned int v = 0;
1795
1796       /* Umm... here is little endian, while the encoding above is big.  */
1797       if (l == 1)
1798         v = p[0];
1799       else if (l == 2)
1800         v = ((p[1] << 8) | p[0]);
1801       else if (l == 4)
1802         v = ((p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]);
1803
1804       if (tag == PCSCv2_PART10_PROPERTY_bMinPINSize)
1805         reader_table[slot].pcsc.pinmin = v;
1806       else if (tag == PCSCv2_PART10_PROPERTY_bMaxPINSize)
1807         reader_table[slot].pcsc.pinmax = v;
1808       else if (tag == PCSCv2_PART10_PROPERTY_wIdVendor)
1809         vendor = v;
1810       else if (tag == PCSCv2_PART10_PROPERTY_wIdProduct)
1811         product = v;
1812
1813       if (DBG_CARD_IO)
1814         log_debug ("TLV properties: tag=%02X, len=%d, v=%08X\n", tag, l, v);
1815
1816       p += l;
1817     }
1818
1819   if (vendor == VENDOR_VEGA && product == VEGA_ALPHA)
1820     {
1821       /*
1822        * Please read the comment of ccid_vendor_specific_init in
1823        * ccid-driver.c.
1824        */
1825       const unsigned char cmd[] = { '\xb5', '\x01', '\x00', '\x03', '\x00' };
1826       sw = control_pcsc (slot, CM_IOCTL_VENDOR_IFD_EXCHANGE,
1827                          cmd, sizeof (cmd), NULL, 0);
1828       if (sw)
1829         return SW_NOT_SUPPORTED;
1830     }
1831   else if (vendor == VENDOR_SCM && product == SCM_SPR532) /* SCM SPR532 */
1832     {
1833       reader_table[slot].is_spr532 = 1;
1834       reader_table[slot].pinpad_varlen_supported = 1;
1835     }
1836   else if (vendor == 0x046a && product == 0x003e  /* Cherry ST-2xxx */
1837            || vendor == 0x0c4b /* Tested with Reiner cyberJack GO */
1838            || vendor == 0x1a44 /* Tested with Vasco DIGIPASS 920 */
1839            || vendor == 0x234b /* Tested with FSIJ Gnuk Token */
1840            || vendor == 0x0d46 /* Tested with KAAN Advanced??? */)
1841     reader_table[slot].pinpad_varlen_supported = 1;
1842
1843   return 0;
1844 }
1845
1846
1847 /* Open the PC/SC reader without using the wrapper.  Returns -1 on
1848    error or a slot number for the reader.  */
1849 #ifndef NEED_PCSC_WRAPPER
1850 static int
1851 open_pcsc_reader_direct (const char *portstr)
1852 {
1853   long err;
1854   int slot;
1855   char *list = NULL;
1856   pcsc_dword_t nreader, listlen;
1857   char *p;
1858
1859   slot = new_reader_slot ();
1860   if (slot == -1)
1861     return -1;
1862
1863   /* Fixme: Allocating a context for each slot is not required.  One
1864      global context should be sufficient.  */
1865   err = pcsc_establish_context (PCSC_SCOPE_SYSTEM, NULL, NULL,
1866                                 &reader_table[slot].pcsc.context);
1867   if (err)
1868     {
1869       log_error ("pcsc_establish_context failed: %s (0x%lx)\n",
1870                  pcsc_error_string (err), err);
1871       reader_table[slot].used = 0;
1872       return -1;
1873     }
1874
1875   err = pcsc_list_readers (reader_table[slot].pcsc.context,
1876                            NULL, NULL, &nreader);
1877   if (!err)
1878     {
1879       list = xtrymalloc (nreader+1); /* Better add 1 for safety reasons. */
1880       if (!list)
1881         {
1882           log_error ("error allocating memory for reader list\n");
1883           pcsc_release_context (reader_table[slot].pcsc.context);
1884           reader_table[slot].used = 0;
1885           return -1 /*SW_HOST_OUT_OF_CORE*/;
1886         }
1887       err = pcsc_list_readers (reader_table[slot].pcsc.context,
1888                                NULL, list, &nreader);
1889     }
1890   if (err)
1891     {
1892       log_error ("pcsc_list_readers failed: %s (0x%lx)\n",
1893                  pcsc_error_string (err), err);
1894       pcsc_release_context (reader_table[slot].pcsc.context);
1895       reader_table[slot].used = 0;
1896       xfree (list);
1897       return -1;
1898     }
1899
1900   listlen = nreader;
1901   p = list;
1902   while (nreader)
1903     {
1904       if (!*p && !p[1])
1905         break;
1906       if (*p)
1907         log_info ("detected reader '%s'\n", p);
1908       if (nreader < (strlen (p)+1))
1909         {
1910           log_error ("invalid response from pcsc_list_readers\n");
1911           break;
1912         }
1913       nreader -= strlen (p)+1;
1914       p += strlen (p) + 1;
1915     }
1916
1917   reader_table[slot].rdrname = xtrymalloc (strlen (portstr? portstr : list)+1);
1918   if (!reader_table[slot].rdrname)
1919     {
1920       log_error ("error allocating memory for reader name\n");
1921       pcsc_release_context (reader_table[slot].pcsc.context);
1922       reader_table[slot].used = 0;
1923       return -1;
1924     }
1925   strcpy (reader_table[slot].rdrname, portstr? portstr : list);
1926   xfree (list);
1927   list = NULL;
1928
1929   reader_table[slot].pcsc.card = 0;
1930   reader_table[slot].atrlen = 0;
1931   reader_table[slot].last_status = 0;
1932
1933   reader_table[slot].connect_card = connect_pcsc_card;
1934   reader_table[slot].disconnect_card = disconnect_pcsc_card;
1935   reader_table[slot].close_reader = close_pcsc_reader;
1936   reader_table[slot].reset_reader = reset_pcsc_reader;
1937   reader_table[slot].get_status_reader = pcsc_get_status;
1938   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
1939   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
1940
1941   dump_reader_status (slot);
1942   return slot;
1943 }
1944 #endif /*!NEED_PCSC_WRAPPER */
1945
1946
1947 /* Open the PC/SC reader using the pcsc_wrapper program.  This is
1948    needed to cope with different thread models and other peculiarities
1949    of libpcsclite. */
1950 #ifdef NEED_PCSC_WRAPPER
1951 static int
1952 open_pcsc_reader_wrapped (const char *portstr)
1953 {
1954   int slot;
1955   reader_table_t slotp;
1956   int fd, rp[2], wp[2];
1957   int n, i;
1958   pid_t pid;
1959   size_t len;
1960   unsigned char msgbuf[9];
1961   int err;
1962   unsigned int dummy_status;
1963
1964   /* Note that we use the constant and not the fucntion because this
1965      code won't be be used under Windows.  */
1966   const char *wrapperpgm = GNUPG_LIBEXECDIR "/gnupg-pcsc-wrapper";
1967
1968   if (access (wrapperpgm, X_OK))
1969     {
1970       log_error ("can't run PC/SC access module '%s': %s\n",
1971                  wrapperpgm, strerror (errno));
1972       return -1;
1973     }
1974
1975   slot = new_reader_slot ();
1976   if (slot == -1)
1977     return -1;
1978   slotp = reader_table + slot;
1979
1980   /* Fire up the PC/SCc wrapper.  We don't use any fork/exec code from
1981      the common directy but implement it directly so that this file
1982      may still be source copied. */
1983
1984   if (pipe (rp) == -1)
1985     {
1986       log_error ("error creating a pipe: %s\n", strerror (errno));
1987       slotp->used = 0;
1988       return -1;
1989     }
1990   if (pipe (wp) == -1)
1991     {
1992       log_error ("error creating a pipe: %s\n", strerror (errno));
1993       close (rp[0]);
1994       close (rp[1]);
1995       slotp->used = 0;
1996       return -1;
1997     }
1998
1999   pid = fork ();
2000   if (pid == -1)
2001     {
2002       log_error ("error forking process: %s\n", strerror (errno));
2003       close (rp[0]);
2004       close (rp[1]);
2005       close (wp[0]);
2006       close (wp[1]);
2007       slotp->used = 0;
2008       return -1;
2009     }
2010   slotp->pcsc.pid = pid;
2011
2012   if (!pid)
2013     { /*
2014          === Child ===
2015        */
2016
2017       /* Double fork. */
2018       pid = fork ();
2019       if (pid == -1)
2020         _exit (31);
2021       if (pid)
2022         _exit (0); /* Immediate exit this parent, so that the child
2023                       gets cleaned up by the init process. */
2024
2025       /* Connect our pipes. */
2026       if (wp[0] != 0 && dup2 (wp[0], 0) == -1)
2027         log_fatal ("dup2 stdin failed: %s\n", strerror (errno));
2028       if (rp[1] != 1 && dup2 (rp[1], 1) == -1)
2029         log_fatal ("dup2 stdout failed: %s\n", strerror (errno));
2030
2031       /* Send stderr to the bit bucket. */
2032       fd = open ("/dev/null", O_WRONLY);
2033       if (fd == -1)
2034         log_fatal ("can't open '/dev/null': %s", strerror (errno));
2035       if (fd != 2 && dup2 (fd, 2) == -1)
2036         log_fatal ("dup2 stderr failed: %s\n", strerror (errno));
2037
2038       /* Close all other files. */
2039       close_all_fds (3, NULL);
2040
2041       execl (wrapperpgm,
2042              "pcsc-wrapper",
2043              "--",
2044              "1", /* API version */
2045              opt.pcsc_driver, /* Name of the PC/SC library. */
2046               NULL);
2047       _exit (31);
2048     }
2049
2050   /*
2051      === Parent ===
2052    */
2053   close (wp[0]);
2054   close (rp[1]);
2055   slotp->pcsc.req_fd = wp[1];
2056   slotp->pcsc.rsp_fd = rp[0];
2057
2058   /* Wait for the intermediate child to terminate. */
2059 #ifdef USE_NPTH
2060 #define WAIT npth_waitpid
2061 #else
2062 #define WAIT waitpid
2063 #endif
2064   while ( (i=WAIT (pid, NULL, 0)) == -1 && errno == EINTR)
2065     ;
2066 #undef WAIT
2067
2068   /* Now send the open request. */
2069   msgbuf[0] = 0x01; /* OPEN command. */
2070   len = portstr? strlen (portstr):0;
2071   msgbuf[1] = (len >> 24);
2072   msgbuf[2] = (len >> 16);
2073   msgbuf[3] = (len >>  8);
2074   msgbuf[4] = (len      );
2075   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
2076        || (portstr && writen (slotp->pcsc.req_fd, portstr, len)))
2077     {
2078       log_error ("error sending PC/SC OPEN request: %s\n",
2079                  strerror (errno));
2080       goto command_failed;
2081     }
2082   /* Read the response. */
2083   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
2084     {
2085       log_error ("error receiving PC/SC OPEN response: %s\n",
2086                  i? strerror (errno) : "premature EOF");
2087       goto command_failed;
2088     }
2089   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
2090   if (msgbuf[0] != 0x81 || len < 4)
2091     {
2092       log_error ("invalid response header from PC/SC received\n");
2093       goto command_failed;
2094     }
2095   len -= 4; /* Already read the error code. */
2096   if (len > DIM (slotp->atr))
2097     {
2098       log_error ("PC/SC returned a too large ATR (len=%lx)\n",
2099                  (unsigned long)len);
2100       goto command_failed;
2101     }
2102   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
2103                        | (msgbuf[7] << 8 ) | msgbuf[8]);
2104
2105   if (err)
2106     {
2107       log_error ("PC/SC OPEN failed: %s\n", pcsc_error_string (err));
2108       goto command_failed;
2109     }
2110
2111   slotp->last_status = 0;
2112
2113   /* The open request may return a zero for the ATR length to
2114      indicate that no card is present.  */
2115   n = len;
2116   if (n)
2117     {
2118       if ((i=readn (slotp->pcsc.rsp_fd, slotp->atr, n, &len)) || len != n)
2119         {
2120           log_error ("error receiving PC/SC OPEN response: %s\n",
2121                      i? strerror (errno) : "premature EOF");
2122           goto command_failed;
2123         }
2124       /* If we got to here we know that a card is present
2125          and usable.  Thus remember this.  */
2126       slotp->last_status = (  APDU_CARD_USABLE
2127                             | APDU_CARD_PRESENT
2128                             | APDU_CARD_ACTIVE);
2129     }
2130   slotp->atrlen = len;
2131
2132   reader_table[slot].close_reader = close_pcsc_reader;
2133   reader_table[slot].reset_reader = reset_pcsc_reader;
2134   reader_table[slot].get_status_reader = pcsc_get_status;
2135   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
2136   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
2137
2138   pcsc_vendor_specific_init (slot);
2139
2140   /* Read the status so that IS_T0 will be set. */
2141   pcsc_get_status (slot, &dummy_status);
2142
2143   dump_reader_status (slot);
2144   return slot;
2145
2146  command_failed:
2147   close (slotp->pcsc.req_fd);
2148   close (slotp->pcsc.rsp_fd);
2149   slotp->pcsc.req_fd = -1;
2150   slotp->pcsc.rsp_fd = -1;
2151   if (slotp->pcsc.pid != -1)
2152     kill (slotp->pcsc.pid, SIGTERM);
2153   slotp->pcsc.pid = (pid_t)(-1);
2154   slotp->used = 0;
2155   /* There is no way to return SW. */
2156   return -1;
2157
2158 }
2159 #endif /*NEED_PCSC_WRAPPER*/
2160
2161
2162 static int
2163 open_pcsc_reader (const char *portstr)
2164 {
2165 #ifdef NEED_PCSC_WRAPPER
2166   return open_pcsc_reader_wrapped (portstr);
2167 #else
2168   return open_pcsc_reader_direct (portstr);
2169 #endif
2170 }
2171
2172
2173 /* Check whether the reader supports the ISO command code COMMAND
2174    on the pinpad.  Return 0 on success.  */
2175 static int
2176 check_pcsc_pinpad (int slot, int command, pininfo_t *pininfo)
2177 {
2178   int r;
2179
2180   if (reader_table[slot].pcsc.pinmin >= 0)
2181     pininfo->minlen = reader_table[slot].pcsc.pinmin;
2182
2183   if (reader_table[slot].pcsc.pinmax >= 0)
2184     pininfo->maxlen = reader_table[slot].pcsc.pinmax;
2185
2186   if ((command == ISO7816_VERIFY && reader_table[slot].pcsc.verify_ioctl != 0)
2187       || (command == ISO7816_CHANGE_REFERENCE_DATA
2188           && reader_table[slot].pcsc.modify_ioctl != 0))
2189     r = 0;                       /* Success */
2190   else
2191     r = SW_NOT_SUPPORTED;
2192
2193   if (DBG_CARD_IO)
2194     log_debug ("check_pcsc_pinpad: command=%02X, r=%d\n",
2195                (unsigned int)command, r);
2196
2197   if (reader_table[slot].pinpad_varlen_supported)
2198     pininfo->fixedlen = 0;
2199
2200   return r;
2201 }
2202
2203 #define PIN_VERIFY_STRUCTURE_SIZE 24
2204 static int
2205 pcsc_pinpad_verify (int slot, int class, int ins, int p0, int p1,
2206                     pininfo_t *pininfo)
2207 {
2208   int sw;
2209   unsigned char *pin_verify;
2210   int len = PIN_VERIFY_STRUCTURE_SIZE + pininfo->fixedlen;
2211   unsigned char result[2];
2212   pcsc_dword_t resultlen = 2;
2213   int no_lc;
2214
2215   if (!reader_table[slot].atrlen
2216       && (sw = reset_pcsc_reader (slot)))
2217     return sw;
2218
2219   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2220     return SW_NOT_SUPPORTED;
2221
2222   if (!pininfo->minlen)
2223     pininfo->minlen = 1;
2224   if (!pininfo->maxlen)
2225     pininfo->maxlen = 15;
2226
2227   pin_verify = xtrymalloc (len);
2228   if (!pin_verify)
2229     return SW_HOST_OUT_OF_CORE;
2230
2231   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2232
2233   pin_verify[0] = 0x00; /* bTimeOut */
2234   pin_verify[1] = 0x00; /* bTimeOut2 */
2235   pin_verify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2236   pin_verify[3] = pininfo->fixedlen; /* bmPINBlockString */
2237   pin_verify[4] = 0x00; /* bmPINLengthFormat */
2238   pin_verify[5] = pininfo->maxlen; /* wPINMaxExtraDigit */
2239   pin_verify[6] = pininfo->minlen; /* wPINMaxExtraDigit */
2240   pin_verify[7] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2241   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2242     pin_verify[7] |= 0x01; /* Max size reached.  */
2243   pin_verify[8] = 0x01; /* bNumberMessage: One message */
2244   pin_verify[9] =  0x09; /* wLangId: 0x0409: US English */
2245   pin_verify[10] = 0x04; /* wLangId: 0x0409: US English */
2246   pin_verify[11] = 0x00; /* bMsgIndex */
2247   pin_verify[12] = 0x00; /* bTeoPrologue[0] */
2248   pin_verify[13] = 0x00; /* bTeoPrologue[1] */
2249   pin_verify[14] = pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2250   pin_verify[15] = pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2251   pin_verify[16] = 0x00; /* ulDataLength */
2252   pin_verify[17] = 0x00; /* ulDataLength */
2253   pin_verify[18] = 0x00; /* ulDataLength */
2254   pin_verify[19] = class; /* abData[0] */
2255   pin_verify[20] = ins; /* abData[1] */
2256   pin_verify[21] = p0; /* abData[2] */
2257   pin_verify[22] = p1; /* abData[3] */
2258   pin_verify[23] = pininfo->fixedlen; /* abData[4] */
2259   if (pininfo->fixedlen)
2260     memset (&pin_verify[24], 0xff, pininfo->fixedlen);
2261   else if (no_lc)
2262     len--;
2263
2264   if (DBG_CARD_IO)
2265     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2266                class, ins, p0, p1, len, pininfo->maxlen);
2267
2268   sw = control_pcsc (slot, reader_table[slot].pcsc.verify_ioctl,
2269                      pin_verify, len, result, &resultlen);
2270   xfree (pin_verify);
2271   if (sw || resultlen < 2)
2272     return sw? sw : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2273   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2274     {
2275       log_error ("control_pcsc failed: %d\n", sw);
2276       return sw? sw: SW_HOST_INCOMPLETE_CARD_RESPONSE;
2277     }
2278   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2279   if (DBG_CARD_IO)
2280     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2281   return sw;
2282 }
2283
2284
2285 #define PIN_MODIFY_STRUCTURE_SIZE 29
2286 static int
2287 pcsc_pinpad_modify (int slot, int class, int ins, int p0, int p1,
2288                     pininfo_t *pininfo)
2289 {
2290   int sw;
2291   unsigned char *pin_modify;
2292   int len = PIN_MODIFY_STRUCTURE_SIZE + 2 * pininfo->fixedlen;
2293   unsigned char result[2];
2294   pcsc_dword_t resultlen = 2;
2295   int no_lc;
2296
2297   if (!reader_table[slot].atrlen
2298       && (sw = reset_pcsc_reader (slot)))
2299     return sw;
2300
2301   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2302     return SW_NOT_SUPPORTED;
2303
2304   if (!pininfo->minlen)
2305     pininfo->minlen = 1;
2306   if (!pininfo->maxlen)
2307     pininfo->maxlen = 15;
2308
2309   pin_modify = xtrymalloc (len);
2310   if (!pin_modify)
2311     return SW_HOST_OUT_OF_CORE;
2312
2313   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2314
2315   pin_modify[0] = 0x00; /* bTimeOut */
2316   pin_modify[1] = 0x00; /* bTimeOut2 */
2317   pin_modify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2318   pin_modify[3] = pininfo->fixedlen; /* bmPINBlockString */
2319   pin_modify[4] = 0x00; /* bmPINLengthFormat */
2320   pin_modify[5] = 0x00; /* bInsertionOffsetOld */
2321   pin_modify[6] = pininfo->fixedlen; /* bInsertionOffsetNew */
2322   pin_modify[7] = pininfo->maxlen; /* wPINMaxExtraDigit */
2323   pin_modify[8] = pininfo->minlen; /* wPINMaxExtraDigit */
2324   pin_modify[9] = (p0 == 0 ? 0x03 : 0x01);
2325                   /* bConfirmPIN
2326                    *    0x00: new PIN once
2327                    *    0x01: new PIN twice (confirmation)
2328                    *    0x02: old PIN and new PIN once
2329                    *    0x03: old PIN and new PIN twice (confirmation)
2330                    */
2331   pin_modify[10] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2332   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2333     pin_modify[10] |= 0x01; /* Max size reached.  */
2334   pin_modify[11] = 0x03; /* bNumberMessage: Three messages */
2335   pin_modify[12] = 0x09; /* wLangId: 0x0409: US English */
2336   pin_modify[13] = 0x04; /* wLangId: 0x0409: US English */
2337   pin_modify[14] = 0x00; /* bMsgIndex1 */
2338   pin_modify[15] = 0x01; /* bMsgIndex2 */
2339   pin_modify[16] = 0x02; /* bMsgIndex3 */
2340   pin_modify[17] = 0x00; /* bTeoPrologue[0] */
2341   pin_modify[18] = 0x00; /* bTeoPrologue[1] */
2342   pin_modify[19] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2343   pin_modify[20] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2344   pin_modify[21] = 0x00; /* ulDataLength */
2345   pin_modify[22] = 0x00; /* ulDataLength */
2346   pin_modify[23] = 0x00; /* ulDataLength */
2347   pin_modify[24] = class; /* abData[0] */
2348   pin_modify[25] = ins; /* abData[1] */
2349   pin_modify[26] = p0; /* abData[2] */
2350   pin_modify[27] = p1; /* abData[3] */
2351   pin_modify[28] = 2 * pininfo->fixedlen; /* abData[4] */
2352   if (pininfo->fixedlen)
2353     memset (&pin_modify[29], 0xff, 2 * pininfo->fixedlen);
2354   else if (no_lc)
2355     len--;
2356
2357   if (DBG_CARD_IO)
2358     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2359                class, ins, p0, p1, len, (int)pininfo->maxlen);
2360
2361   sw = control_pcsc (slot, reader_table[slot].pcsc.modify_ioctl,
2362                      pin_modify, len, result, &resultlen);
2363   xfree (pin_modify);
2364   if (sw || resultlen < 2)
2365     {
2366       log_error ("control_pcsc failed: %d\n", sw);
2367       return sw? sw : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2368     }
2369   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2370   if (DBG_CARD_IO)
2371     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2372   return sw;
2373 }
2374 \f
2375 #ifdef HAVE_LIBUSB
2376 /*
2377      Internal CCID driver interface.
2378  */
2379
2380
2381 static void
2382 dump_ccid_reader_status (int slot)
2383 {
2384   log_info ("reader slot %d: using ccid driver\n", slot);
2385 }
2386
2387 static int
2388 close_ccid_reader (int slot)
2389 {
2390   ccid_close_reader (reader_table[slot].ccid.handle);
2391   reader_table[slot].used = 0;
2392   return 0;
2393 }
2394
2395
2396 static int
2397 shutdown_ccid_reader (int slot)
2398 {
2399   ccid_shutdown_reader (reader_table[slot].ccid.handle);
2400   return 0;
2401 }
2402
2403
2404 static int
2405 reset_ccid_reader (int slot)
2406 {
2407   int err;
2408   reader_table_t slotp = reader_table + slot;
2409   unsigned char atr[33];
2410   size_t atrlen;
2411
2412   err = ccid_get_atr (slotp->ccid.handle, atr, sizeof atr, &atrlen);
2413   if (err)
2414     return err;
2415   /* If the reset was successful, update the ATR. */
2416   assert (sizeof slotp->atr >= sizeof atr);
2417   slotp->atrlen = atrlen;
2418   memcpy (slotp->atr, atr, atrlen);
2419   dump_reader_status (slot);
2420   return 0;
2421 }
2422
2423
2424 static int
2425 set_progress_cb_ccid_reader (int slot, gcry_handler_progress_t cb, void *cb_arg)
2426 {
2427   reader_table_t slotp = reader_table + slot;
2428
2429   return ccid_set_progress_cb (slotp->ccid.handle, cb, cb_arg);
2430 }
2431
2432
2433 static int
2434 get_status_ccid (int slot, unsigned int *status)
2435 {
2436   int rc;
2437   int bits;
2438
2439   rc = ccid_slot_status (reader_table[slot].ccid.handle, &bits);
2440   if (rc)
2441     return rc;
2442
2443   if (bits == 0)
2444     *status = (APDU_CARD_USABLE|APDU_CARD_PRESENT|APDU_CARD_ACTIVE);
2445   else if (bits == 1)
2446     *status = APDU_CARD_PRESENT;
2447   else
2448     *status = 0;
2449
2450   return 0;
2451 }
2452
2453
2454 /* Actually send the APDU of length APDULEN to SLOT and return a
2455    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2456    set to BUFLEN.  Returns: Internal CCID driver error code. */
2457 static int
2458 send_apdu_ccid (int slot, unsigned char *apdu, size_t apdulen,
2459                 unsigned char *buffer, size_t *buflen,
2460                 pininfo_t *pininfo)
2461 {
2462   long err;
2463   size_t maxbuflen;
2464
2465   /* If we don't have an ATR, we need to reset the reader first. */
2466   if (!reader_table[slot].atrlen
2467       && (err = reset_ccid_reader (slot)))
2468     return err;
2469
2470   if (DBG_CARD_IO)
2471     log_printhex (" raw apdu:", apdu, apdulen);
2472
2473   maxbuflen = *buflen;
2474   if (pininfo)
2475     err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2476                                   apdu, apdulen, pininfo,
2477                                   buffer, maxbuflen, buflen);
2478   else
2479     err = ccid_transceive (reader_table[slot].ccid.handle,
2480                            apdu, apdulen,
2481                            buffer, maxbuflen, buflen);
2482   if (err)
2483     log_error ("ccid_transceive failed: (0x%lx)\n",
2484                err);
2485
2486   return err;
2487 }
2488
2489
2490 /* Check whether the CCID reader supports the ISO command code COMMAND
2491    on the pinpad.  Return 0 on success.  For a description of the pin
2492    parameters, see ccid-driver.c */
2493 static int
2494 check_ccid_pinpad (int slot, int command, pininfo_t *pininfo)
2495 {
2496   unsigned char apdu[] = { 0, 0, 0, 0x81 };
2497
2498   apdu[1] = command;
2499   return ccid_transceive_secure (reader_table[slot].ccid.handle, apdu,
2500                                  sizeof apdu, pininfo, NULL, 0, NULL);
2501 }
2502
2503
2504 static int
2505 ccid_pinpad_operation (int slot, int class, int ins, int p0, int p1,
2506                        pininfo_t *pininfo)
2507 {
2508   unsigned char apdu[4];
2509   int err, sw;
2510   unsigned char result[2];
2511   size_t resultlen = 2;
2512
2513   apdu[0] = class;
2514   apdu[1] = ins;
2515   apdu[2] = p0;
2516   apdu[3] = p1;
2517   err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2518                                 apdu, sizeof apdu, pininfo,
2519                                 result, 2, &resultlen);
2520   if (err)
2521     return err;
2522
2523   if (resultlen < 2)
2524     return SW_HOST_INCOMPLETE_CARD_RESPONSE;
2525
2526   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2527   return sw;
2528 }
2529
2530
2531 /* Open the reader and try to read an ATR.  */
2532 static int
2533 open_ccid_reader (const char *portstr)
2534 {
2535   int err;
2536   int slot;
2537   reader_table_t slotp;
2538
2539   slot = new_reader_slot ();
2540   if (slot == -1)
2541     return -1;
2542   slotp = reader_table + slot;
2543
2544   err = ccid_open_reader (&slotp->ccid.handle, portstr);
2545   if (err)
2546     {
2547       slotp->used = 0;
2548       return -1;
2549     }
2550
2551   err = ccid_get_atr (slotp->ccid.handle,
2552                       slotp->atr, sizeof slotp->atr, &slotp->atrlen);
2553   if (err)
2554     {
2555       slotp->atrlen = 0;
2556       err = 0;
2557     }
2558   else
2559     {
2560       /* If we got to here we know that a card is present
2561          and usable.  Thus remember this.  */
2562       reader_table[slot].last_status = (APDU_CARD_USABLE
2563                                         | APDU_CARD_PRESENT
2564                                         | APDU_CARD_ACTIVE);
2565     }
2566
2567   reader_table[slot].close_reader = close_ccid_reader;
2568   reader_table[slot].shutdown_reader = shutdown_ccid_reader;
2569   reader_table[slot].reset_reader = reset_ccid_reader;
2570   reader_table[slot].get_status_reader = get_status_ccid;
2571   reader_table[slot].send_apdu_reader = send_apdu_ccid;
2572   reader_table[slot].check_pinpad = check_ccid_pinpad;
2573   reader_table[slot].dump_status_reader = dump_ccid_reader_status;
2574   reader_table[slot].set_progress_cb = set_progress_cb_ccid_reader;
2575   reader_table[slot].pinpad_verify = ccid_pinpad_operation;
2576   reader_table[slot].pinpad_modify = ccid_pinpad_operation;
2577   /* Our CCID reader code does not support T=0 at all, thus reset the
2578      flag.  */
2579   reader_table[slot].is_t0 = 0;
2580
2581   dump_reader_status (slot);
2582   return slot;
2583 }
2584
2585
2586
2587 #endif /* HAVE_LIBUSB */
2588
2589
2590 \f
2591 #ifdef USE_G10CODE_RAPDU
2592 /*
2593      The Remote APDU Interface.
2594
2595      This uses the Remote APDU protocol to contact a reader.
2596
2597      The port number is actually an index into the list of ports as
2598      returned via the protocol.
2599  */
2600
2601
2602 static int
2603 rapdu_status_to_sw (int status)
2604 {
2605   int rc;
2606
2607   switch (status)
2608     {
2609     case RAPDU_STATUS_SUCCESS:  rc = 0; break;
2610
2611     case RAPDU_STATUS_INVCMD:
2612     case RAPDU_STATUS_INVPROT:
2613     case RAPDU_STATUS_INVSEQ:
2614     case RAPDU_STATUS_INVCOOKIE:
2615     case RAPDU_STATUS_INVREADER:  rc = SW_HOST_INV_VALUE;  break;
2616
2617     case RAPDU_STATUS_TIMEOUT:  rc = SW_HOST_CARD_IO_ERROR; break;
2618     case RAPDU_STATUS_CARDIO:   rc = SW_HOST_CARD_IO_ERROR; break;
2619     case RAPDU_STATUS_NOCARD:   rc = SW_HOST_NO_CARD; break;
2620     case RAPDU_STATUS_CARDCHG:  rc = SW_HOST_NO_CARD; break;
2621     case RAPDU_STATUS_BUSY:     rc = SW_HOST_BUSY; break;
2622     case RAPDU_STATUS_NEEDRESET: rc = SW_HOST_CARD_INACTIVE; break;
2623
2624     default: rc = SW_HOST_GENERAL_ERROR; break;
2625     }
2626
2627   return rc;
2628 }
2629
2630
2631
2632 static int
2633 close_rapdu_reader (int slot)
2634 {
2635   rapdu_release (reader_table[slot].rapdu.handle);
2636   reader_table[slot].used = 0;
2637   return 0;
2638 }
2639
2640
2641 static int
2642 reset_rapdu_reader (int slot)
2643 {
2644   int err;
2645   reader_table_t slotp;
2646   rapdu_msg_t msg = NULL;
2647
2648   slotp = reader_table + slot;
2649
2650   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2651   if (err)
2652     {
2653       log_error ("sending rapdu command RESET failed: %s\n",
2654                 err < 0 ? strerror (errno): rapdu_strerror (err));
2655       rapdu_msg_release (msg);
2656       return rapdu_status_to_sw (err);
2657     }
2658   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2659   if (err)
2660     {
2661       log_error ("receiving rapdu message failed: %s\n",
2662                 err < 0 ? strerror (errno): rapdu_strerror (err));
2663       rapdu_msg_release (msg);
2664       return rapdu_status_to_sw (err);
2665     }
2666   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2667     {
2668       int sw = rapdu_status_to_sw (msg->cmd);
2669       log_error ("rapdu command RESET failed: %s\n",
2670                  rapdu_strerror (msg->cmd));
2671       rapdu_msg_release (msg);
2672       return sw;
2673     }
2674   if (msg->datalen > DIM (slotp->atr))
2675     {
2676       log_error ("ATR returned by the RAPDU layer is too large\n");
2677       rapdu_msg_release (msg);
2678       return SW_HOST_INV_VALUE;
2679     }
2680   slotp->atrlen = msg->datalen;
2681   memcpy (slotp->atr, msg->data, msg->datalen);
2682
2683   rapdu_msg_release (msg);
2684   return 0;
2685 }
2686
2687
2688 static int
2689 my_rapdu_get_status (int slot, unsigned int *status)
2690 {
2691   int err;
2692   reader_table_t slotp;
2693   rapdu_msg_t msg = NULL;
2694   int oldslot;
2695
2696   slotp = reader_table + slot;
2697
2698   oldslot = rapdu_set_reader (slotp->rapdu.handle, slot);
2699   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_STATUS);
2700   rapdu_set_reader (slotp->rapdu.handle, oldslot);
2701   if (err)
2702     {
2703       log_error ("sending rapdu command GET_STATUS failed: %s\n",
2704                 err < 0 ? strerror (errno): rapdu_strerror (err));
2705       return rapdu_status_to_sw (err);
2706     }
2707   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2708   if (err)
2709     {
2710       log_error ("receiving rapdu message failed: %s\n",
2711                 err < 0 ? strerror (errno): rapdu_strerror (err));
2712       rapdu_msg_release (msg);
2713       return rapdu_status_to_sw (err);
2714     }
2715   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2716     {
2717       int sw = rapdu_status_to_sw (msg->cmd);
2718       log_error ("rapdu command GET_STATUS failed: %s\n",
2719                  rapdu_strerror (msg->cmd));
2720       rapdu_msg_release (msg);
2721       return sw;
2722     }
2723   *status = msg->data[0];
2724
2725   rapdu_msg_release (msg);
2726   return 0;
2727 }
2728
2729
2730 /* Actually send the APDU of length APDULEN to SLOT and return a
2731    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2732    set to BUFLEN.  Returns: APDU error code. */
2733 static int
2734 my_rapdu_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
2735                     unsigned char *buffer, size_t *buflen,
2736                     pininfo_t *pininfo)
2737 {
2738   int err;
2739   reader_table_t slotp;
2740   rapdu_msg_t msg = NULL;
2741   size_t maxlen = *buflen;
2742
2743   slotp = reader_table + slot;
2744
2745   *buflen = 0;
2746   if (DBG_CARD_IO)
2747     log_printhex ("  APDU_data:", apdu, apdulen);
2748
2749   if (apdulen < 4)
2750     {
2751       log_error ("rapdu_send_apdu: APDU is too short\n");
2752       return SW_HOST_INV_VALUE;
2753     }
2754
2755   err = rapdu_send_apdu (slotp->rapdu.handle, apdu, apdulen);
2756   if (err)
2757     {
2758       log_error ("sending rapdu command APDU failed: %s\n",
2759                 err < 0 ? strerror (errno): rapdu_strerror (err));
2760       rapdu_msg_release (msg);
2761       return rapdu_status_to_sw (err);
2762     }
2763   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2764   if (err)
2765     {
2766       log_error ("receiving rapdu message failed: %s\n",
2767                 err < 0 ? strerror (errno): rapdu_strerror (err));
2768       rapdu_msg_release (msg);
2769       return rapdu_status_to_sw (err);
2770     }
2771   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2772     {
2773       int sw = rapdu_status_to_sw (msg->cmd);
2774       log_error ("rapdu command APDU failed: %s\n",
2775                  rapdu_strerror (msg->cmd));
2776       rapdu_msg_release (msg);
2777       return sw;
2778     }
2779
2780   if (msg->datalen > maxlen)
2781     {
2782       log_error ("rapdu response apdu too large\n");
2783       rapdu_msg_release (msg);
2784       return SW_HOST_INV_VALUE;
2785     }
2786
2787   *buflen = msg->datalen;
2788   memcpy (buffer, msg->data, msg->datalen);
2789
2790   rapdu_msg_release (msg);
2791   return 0;
2792 }
2793
2794 static int
2795 open_rapdu_reader (int portno,
2796                    const unsigned char *cookie, size_t length,
2797                    int (*readfnc) (void *opaque,
2798                                    void *buffer, size_t size),
2799                    void *readfnc_value,
2800                    int (*writefnc) (void *opaque,
2801                                     const void *buffer, size_t size),
2802                    void *writefnc_value,
2803                    void (*closefnc) (void *opaque),
2804                    void *closefnc_value)
2805 {
2806   int err;
2807   int slot;
2808   reader_table_t slotp;
2809   rapdu_msg_t msg = NULL;
2810
2811   slot = new_reader_slot ();
2812   if (slot == -1)
2813     return -1;
2814   slotp = reader_table + slot;
2815
2816   slotp->rapdu.handle = rapdu_new ();
2817   if (!slotp->rapdu.handle)
2818     {
2819       slotp->used = 0;
2820       return -1;
2821     }
2822
2823   rapdu_set_reader (slotp->rapdu.handle, portno);
2824
2825   rapdu_set_iofunc (slotp->rapdu.handle,
2826                     readfnc, readfnc_value,
2827                     writefnc, writefnc_value,
2828                     closefnc, closefnc_value);
2829   rapdu_set_cookie (slotp->rapdu.handle, cookie, length);
2830
2831   /* First try to get the current ATR, but if the card is inactive
2832      issue a reset instead.  */
2833   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_ATR);
2834   if (err == RAPDU_STATUS_NEEDRESET)
2835     err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2836   if (err)
2837     {
2838       log_info ("sending rapdu command GET_ATR/RESET failed: %s\n",
2839                 err < 0 ? strerror (errno): rapdu_strerror (err));
2840       goto failure;
2841     }
2842   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2843   if (err)
2844     {
2845       log_info ("receiving rapdu message failed: %s\n",
2846                 err < 0 ? strerror (errno): rapdu_strerror (err));
2847       goto failure;
2848     }
2849   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2850     {
2851       log_info ("rapdu command GET ATR failed: %s\n",
2852                  rapdu_strerror (msg->cmd));
2853       goto failure;
2854     }
2855   if (msg->datalen > DIM (slotp->atr))
2856     {
2857       log_error ("ATR returned by the RAPDU layer is too large\n");
2858       goto failure;
2859     }
2860   slotp->atrlen = msg->datalen;
2861   memcpy (slotp->atr, msg->data, msg->datalen);
2862
2863   reader_table[slot].close_reader = close_rapdu_reader;
2864   reader_table[slot].reset_reader = reset_rapdu_reader;
2865   reader_table[slot].get_status_reader = my_rapdu_get_status;
2866   reader_table[slot].send_apdu_reader = my_rapdu_send_apdu;
2867   reader_table[slot].check_pinpad = NULL;
2868   reader_table[slot].dump_status_reader = NULL;
2869   reader_table[slot].pinpad_verify = NULL;
2870   reader_table[slot].pinpad_modify = NULL;
2871
2872   dump_reader_status (slot);
2873   rapdu_msg_release (msg);
2874   return slot;
2875
2876  failure:
2877   rapdu_msg_release (msg);
2878   rapdu_release (slotp->rapdu.handle);
2879   slotp->used = 0;
2880   return -1;
2881 }
2882
2883 #endif /*USE_G10CODE_RAPDU*/
2884
2885
2886 \f
2887 /*
2888        Driver Access
2889  */
2890
2891
2892 static int
2893 lock_slot (int slot)
2894 {
2895 #ifdef USE_NPTH
2896   int err;
2897
2898   err = npth_mutex_lock (&reader_table[slot].lock);
2899   if (err)
2900     {
2901       log_error ("failed to acquire apdu lock: %s\n", strerror (err));
2902       return SW_HOST_LOCKING_FAILED;
2903     }
2904 #endif /*USE_NPTH*/
2905   return 0;
2906 }
2907
2908 static int
2909 trylock_slot (int slot)
2910 {
2911 #ifdef USE_NPTH
2912   int err;
2913
2914   err = npth_mutex_trylock (&reader_table[slot].lock);
2915   if (err == EBUSY)
2916     return SW_HOST_BUSY;
2917   else if (err)
2918     {
2919       log_error ("failed to acquire apdu lock: %s\n", strerror (err));
2920       return SW_HOST_LOCKING_FAILED;
2921     }
2922 #endif /*USE_NPTH*/
2923   return 0;
2924 }
2925
2926 static void
2927 unlock_slot (int slot)
2928 {
2929 #ifdef USE_NPTH
2930   int err;
2931
2932   err = npth_mutex_unlock (&reader_table[slot].lock);
2933   if (err)
2934     log_error ("failed to release apdu lock: %s\n", strerror (errno));
2935 #endif /*USE_NPTH*/
2936 }
2937
2938
2939 /* Open the reader and return an internal slot number or -1 on
2940    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
2941    the first USB reader.  For PC/SC the first listed reader). */
2942 int
2943 apdu_open_reader (const char *portstr)
2944 {
2945   static int pcsc_api_loaded, ct_api_loaded;
2946   int slot;
2947
2948   if (DBG_READER)
2949     log_debug ("enter: apdu_open_reader: portstr=%s\n", portstr);
2950
2951 #ifdef HAVE_LIBUSB
2952   if (!opt.disable_ccid)
2953     {
2954       static int once_available;
2955       int i;
2956       const char *s;
2957
2958       slot = open_ccid_reader (portstr);
2959       if (slot != -1)
2960         {
2961           once_available = 1;
2962           if (DBG_READER)
2963             log_debug ("leave: apdu_open_reader => slot=%d [ccid]\n", slot);
2964           return slot; /* got one */
2965         }
2966
2967       /* If we ever loaded successfully loaded a CCID reader we never
2968          want to fallback to another driver.  This solves a problem
2969          where ccid was used, the card unplugged and then scdaemon
2970          tries to find a new reader and will eventually try PC/SC over
2971          and over again.  To reset this flag "gpgconf --kill scdaemon"
2972          can be used.  */
2973       if (once_available)
2974         {
2975           if (DBG_READER)
2976             log_debug ("leave: apdu_open_reader => slot=-1 (once_avail)\n");
2977           return -1;
2978         }
2979
2980       /* If a CCID reader specification has been given, the user does
2981          not want a fallback to other drivers. */
2982       if (portstr)
2983         for (s=portstr, i=0; *s; s++)
2984           if (*s == ':' && (++i == 3))
2985             {
2986               if (DBG_READER)
2987                 log_debug ("leave: apdu_open_reader => slot=-1 (no ccid)\n");
2988               return -1;
2989             }
2990     }
2991
2992 #endif /* HAVE_LIBUSB */
2993
2994   if (opt.ctapi_driver && *opt.ctapi_driver)
2995     {
2996       int port = portstr? atoi (portstr) : 32768;
2997
2998       if (!ct_api_loaded)
2999         {
3000           void *handle;
3001
3002           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
3003           if (!handle)
3004             {
3005               log_error ("apdu_open_reader: failed to open driver: %s\n",
3006                          dlerror ());
3007               return -1;
3008             }
3009           CT_init = dlsym (handle, "CT_init");
3010           CT_data = dlsym (handle, "CT_data");
3011           CT_close = dlsym (handle, "CT_close");
3012           if (!CT_init || !CT_data || !CT_close)
3013             {
3014               log_error ("apdu_open_reader: invalid CT-API driver\n");
3015               dlclose (handle);
3016               return -1;
3017             }
3018           ct_api_loaded = 1;
3019         }
3020       return open_ct_reader (port);
3021     }
3022
3023
3024   /* No ctAPI configured, so lets try the PC/SC API */
3025   if (!pcsc_api_loaded)
3026     {
3027 #ifndef NEED_PCSC_WRAPPER
3028       void *handle;
3029
3030       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
3031       if (!handle)
3032         {
3033           log_error ("apdu_open_reader: failed to open driver '%s': %s\n",
3034                      opt.pcsc_driver, dlerror ());
3035           return -1;
3036         }
3037
3038       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
3039       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
3040       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
3041 #if defined(_WIN32) || defined(__CYGWIN__)
3042       if (!pcsc_list_readers)
3043         pcsc_list_readers    = dlsym (handle, "SCardListReadersA");
3044 #endif
3045       pcsc_get_status_change = dlsym (handle, "SCardGetStatusChange");
3046 #if defined(_WIN32) || defined(__CYGWIN__)
3047       if (!pcsc_get_status_change)
3048         pcsc_get_status_change = dlsym (handle, "SCardGetStatusChangeA");
3049 #endif
3050       pcsc_connect           = dlsym (handle, "SCardConnect");
3051 #if defined(_WIN32) || defined(__CYGWIN__)
3052       if (!pcsc_connect)
3053         pcsc_connect         = dlsym (handle, "SCardConnectA");
3054 #endif
3055       pcsc_reconnect         = dlsym (handle, "SCardReconnect");
3056 #if defined(_WIN32) || defined(__CYGWIN__)
3057       if (!pcsc_reconnect)
3058         pcsc_reconnect       = dlsym (handle, "SCardReconnectA");
3059 #endif
3060       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
3061       pcsc_status            = dlsym (handle, "SCardStatus");
3062 #if defined(_WIN32) || defined(__CYGWIN__)
3063       if (!pcsc_status)
3064         pcsc_status          = dlsym (handle, "SCardStatusA");
3065 #endif
3066       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
3067       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
3068       pcsc_transmit          = dlsym (handle, "SCardTransmit");
3069       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
3070       pcsc_control           = dlsym (handle, "SCardControl");
3071
3072       if (!pcsc_establish_context
3073           || !pcsc_release_context
3074           || !pcsc_list_readers
3075           || !pcsc_get_status_change
3076           || !pcsc_connect
3077           || !pcsc_reconnect
3078           || !pcsc_disconnect
3079           || !pcsc_status
3080           || !pcsc_begin_transaction
3081           || !pcsc_end_transaction
3082           || !pcsc_transmit
3083           || !pcsc_control
3084           /* || !pcsc_set_timeout */)
3085         {
3086           /* Note that set_timeout is currently not used and also not
3087              available under Windows. */
3088           log_error ("apdu_open_reader: invalid PC/SC driver "
3089                      "(%d%d%d%d%d%d%d%d%d%d%d%d%d)\n",
3090                      !!pcsc_establish_context,
3091                      !!pcsc_release_context,
3092                      !!pcsc_list_readers,
3093                      !!pcsc_get_status_change,
3094                      !!pcsc_connect,
3095                      !!pcsc_reconnect,
3096                      !!pcsc_disconnect,
3097                      !!pcsc_status,
3098                      !!pcsc_begin_transaction,
3099                      !!pcsc_end_transaction,
3100                      !!pcsc_transmit,
3101                      !!pcsc_set_timeout,
3102                      !!pcsc_control );
3103           dlclose (handle);
3104           return -1;
3105         }
3106 #endif /*!NEED_PCSC_WRAPPER*/
3107       pcsc_api_loaded = 1;
3108     }
3109
3110   slot = open_pcsc_reader (portstr);
3111
3112   if (DBG_READER)
3113     log_debug ("leave: apdu_open_reader => slot=%d [pc/sc]\n", slot);
3114   return slot;
3115 }
3116
3117
3118 /* Open an remote reader and return an internal slot number or -1 on
3119    error. This function is an alternative to apdu_open_reader and used
3120    with remote readers only.  Note that the supplied CLOSEFNC will
3121    only be called once and the slot will not be valid afther this.
3122
3123    If PORTSTR is NULL we default to the first availabe port.
3124 */
3125 int
3126 apdu_open_remote_reader (const char *portstr,
3127                          const unsigned char *cookie, size_t length,
3128                          int (*readfnc) (void *opaque,
3129                                          void *buffer, size_t size),
3130                          void *readfnc_value,
3131                          int (*writefnc) (void *opaque,
3132                                           const void *buffer, size_t size),
3133                          void *writefnc_value,
3134                          void (*closefnc) (void *opaque),
3135                          void *closefnc_value)
3136 {
3137 #ifdef USE_G10CODE_RAPDU
3138   return open_rapdu_reader (portstr? atoi (portstr) : 0,
3139                             cookie, length,
3140                             readfnc, readfnc_value,
3141                             writefnc, writefnc_value,
3142                             closefnc, closefnc_value);
3143 #else
3144   (void)portstr;
3145   (void)cookie;
3146   (void)length;
3147   (void)readfnc;
3148   (void)readfnc_value;
3149   (void)writefnc;
3150   (void)writefnc_value;
3151   (void)closefnc;
3152   (void)closefnc_value;
3153 #ifdef _WIN32
3154   errno = ENOENT;
3155 #else
3156   errno = ENOSYS;
3157 #endif
3158   return -1;
3159 #endif
3160 }
3161
3162
3163 int
3164 apdu_close_reader (int slot)
3165 {
3166   int sw;
3167
3168   if (DBG_READER)
3169     log_debug ("enter: apdu_close_reader: slot=%d\n", slot);
3170
3171   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3172     {
3173       if (DBG_READER)
3174         log_debug ("leave: apdu_close_reader => SW_HOST_NO_DRIVER\n");
3175       return SW_HOST_NO_DRIVER;
3176     }
3177   sw = apdu_disconnect (slot);
3178   if (sw)
3179     {
3180       if (DBG_READER)
3181         log_debug ("leave: apdu_close_reader => 0x%x (apdu_disconnect)\n", sw);
3182       return sw;
3183     }
3184   if (reader_table[slot].close_reader)
3185     {
3186       sw = reader_table[slot].close_reader (slot);
3187       if (DBG_READER)
3188         log_debug ("leave: apdu_close_reader => 0x%x (close_reader)\n", sw);
3189       return sw;
3190     }
3191   if (DBG_READER)
3192     log_debug ("leave: apdu_close_reader => SW_HOST_NOT_SUPPORTED\n");
3193   return SW_HOST_NOT_SUPPORTED;
3194 }
3195
3196
3197 /* Function suitable for a cleanup function to close all reader.  It
3198    should not be used if the reader will be opened again.  The reason
3199    for implementing this to properly close USB devices so that they
3200    will startup the next time without error. */
3201 void
3202 apdu_prepare_exit (void)
3203 {
3204   static int sentinel;
3205   int slot;
3206
3207   if (!sentinel)
3208     {
3209       sentinel = 1;
3210       for (slot = 0; slot < MAX_READER; slot++)
3211         if (reader_table[slot].used)
3212           {
3213             apdu_disconnect (slot);
3214             if (reader_table[slot].close_reader)
3215               reader_table[slot].close_reader (slot);
3216             reader_table[slot].used = 0;
3217           }
3218       sentinel = 0;
3219     }
3220 }
3221
3222
3223 /* Shutdown a reader; that is basically the same as a close but keeps
3224    the handle ready for later use. A apdu_reset_reader or apdu_connect
3225    should be used to get it active again. */
3226 int
3227 apdu_shutdown_reader (int slot)
3228 {
3229   int sw;
3230
3231   if (DBG_READER)
3232     log_debug ("enter: apdu_shutdown_reader: slot=%d\n", slot);
3233
3234   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3235     {
3236       if (DBG_READER)
3237         log_debug ("leave: apdu_shutdown_reader => SW_HOST_NO_DRIVER\n");
3238       return SW_HOST_NO_DRIVER;
3239     }
3240   sw = apdu_disconnect (slot);
3241   if (sw)
3242     {
3243       if (DBG_READER)
3244         log_debug ("leave: apdu_shutdown_reader => 0x%x (apdu_disconnect)\n",
3245                    sw);
3246       return sw;
3247     }
3248   if (reader_table[slot].shutdown_reader)
3249     {
3250       sw = reader_table[slot].shutdown_reader (slot);
3251       if (DBG_READER)
3252         log_debug ("leave: apdu_shutdown_reader => 0x%x (close_reader)\n", sw);
3253       return sw;
3254     }
3255   if (DBG_READER)
3256     log_debug ("leave: apdu_shutdown_reader => SW_HOST_NOT_SUPPORTED\n");
3257   return SW_HOST_NOT_SUPPORTED;
3258 }
3259
3260 /* Enumerate all readers and return information on whether this reader
3261    is in use.  The caller should start with SLOT set to 0 and
3262    increment it with each call until an error is returned. */
3263 int
3264 apdu_enum_reader (int slot, int *used)
3265 {
3266   if (slot < 0 || slot >= MAX_READER)
3267     return SW_HOST_NO_DRIVER;
3268   *used = reader_table[slot].used;
3269   return 0;
3270 }
3271
3272
3273 /* Connect a card.  This is used to power up the card and make sure
3274    that an ATR is available.  Depending on the reader backend it may
3275    return an error for an inactive card or if no card is
3276    available.  */
3277 int
3278 apdu_connect (int slot)
3279 {
3280   int sw;
3281   unsigned int status;
3282
3283   if (DBG_READER)
3284     log_debug ("enter: apdu_connect: slot=%d\n", slot);
3285
3286   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3287     {
3288       if (DBG_READER)
3289         log_debug ("leave: apdu_connect => SW_HOST_NO_DRIVER\n");
3290       return SW_HOST_NO_DRIVER;
3291     }
3292
3293   /* Only if the access method provides a connect function we use it.
3294      If not, we expect that the card has been implicitly connected by
3295      apdu_open_reader.  */
3296   if (reader_table[slot].connect_card)
3297     {
3298       sw = lock_slot (slot);
3299       if (!sw)
3300         {
3301           sw = reader_table[slot].connect_card (slot);
3302           unlock_slot (slot);
3303         }
3304     }
3305   else
3306     sw = 0;
3307
3308   /* We need to call apdu_get_status_internal, so that the last-status
3309      machinery gets setup properly even if a card is inserted while
3310      scdaemon is fired up and apdu_get_status has not yet been called.
3311      Without that we would force a reset of the card with the next
3312      call to apdu_get_status.  */
3313   apdu_get_status_internal (slot, 1, 1, &status, NULL);
3314   if (sw)
3315     ;
3316   else if (!(status & APDU_CARD_PRESENT))
3317     sw = SW_HOST_NO_CARD;
3318   else if ((status & APDU_CARD_PRESENT) && !(status & APDU_CARD_ACTIVE))
3319     sw = SW_HOST_CARD_INACTIVE;
3320
3321   if (DBG_READER)
3322     log_debug ("leave: apdu_connect => sw=0x%x\n", sw);
3323
3324   return sw;
3325 }
3326
3327
3328 int
3329 apdu_disconnect (int slot)
3330 {
3331   int sw;
3332
3333   if (DBG_READER)
3334     log_debug ("enter: apdu_disconnect: slot=%d\n", slot);
3335
3336   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3337     {
3338       if (DBG_READER)
3339         log_debug ("leave: apdu_disconnect => SW_HOST_NO_DRIVER\n");
3340       return SW_HOST_NO_DRIVER;
3341     }
3342
3343   if (reader_table[slot].disconnect_card)
3344     {
3345       sw = lock_slot (slot);
3346       if (!sw)
3347         {
3348           sw = reader_table[slot].disconnect_card (slot);
3349           unlock_slot (slot);
3350         }
3351     }
3352   else
3353     sw = 0;
3354
3355   if (DBG_READER)
3356     log_debug ("leave: apdu_disconnect => sw=0x%x\n", sw);
3357   return sw;
3358 }
3359
3360
3361 /* Set the progress callback of SLOT to CB and its args to CB_ARG.  If
3362    CB is NULL the progress callback is removed.  */
3363 int
3364 apdu_set_progress_cb (int slot, gcry_handler_progress_t cb, void *cb_arg)
3365 {
3366   int sw;
3367
3368   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3369     return SW_HOST_NO_DRIVER;
3370
3371   if (reader_table[slot].set_progress_cb)
3372     {
3373       sw = lock_slot (slot);
3374       if (!sw)
3375         {
3376           sw = reader_table[slot].set_progress_cb (slot, cb, cb_arg);
3377           unlock_slot (slot);
3378         }
3379     }
3380   else
3381     sw = 0;
3382   return sw;
3383 }
3384
3385
3386 /* Do a reset for the card in reader at SLOT. */
3387 int
3388 apdu_reset (int slot)
3389 {
3390   int sw;
3391
3392   if (DBG_READER)
3393     log_debug ("enter: apdu_reset: slot=%d\n", slot);
3394
3395   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3396     {
3397       if (DBG_READER)
3398         log_debug ("leave: apdu_reset => SW_HOST_NO_DRIVER\n");
3399       return SW_HOST_NO_DRIVER;
3400     }
3401
3402   if ((sw = lock_slot (slot)))
3403     {
3404       if (DBG_READER)
3405         log_debug ("leave: apdu_reset => sw=0x%x (lock_slot)\n", sw);
3406       return sw;
3407     }
3408
3409   reader_table[slot].last_status = 0;
3410   if (reader_table[slot].reset_reader)
3411     sw = reader_table[slot].reset_reader (slot);
3412
3413   if (!sw)
3414     {
3415       /* If we got to here we know that a card is present
3416          and usable.  Thus remember this.  */
3417       reader_table[slot].last_status = (APDU_CARD_USABLE
3418                                         | APDU_CARD_PRESENT
3419                                         | APDU_CARD_ACTIVE);
3420     }
3421
3422   unlock_slot (slot);
3423   if (DBG_READER)
3424     log_debug ("leave: apdu_reset => sw=0x%x\n", sw);
3425   return sw;
3426 }
3427
3428
3429 /* Return the ATR or NULL if none is available.  On success the length
3430    of the ATR is stored at ATRLEN.  The caller must free the returned
3431    value.  */
3432 unsigned char *
3433 apdu_get_atr (int slot, size_t *atrlen)
3434 {
3435   unsigned char *buf;
3436
3437   if (DBG_READER)
3438     log_debug ("enter: apdu_get_atr: slot=%d\n", slot);
3439
3440   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3441     {
3442       if (DBG_READER)
3443         log_debug ("leave: apdu_get_atr => NULL (bad slot)\n");
3444       return NULL;
3445     }
3446   if (!reader_table[slot].atrlen)
3447     {
3448       if (DBG_READER)
3449         log_debug ("leave: apdu_get_atr => NULL (no ATR)\n");
3450       return NULL;
3451     }
3452
3453   buf = xtrymalloc (reader_table[slot].atrlen);
3454   if (!buf)
3455     {
3456       if (DBG_READER)
3457         log_debug ("leave: apdu_get_atr => NULL (out of core)\n");
3458       return NULL;
3459     }
3460   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
3461   *atrlen = reader_table[slot].atrlen;
3462   if (DBG_READER)
3463     log_debug ("leave: apdu_get_atr => atrlen=%zu\n", *atrlen);
3464   return buf;
3465 }
3466
3467
3468
3469 /* Retrieve the status for SLOT. The function does only wait for the
3470    card to become available if HANG is set to true. On success the
3471    bits in STATUS will be set to
3472
3473      APDU_CARD_USABLE  (bit 0) = card present and usable
3474      APDU_CARD_PRESENT (bit 1) = card present
3475      APDU_CARD_ACTIVE  (bit 2) = card active
3476                        (bit 3) = card access locked [not yet implemented]
3477
3478    For must applications, testing bit 0 is sufficient.
3479
3480    CHANGED will receive the value of the counter tracking the number
3481    of card insertions.  This value may be used to detect a card
3482    change.
3483 */
3484 static int
3485 apdu_get_status_internal (int slot, int hang, int no_atr_reset,
3486                           unsigned int *status, unsigned int *changed)
3487 {
3488   int sw;
3489   unsigned int s;
3490
3491   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3492     return SW_HOST_NO_DRIVER;
3493
3494   if ((sw = hang? lock_slot (slot) : trylock_slot (slot)))
3495     return sw;
3496
3497   if (reader_table[slot].get_status_reader)
3498     sw = reader_table[slot].get_status_reader (slot, &s);
3499
3500   unlock_slot (slot);
3501
3502   if (sw)
3503     {
3504       reader_table[slot].last_status = 0;
3505       return sw;
3506     }
3507
3508   /* Keep track of changes.  */
3509   if (s != reader_table[slot].last_status
3510       || !reader_table[slot].any_status )
3511     {
3512       reader_table[slot].change_counter++;
3513       /* Make sure that the ATR is invalid so that a reset will be
3514          triggered by apdu_activate.  */
3515       if (!no_atr_reset)
3516         reader_table[slot].atrlen = 0;
3517     }
3518   reader_table[slot].any_status = 1;
3519   reader_table[slot].last_status = s;
3520
3521   if (status)
3522     *status = s;
3523   if (changed)
3524     *changed = reader_table[slot].change_counter;
3525   return 0;
3526 }
3527
3528
3529 /* See above for a description.  */
3530 int
3531 apdu_get_status (int slot, int hang,
3532                  unsigned int *status, unsigned int *changed)
3533 {
3534   int sw;
3535
3536   if (DBG_READER)
3537     log_debug ("enter: apdu_get_status: slot=%d hang=%d\n", slot, hang);
3538   sw = apdu_get_status_internal (slot, hang, 0, status, changed);
3539   if (DBG_READER)
3540     {
3541       if (status && changed)
3542         log_debug ("leave: apdu_get_status => sw=0x%x status=%u changecnt=%u\n",
3543                    sw, *status, *changed);
3544       else if (status)
3545         log_debug ("leave: apdu_get_status => sw=0x%x status=%u\n",
3546                    sw, *status);
3547       else if (changed)
3548         log_debug ("leave: apdu_get_status => sw=0x%x changed=%u\n",
3549                    sw, *changed);
3550       else
3551         log_debug ("leave: apdu_get_status => sw=0x%x\n", sw);
3552     }
3553   return sw;
3554 }
3555
3556
3557 /* Check whether the reader supports the ISO command code COMMAND on
3558    the pinpad.  Return 0 on success.  For a description of the pin
3559    parameters, see ccid-driver.c */
3560 int
3561 apdu_check_pinpad (int slot, int command, pininfo_t *pininfo)
3562 {
3563   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3564     return SW_HOST_NO_DRIVER;
3565
3566   if (opt.enable_pinpad_varlen)
3567     pininfo->fixedlen = 0;
3568
3569   if (reader_table[slot].check_pinpad)
3570     {
3571       int sw;
3572
3573       if ((sw = lock_slot (slot)))
3574         return sw;
3575
3576       sw = reader_table[slot].check_pinpad (slot, command, pininfo);
3577       unlock_slot (slot);
3578       return sw;
3579     }
3580   else
3581     return SW_HOST_NOT_SUPPORTED;
3582 }
3583
3584
3585 int
3586 apdu_pinpad_verify (int slot, int class, int ins, int p0, int p1,
3587                     pininfo_t *pininfo)
3588 {
3589   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3590     return SW_HOST_NO_DRIVER;
3591
3592   if (reader_table[slot].pinpad_verify)
3593     {
3594       int sw;
3595
3596       if ((sw = lock_slot (slot)))
3597         return sw;
3598
3599       sw = reader_table[slot].pinpad_verify (slot, class, ins, p0, p1,
3600                                              pininfo);
3601       unlock_slot (slot);
3602       return sw;
3603     }
3604   else
3605     return SW_HOST_NOT_SUPPORTED;
3606 }
3607
3608
3609 int
3610 apdu_pinpad_modify (int slot, int class, int ins, int p0, int p1,
3611                     pininfo_t *pininfo)
3612 {
3613   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3614     return SW_HOST_NO_DRIVER;
3615
3616   if (reader_table[slot].pinpad_modify)
3617     {
3618       int sw;
3619
3620       if ((sw = lock_slot (slot)))
3621         return sw;
3622
3623       sw = reader_table[slot].pinpad_modify (slot, class, ins, p0, p1,
3624                                              pininfo);
3625       unlock_slot (slot);
3626       return sw;
3627     }
3628   else
3629     return SW_HOST_NOT_SUPPORTED;
3630 }
3631
3632
3633 /* Dispatcher for the actual send_apdu function. Note, that this
3634    function should be called in locked state. */
3635 static int
3636 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
3637            unsigned char *buffer, size_t *buflen, pininfo_t *pininfo)
3638 {
3639   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3640     return SW_HOST_NO_DRIVER;
3641
3642   if (reader_table[slot].send_apdu_reader)
3643     return reader_table[slot].send_apdu_reader (slot,
3644                                                 apdu, apdulen,
3645                                                 buffer, buflen,
3646                                                 pininfo);
3647   else
3648     return SW_HOST_NOT_SUPPORTED;
3649 }
3650
3651
3652 /* Core APDU tranceiver function. Parameters are described at
3653    apdu_send_le with the exception of PININFO which indicates pinpad
3654    related operations if not NULL.  If EXTENDED_MODE is not 0
3655    command chaining or extended length will be used according to these
3656    values:
3657        n < 0 := Use command chaining with the data part limited to -n
3658                 in each chunk.  If -1 is used a default value is used.
3659       n == 0 := No extended mode or command chaining.
3660       n == 1 := Use extended length for input and output without a
3661                 length limit.
3662        n > 1 := Use extended length with up to N bytes.
3663
3664 */
3665 static int
3666 send_le (int slot, int class, int ins, int p0, int p1,
3667          int lc, const char *data, int le,
3668          unsigned char **retbuf, size_t *retbuflen,
3669          pininfo_t *pininfo, int extended_mode)
3670 {
3671 #define SHORT_RESULT_BUFFER_SIZE 258
3672   /* We allocate 8 extra bytes as a safety margin towards a driver bug.  */
3673   unsigned char short_result_buffer[SHORT_RESULT_BUFFER_SIZE+10];
3674   unsigned char *result_buffer = NULL;
3675   size_t result_buffer_size;
3676   unsigned char *result;
3677   size_t resultlen;
3678   unsigned char short_apdu_buffer[5+256+1];
3679   unsigned char *apdu_buffer = NULL;
3680   size_t apdu_buffer_size;
3681   unsigned char *apdu;
3682   size_t apdulen;
3683   int sw;
3684   long rc; /* We need a long here due to PC/SC. */
3685   int did_exact_length_hack = 0;
3686   int use_chaining = 0;
3687   int use_extended_length = 0;
3688   int lc_chunk;
3689
3690   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3691     return SW_HOST_NO_DRIVER;
3692
3693   if (DBG_CARD_IO)
3694     log_debug ("send apdu: c=%02X i=%02X p1=%02X p2=%02X lc=%d le=%d em=%d\n",
3695                class, ins, p0, p1, lc, le, extended_mode);
3696
3697   if (lc != -1 && (lc > 255 || lc < 0))
3698     {
3699       /* Data does not fit into an APDU.  What we do now depends on
3700          the EXTENDED_MODE parameter.  */
3701       if (!extended_mode)
3702         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
3703       else if (extended_mode > 0)
3704         use_extended_length = 1;
3705       else if (extended_mode < 0)
3706         {
3707           /* Send APDU using chaining mode.  */
3708           if (lc > 16384)
3709             return SW_WRONG_LENGTH;   /* Sanity check.  */
3710           if ((class&0xf0) != 0)
3711             return SW_HOST_INV_VALUE; /* Upper 4 bits need to be 0.  */
3712           use_chaining = extended_mode == -1? 255 : -extended_mode;
3713           use_chaining &= 0xff;
3714         }
3715       else
3716         return SW_HOST_INV_VALUE;
3717     }
3718   else if (lc == -1 && extended_mode > 0)
3719     use_extended_length = 1;
3720
3721   if (le != -1 && (le > (extended_mode > 0? 255:256) || le < 0))
3722     {
3723       /* Expected Data does not fit into an APDU.  What we do now
3724          depends on the EXTENDED_MODE parameter.  Note that a check
3725          for command chaining does not make sense because we are
3726          looking at Le.  */
3727       if (!extended_mode)
3728         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
3729       else if (use_extended_length)
3730         ; /* We are already using extended length.  */
3731       else if (extended_mode > 0)
3732         use_extended_length = 1;
3733       else
3734         return SW_HOST_INV_VALUE;
3735     }
3736
3737   if ((!data && lc != -1) || (data && lc == -1))
3738     return SW_HOST_INV_VALUE;
3739
3740   if (use_extended_length)
3741     {
3742       if (reader_table[slot].is_t0)
3743         return SW_HOST_NOT_SUPPORTED;
3744
3745       /* Space for: cls/ins/p1/p2+Z+2_byte_Lc+Lc+2_byte_Le.  */
3746       apdu_buffer_size = 4 + 1 + (lc >= 0? (2+lc):0) + 2;
3747       apdu_buffer = xtrymalloc (apdu_buffer_size + 10);
3748       if (!apdu_buffer)
3749         return SW_HOST_OUT_OF_CORE;
3750       apdu = apdu_buffer;
3751     }
3752   else
3753     {
3754       apdu_buffer_size = sizeof short_apdu_buffer;
3755       apdu = short_apdu_buffer;