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