scd: Improve the prompts for OpenPGP cards.
[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 *, 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, int on_wire);
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, int on_wire)
669 {
670   (void)slot;
671   (void)on_wire;
672   /* The status we returned is wrong but we don't care because ctAPI
673      is not anymore required.  */
674   *status = APDU_CARD_USABLE|APDU_CARD_PRESENT|APDU_CARD_ACTIVE;
675   return 0;
676 }
677
678 /* Actually send the APDU of length APDULEN to SLOT and return a
679    maximum of *BUFLEN data in BUFFER, the actual returned size will be
680    set to BUFLEN.  Returns: CT API error code. */
681 static int
682 ct_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
683               unsigned char *buffer, size_t *buflen, pininfo_t *pininfo)
684 {
685   int rc;
686   unsigned char dad[1], sad[1];
687   unsigned short ctbuflen;
688
689   (void)pininfo;
690
691   /* If we don't have an ATR, we need to reset the reader first. */
692   if (!reader_table[slot].atrlen
693       && (rc = reset_ct_reader (slot)))
694     return rc;
695
696   dad[0] = 0;     /* Destination address: Card. */
697   sad[0] = 2;     /* Source address: Host. */
698   ctbuflen = *buflen;
699   if (DBG_CARD_IO)
700     log_printhex ("  CT_data:", apdu, apdulen);
701   rc = CT_data (slot, dad, sad, apdulen, apdu, &ctbuflen, buffer);
702   *buflen = ctbuflen;
703
704   return rc? SW_HOST_CARD_IO_ERROR: 0;
705 }
706
707
708
709 /* Open a reader and return an internal handle for it.  PORT is a
710    non-negative value with the port number of the reader. USB readers
711    do have port numbers starting at 32769. */
712 static int
713 open_ct_reader (int port)
714 {
715   int rc, reader;
716
717   if (port < 0 || port > 0xffff)
718     {
719       log_error ("open_ct_reader: invalid port %d requested\n", port);
720       return -1;
721     }
722   reader = new_reader_slot ();
723   if (reader == -1)
724     return reader;
725   reader_table[reader].port = port;
726
727   rc = CT_init (reader, (unsigned short)port);
728   if (rc)
729     {
730       log_error ("apdu_open_ct_reader failed on port %d: %s\n",
731                  port, ct_error_string (rc));
732       reader_table[reader].used = 0;
733       unlock_slot (reader);
734       return -1;
735     }
736
737   /* Only try to activate the card. */
738   rc = ct_activate_card (reader);
739   if (rc)
740     {
741       reader_table[reader].atrlen = 0;
742       rc = 0;
743     }
744
745   reader_table[reader].close_reader = close_ct_reader;
746   reader_table[reader].reset_reader = reset_ct_reader;
747   reader_table[reader].get_status_reader = ct_get_status;
748   reader_table[reader].send_apdu_reader = ct_send_apdu;
749   reader_table[reader].check_pinpad = NULL;
750   reader_table[reader].dump_status_reader = NULL;
751   reader_table[reader].pinpad_verify = NULL;
752   reader_table[reader].pinpad_modify = NULL;
753
754   dump_reader_status (reader);
755   unlock_slot (reader);
756   return reader;
757 }
758
759 \f
760 /*
761        PC/SC Interface
762  */
763
764 #ifdef NEED_PCSC_WRAPPER
765 static int
766 writen (int fd, const void *buf, size_t nbytes)
767 {
768   size_t nleft = nbytes;
769   int nwritten;
770
771 /*   log_printhex (" writen:", buf, nbytes); */
772
773   while (nleft > 0)
774     {
775 #ifdef USE_NPTH
776       nwritten = npth_write (fd, buf, nleft);
777 #else
778       nwritten = write (fd, buf, nleft);
779 #endif
780       if (nwritten < 0 && errno == EINTR)
781         continue;
782       if (nwritten < 0)
783         return -1;
784       nleft -= nwritten;
785       buf = (const char*)buf + nwritten;
786     }
787   return 0;
788 }
789
790 /* Read up to BUFLEN bytes from FD and return the number of bytes
791    actually read in NREAD.  Returns -1 on error or 0 on success. */
792 static int
793 readn (int fd, void *buf, size_t buflen, size_t *nread)
794 {
795   size_t nleft = buflen;
796   int n;
797 /*   void *orig_buf = buf; */
798
799   while (nleft > 0)
800     {
801 #ifdef USE_NPTH
802 # ifdef HAVE_W32_SYSTEM
803 #  error Cannot use npth_read here because it expects a system HANDLE.
804 # endif
805       n = npth_read (fd, buf, nleft);
806 #else
807       n = read (fd, buf, nleft);
808 #endif
809       if (n < 0 && errno == EINTR)
810         continue;
811       if (n < 0)
812         return -1; /* read error. */
813       if (!n)
814         break; /* EOF */
815       nleft -= n;
816       buf = (char*)buf + n;
817     }
818   if (nread)
819     *nread = buflen - nleft;
820
821 /*   log_printhex ("  readn:", orig_buf, *nread); */
822
823   return 0;
824 }
825 #endif /*NEED_PCSC_WRAPPER*/
826
827 static const char *
828 pcsc_error_string (long err)
829 {
830   const char *s;
831
832   if (!err)
833     return "okay";
834   if ((err & 0x80100000) != 0x80100000)
835     return "invalid PC/SC error code";
836   err &= 0xffff;
837   switch (err)
838     {
839     case 0x0002: s = "cancelled"; break;
840     case 0x000e: s = "can't dispose"; break;
841     case 0x0008: s = "insufficient buffer"; break;
842     case 0x0015: s = "invalid ATR"; break;
843     case 0x0003: s = "invalid handle"; break;
844     case 0x0004: s = "invalid parameter"; break;
845     case 0x0005: s = "invalid target"; break;
846     case 0x0011: s = "invalid value"; break;
847     case 0x0006: s = "no memory"; break;
848     case 0x0013: s = "comm error"; break;
849     case 0x0001: s = "internal error"; break;
850     case 0x0014: s = "unknown error"; break;
851     case 0x0007: s = "waited too long"; break;
852     case 0x0009: s = "unknown reader"; break;
853     case 0x000a: s = "timeout"; break;
854     case 0x000b: s = "sharing violation"; break;
855     case 0x000c: s = "no smartcard"; break;
856     case 0x000d: s = "unknown card"; break;
857     case 0x000f: s = "proto mismatch"; break;
858     case 0x0010: s = "not ready"; break;
859     case 0x0012: s = "system cancelled"; break;
860     case 0x0016: s = "not transacted"; break;
861     case 0x0017: s = "reader unavailable"; break;
862     case 0x0065: s = "unsupported card"; break;
863     case 0x0066: s = "unresponsive card"; break;
864     case 0x0067: s = "unpowered card"; break;
865     case 0x0068: s = "reset card"; break;
866     case 0x0069: s = "removed card"; break;
867     case 0x006a: s = "inserted card"; break;
868     case 0x001f: s = "unsupported feature"; break;
869     case 0x0019: s = "PCI too small"; break;
870     case 0x001a: s = "reader unsupported"; break;
871     case 0x001b: s = "duplicate reader"; break;
872     case 0x001c: s = "card unsupported"; break;
873     case 0x001d: s = "no service"; break;
874     case 0x001e: s = "service stopped"; break;
875     default:     s = "unknown PC/SC error code"; break;
876     }
877   return s;
878 }
879
880 /* Map PC/SC error codes to our special host status words.  */
881 static int
882 pcsc_error_to_sw (long ec)
883 {
884   int rc;
885
886   switch ( PCSC_ERR_MASK (ec) )
887     {
888     case 0:  rc = 0; break;
889
890     case PCSC_E_CANCELLED:           rc = SW_HOST_ABORTED; break;
891     case PCSC_E_NO_MEMORY:           rc = SW_HOST_OUT_OF_CORE; break;
892     case PCSC_E_TIMEOUT:             rc = SW_HOST_CARD_IO_ERROR; break;
893     case PCSC_E_NO_SERVICE:
894     case PCSC_E_SERVICE_STOPPED:
895     case PCSC_E_UNKNOWN_READER:      rc = SW_HOST_NO_READER; break;
896     case PCSC_E_SHARING_VIOLATION:   rc = SW_HOST_LOCKING_FAILED; break;
897     case PCSC_E_NO_SMARTCARD:        rc = SW_HOST_NO_CARD; break;
898     case PCSC_W_REMOVED_CARD:        rc = SW_HOST_NO_CARD; break;
899
900     case PCSC_E_INVALID_TARGET:
901     case PCSC_E_INVALID_VALUE:
902     case PCSC_E_INVALID_HANDLE:
903     case PCSC_E_INVALID_PARAMETER:
904     case PCSC_E_INSUFFICIENT_BUFFER: rc = SW_HOST_INV_VALUE; break;
905
906     default:  rc = SW_HOST_GENERAL_ERROR; break;
907     }
908
909   return rc;
910 }
911
912 static void
913 dump_pcsc_reader_status (int slot)
914 {
915   if (reader_table[slot].pcsc.card)
916     {
917       log_info ("reader slot %d: active protocol:", slot);
918       if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T0))
919         log_printf (" T0");
920       else if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
921         log_printf (" T1");
922       else if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_RAW))
923         log_printf (" raw");
924       log_printf ("\n");
925     }
926   else
927     log_info ("reader slot %d: not connected\n", slot);
928 }
929
930
931 #ifndef NEED_PCSC_WRAPPER
932 static int
933 pcsc_get_status_direct (int slot, unsigned int *status, int on_wire)
934 {
935   long err;
936   struct pcsc_readerstate_s rdrstates[1];
937
938   (void)on_wire;
939   memset (rdrstates, 0, sizeof *rdrstates);
940   rdrstates[0].reader = reader_table[slot].rdrname;
941   rdrstates[0].current_state = PCSC_STATE_UNAWARE;
942   err = pcsc_get_status_change (reader_table[slot].pcsc.context,
943                                 0,
944                                 rdrstates, 1);
945   if (err == PCSC_E_TIMEOUT)
946     err = 0; /* Timeout is no error error here. */
947   if (err)
948     {
949       log_error ("pcsc_get_status_change failed: %s (0x%lx)\n",
950                  pcsc_error_string (err), err);
951       return pcsc_error_to_sw (err);
952     }
953
954   /*   log_debug  */
955   /*     ("pcsc_get_status_change: %s%s%s%s%s%s%s%s%s%s\n", */
956   /*      (rdrstates[0].event_state & PCSC_STATE_IGNORE)? " ignore":"", */
957   /*      (rdrstates[0].event_state & PCSC_STATE_CHANGED)? " changed":"", */
958   /*      (rdrstates[0].event_state & PCSC_STATE_UNKNOWN)? " unknown":"", */
959   /*      (rdrstates[0].event_state & PCSC_STATE_UNAVAILABLE)?" unavail":"", */
960   /*      (rdrstates[0].event_state & PCSC_STATE_EMPTY)? " empty":"", */
961   /*      (rdrstates[0].event_state & PCSC_STATE_PRESENT)? " present":"", */
962   /*      (rdrstates[0].event_state & PCSC_STATE_ATRMATCH)? " atr":"", */
963   /*      (rdrstates[0].event_state & PCSC_STATE_EXCLUSIVE)? " excl":"", */
964   /*      (rdrstates[0].event_state & PCSC_STATE_INUSE)? " unuse":"", */
965   /*      (rdrstates[0].event_state & PCSC_STATE_MUTE)? " mute":"" ); */
966
967   *status = 0;
968   if ( (rdrstates[0].event_state & PCSC_STATE_PRESENT) )
969     {
970       *status |= APDU_CARD_PRESENT;
971       if ( !(rdrstates[0].event_state & PCSC_STATE_MUTE) )
972         *status |= APDU_CARD_ACTIVE;
973     }
974 #ifndef HAVE_W32_SYSTEM
975   /* We indicate a useful card if it is not in use by another
976      application.  This is because we only use exclusive access
977      mode.  */
978   if ( (*status & (APDU_CARD_PRESENT|APDU_CARD_ACTIVE))
979        == (APDU_CARD_PRESENT|APDU_CARD_ACTIVE)
980        && !(rdrstates[0].event_state & PCSC_STATE_INUSE) )
981     *status |= APDU_CARD_USABLE;
982 #else
983   /* Some winscard drivers may set EXCLUSIVE and INUSE at the same
984      time when we are the only user (SCM SCR335) under Windows.  */
985   if ((*status & (APDU_CARD_PRESENT|APDU_CARD_ACTIVE))
986       == (APDU_CARD_PRESENT|APDU_CARD_ACTIVE))
987     *status |= APDU_CARD_USABLE;
988 #endif
989
990   return 0;
991 }
992 #endif /*!NEED_PCSC_WRAPPER*/
993
994
995 #ifdef NEED_PCSC_WRAPPER
996 static int
997 pcsc_get_status_wrapped (int slot, unsigned int *status, int on_wire)
998 {
999   long err;
1000   reader_table_t slotp;
1001   size_t len, full_len;
1002   int i, n;
1003   unsigned char msgbuf[9];
1004   unsigned char buffer[16];
1005   int sw = SW_HOST_CARD_IO_ERROR;
1006
1007   (void)on_wire;
1008   slotp = reader_table + slot;
1009
1010   if (slotp->pcsc.req_fd == -1
1011       || slotp->pcsc.rsp_fd == -1
1012       || slotp->pcsc.pid == (pid_t)(-1) )
1013     {
1014       log_error ("pcsc_get_status: pcsc-wrapper not running\n");
1015       return sw;
1016     }
1017
1018   msgbuf[0] = 0x04; /* STATUS command. */
1019   len = 0;
1020   msgbuf[1] = (len >> 24);
1021   msgbuf[2] = (len >> 16);
1022   msgbuf[3] = (len >>  8);
1023   msgbuf[4] = (len      );
1024   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
1025     {
1026       log_error ("error sending PC/SC STATUS request: %s\n",
1027                  strerror (errno));
1028       goto command_failed;
1029     }
1030
1031   /* Read the response. */
1032   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1033     {
1034       log_error ("error receiving PC/SC STATUS response: %s\n",
1035                  i? strerror (errno) : "premature EOF");
1036       goto command_failed;
1037     }
1038   len = buf_to_size_t (msgbuf+1);
1039   if (msgbuf[0] != 0x81 || len < 4)
1040     {
1041       log_error ("invalid response header from PC/SC received\n");
1042       goto command_failed;
1043     }
1044   len -= 4; /* Already read the error code. */
1045   err = PCSC_ERR_MASK (buf32_to_ulong (msgbuf+5));
1046   if (err)
1047     {
1048       log_error ("pcsc_status failed: %s (0x%lx)\n",
1049                  pcsc_error_string (err), err);
1050       /* This is a proper error code, so return immediately.  */
1051       return pcsc_error_to_sw (err);
1052     }
1053
1054   full_len = len;
1055
1056   /* The current version returns 3 words but we allow also for old
1057      versions returning only 2 words. */
1058   n = 12 < len ? 12 : len;
1059   if ((i=readn (slotp->pcsc.rsp_fd, buffer, n, &len))
1060       || (len != 8 && len != 12))
1061     {
1062       log_error ("error receiving PC/SC STATUS response: %s\n",
1063                  i? strerror (errno) : "premature EOF");
1064       goto command_failed;
1065     }
1066
1067   slotp->is_t0 = (len == 12 && !!(buffer[11] & PCSC_PROTOCOL_T0));
1068
1069
1070   full_len -= len;
1071   /* Newer versions of the wrapper might send more status bytes.
1072      Read them. */
1073   while (full_len)
1074     {
1075       unsigned char dummybuf[128];
1076
1077       n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
1078       if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
1079         {
1080           log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1081                      i? strerror (errno) : "premature EOF");
1082           goto command_failed;
1083         }
1084       full_len -= n;
1085     }
1086
1087   /* We are lucky: The wrapper already returns the data in the
1088      required format. */
1089   *status = buffer[3];
1090   return 0;
1091
1092  command_failed:
1093   close (slotp->pcsc.req_fd);
1094   close (slotp->pcsc.rsp_fd);
1095   slotp->pcsc.req_fd = -1;
1096   slotp->pcsc.rsp_fd = -1;
1097   if (slotp->pcsc.pid != -1)
1098     kill (slotp->pcsc.pid, SIGTERM);
1099   slotp->pcsc.pid = (pid_t)(-1);
1100   slotp->used = 0;
1101   return sw;
1102 }
1103 #endif /*NEED_PCSC_WRAPPER*/
1104
1105
1106 static int
1107 pcsc_get_status (int slot, unsigned int *status, int on_wire)
1108 {
1109 #ifdef NEED_PCSC_WRAPPER
1110   return pcsc_get_status_wrapped (slot, status, on_wire);
1111 #else
1112   return pcsc_get_status_direct (slot, status, on_wire);
1113 #endif
1114 }
1115
1116
1117 #ifndef NEED_PCSC_WRAPPER
1118 static int
1119 pcsc_send_apdu_direct (int slot, unsigned char *apdu, size_t apdulen,
1120                        unsigned char *buffer, size_t *buflen,
1121                        pininfo_t *pininfo)
1122 {
1123   long err;
1124   struct pcsc_io_request_s send_pci;
1125   pcsc_dword_t recv_len;
1126
1127   (void)pininfo;
1128
1129   if (!reader_table[slot].atrlen
1130       && (err = reset_pcsc_reader (slot)))
1131     return err;
1132
1133   if (DBG_CARD_IO)
1134     log_printhex ("  PCSC_data:", apdu, apdulen);
1135
1136   if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
1137       send_pci.protocol = PCSC_PROTOCOL_T1;
1138   else
1139       send_pci.protocol = PCSC_PROTOCOL_T0;
1140   send_pci.pci_len = sizeof send_pci;
1141   recv_len = *buflen;
1142   err = pcsc_transmit (reader_table[slot].pcsc.card,
1143                        &send_pci, apdu, apdulen,
1144                        NULL, buffer, &recv_len);
1145   *buflen = recv_len;
1146   if (err)
1147     log_error ("pcsc_transmit failed: %s (0x%lx)\n",
1148                pcsc_error_string (err), err);
1149
1150   return pcsc_error_to_sw (err);
1151 }
1152 #endif /*!NEED_PCSC_WRAPPER*/
1153
1154
1155 #ifdef NEED_PCSC_WRAPPER
1156 static int
1157 pcsc_send_apdu_wrapped (int slot, unsigned char *apdu, size_t apdulen,
1158                         unsigned char *buffer, size_t *buflen,
1159                         pininfo_t *pininfo)
1160 {
1161   long err;
1162   reader_table_t slotp;
1163   size_t len, full_len;
1164   int i, n;
1165   unsigned char msgbuf[9];
1166   int sw = SW_HOST_CARD_IO_ERROR;
1167
1168   (void)pininfo;
1169
1170   if (!reader_table[slot].atrlen
1171       && (err = reset_pcsc_reader (slot)))
1172     return err;
1173
1174   if (DBG_CARD_IO)
1175     log_printhex ("  PCSC_data:", apdu, apdulen);
1176
1177   slotp = reader_table + slot;
1178
1179   if (slotp->pcsc.req_fd == -1
1180       || slotp->pcsc.rsp_fd == -1
1181       || slotp->pcsc.pid == (pid_t)(-1) )
1182     {
1183       log_error ("pcsc_send_apdu: pcsc-wrapper not running\n");
1184       return sw;
1185     }
1186
1187   msgbuf[0] = 0x03; /* TRANSMIT command. */
1188   len = apdulen;
1189   msgbuf[1] = (len >> 24);
1190   msgbuf[2] = (len >> 16);
1191   msgbuf[3] = (len >>  8);
1192   msgbuf[4] = (len      );
1193   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
1194        || writen (slotp->pcsc.req_fd, apdu, len))
1195     {
1196       log_error ("error sending PC/SC TRANSMIT request: %s\n",
1197                  strerror (errno));
1198       goto command_failed;
1199     }
1200
1201   /* Read the response. */
1202   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1203     {
1204       log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1205                  i? strerror (errno) : "premature EOF");
1206       goto command_failed;
1207     }
1208   len = buf_to_size_t (msgbuf+1);
1209   if (msgbuf[0] != 0x81 || len < 4)
1210     {
1211       log_error ("invalid response header from PC/SC received\n");
1212       goto command_failed;
1213     }
1214   len -= 4; /* Already read the error code. */
1215   err = PCSC_ERR_MASK (buf32_to_ulong (msgbuf+5));
1216   if (err)
1217     {
1218       log_error ("pcsc_transmit failed: %s (0x%lx)\n",
1219                  pcsc_error_string (err), err);
1220       return pcsc_error_to_sw (err);
1221     }
1222
1223    full_len = len;
1224
1225    n = *buflen < len ? *buflen : len;
1226    if ((i=readn (slotp->pcsc.rsp_fd, buffer, n, &len)) || len != n)
1227      {
1228        log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1229                   i? strerror (errno) : "premature EOF");
1230        goto command_failed;
1231      }
1232    *buflen = n;
1233
1234    full_len -= len;
1235    if (full_len)
1236      {
1237        log_error ("pcsc_send_apdu: provided buffer too short - truncated\n");
1238        err = SW_HOST_INV_VALUE;
1239      }
1240    /* We need to read any rest of the response, to keep the
1241       protocol running.  */
1242    while (full_len)
1243      {
1244        unsigned char dummybuf[128];
1245
1246        n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
1247        if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
1248          {
1249            log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1250                       i? strerror (errno) : "premature EOF");
1251            goto command_failed;
1252          }
1253        full_len -= n;
1254      }
1255
1256    return err;
1257
1258  command_failed:
1259   close (slotp->pcsc.req_fd);
1260   close (slotp->pcsc.rsp_fd);
1261   slotp->pcsc.req_fd = -1;
1262   slotp->pcsc.rsp_fd = -1;
1263   if (slotp->pcsc.pid != -1)
1264     kill (slotp->pcsc.pid, SIGTERM);
1265   slotp->pcsc.pid = (pid_t)(-1);
1266   slotp->used = 0;
1267   return sw;
1268 }
1269 #endif /*NEED_PCSC_WRAPPER*/
1270
1271
1272 /* Send the APDU of length APDULEN to SLOT and return a maximum of
1273    *BUFLEN data in BUFFER, the actual returned size will be stored at
1274    BUFLEN.  Returns: A status word. */
1275 static int
1276 pcsc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
1277                 unsigned char *buffer, size_t *buflen,
1278                 pininfo_t *pininfo)
1279 {
1280 #ifdef NEED_PCSC_WRAPPER
1281   return pcsc_send_apdu_wrapped (slot, apdu, apdulen, buffer, buflen, pininfo);
1282 #else
1283   return pcsc_send_apdu_direct (slot, apdu, apdulen, buffer, buflen, pininfo);
1284 #endif
1285 }
1286
1287
1288 #ifndef NEED_PCSC_WRAPPER
1289 static int
1290 control_pcsc_direct (int slot, pcsc_dword_t ioctl_code,
1291                      const unsigned char *cntlbuf, size_t len,
1292                      unsigned char *buffer, pcsc_dword_t *buflen)
1293 {
1294   long err;
1295
1296   err = pcsc_control (reader_table[slot].pcsc.card, ioctl_code,
1297                       cntlbuf, len, buffer, buflen? *buflen:0, buflen);
1298   if (err)
1299     {
1300       log_error ("pcsc_control failed: %s (0x%lx)\n",
1301                  pcsc_error_string (err), err);
1302       return pcsc_error_to_sw (err);
1303     }
1304
1305   return 0;
1306 }
1307 #endif /*!NEED_PCSC_WRAPPER*/
1308
1309
1310 #ifdef NEED_PCSC_WRAPPER
1311 static int
1312 control_pcsc_wrapped (int slot, pcsc_dword_t ioctl_code,
1313                       const unsigned char *cntlbuf, size_t len,
1314                       unsigned char *buffer, pcsc_dword_t *buflen)
1315 {
1316   long err = PCSC_E_NOT_TRANSACTED;
1317   reader_table_t slotp;
1318   unsigned char msgbuf[9];
1319   int i, n;
1320   size_t full_len;
1321
1322   slotp = reader_table + slot;
1323
1324   msgbuf[0] = 0x06; /* CONTROL command. */
1325   msgbuf[1] = ((len + 4) >> 24);
1326   msgbuf[2] = ((len + 4) >> 16);
1327   msgbuf[3] = ((len + 4) >>  8);
1328   msgbuf[4] = ((len + 4)      );
1329   msgbuf[5] = (ioctl_code >> 24);
1330   msgbuf[6] = (ioctl_code >> 16);
1331   msgbuf[7] = (ioctl_code >>  8);
1332   msgbuf[8] = (ioctl_code      );
1333   if ( writen (slotp->pcsc.req_fd, msgbuf, 9)
1334        || writen (slotp->pcsc.req_fd, cntlbuf, len))
1335     {
1336       log_error ("error sending PC/SC CONTROL request: %s\n",
1337                  strerror (errno));
1338       goto command_failed;
1339     }
1340
1341   /* Read the response. */
1342   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1343     {
1344       log_error ("error receiving PC/SC CONTROL response: %s\n",
1345                  i? strerror (errno) : "premature EOF");
1346       goto command_failed;
1347     }
1348   len = buf32_to_size_t (msgbuf+1);
1349   if (msgbuf[0] != 0x81 || len < 4)
1350     {
1351       log_error ("invalid response header from PC/SC received\n");
1352       goto command_failed;
1353     }
1354   len -= 4; /* Already read the error code. */
1355   err = PCSC_ERR_MASK (buf32_to_ulong (msgbuf+5));
1356   if (err)
1357     {
1358       log_error ("pcsc_control failed: %s (0x%lx)\n",
1359                  pcsc_error_string (err), err);
1360       return pcsc_error_to_sw (err);
1361     }
1362
1363   full_len = len;
1364
1365   if (buflen)
1366     n = *buflen < len ? *buflen : len;
1367   else
1368     n = 0;
1369   if ((i=readn (slotp->pcsc.rsp_fd, buffer, n, &len)) || len != n)
1370     {
1371       log_error ("error receiving PC/SC CONTROL response: %s\n",
1372                  i? strerror (errno) : "premature EOF");
1373       goto command_failed;
1374     }
1375   if (buflen)
1376     *buflen = n;
1377
1378   full_len -= len;
1379   if (full_len)
1380     {
1381       log_error ("pcsc_send_apdu: provided buffer too short - truncated\n");
1382       err = PCSC_E_INVALID_VALUE;
1383     }
1384   /* We need to read any rest of the response, to keep the
1385      protocol running.  */
1386   while (full_len)
1387     {
1388       unsigned char dummybuf[128];
1389
1390       n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
1391       if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
1392         {
1393           log_error ("error receiving PC/SC CONTROL response: %s\n",
1394                      i? strerror (errno) : "premature EOF");
1395           goto command_failed;
1396         }
1397       full_len -= n;
1398     }
1399
1400   if (!err)
1401     return 0;
1402
1403  command_failed:
1404   close (slotp->pcsc.req_fd);
1405   close (slotp->pcsc.rsp_fd);
1406   slotp->pcsc.req_fd = -1;
1407   slotp->pcsc.rsp_fd = -1;
1408   if (slotp->pcsc.pid != -1)
1409     kill (slotp->pcsc.pid, SIGTERM);
1410   slotp->pcsc.pid = (pid_t)(-1);
1411   slotp->used = 0;
1412   return pcsc_error_to_sw (err);
1413 }
1414 #endif /*NEED_PCSC_WRAPPER*/
1415
1416
1417
1418 /* Do some control with the value of IOCTL_CODE to the card inserted
1419    to SLOT.  Input buffer is specified by CNTLBUF of length LEN.
1420    Output buffer is specified by BUFFER of length *BUFLEN, and the
1421    actual output size will be stored at BUFLEN.  Returns: A status word.
1422    This routine is used for PIN pad input support.  */
1423 static int
1424 control_pcsc (int slot, pcsc_dword_t ioctl_code,
1425               const unsigned char *cntlbuf, size_t len,
1426               unsigned char *buffer, pcsc_dword_t *buflen)
1427 {
1428 #ifdef NEED_PCSC_WRAPPER
1429   return control_pcsc_wrapped (slot, ioctl_code, cntlbuf, len, buffer, buflen);
1430 #else
1431   return control_pcsc_direct (slot, ioctl_code, cntlbuf, len, buffer, buflen);
1432 #endif
1433 }
1434
1435
1436 #ifndef NEED_PCSC_WRAPPER
1437 static int
1438 close_pcsc_reader_direct (int slot)
1439 {
1440   pcsc_release_context (reader_table[slot].pcsc.context);
1441   return 0;
1442 }
1443 #endif /*!NEED_PCSC_WRAPPER*/
1444
1445
1446 #ifdef NEED_PCSC_WRAPPER
1447 static int
1448 close_pcsc_reader_wrapped (int slot)
1449 {
1450   long err;
1451   reader_table_t slotp;
1452   size_t len;
1453   int i;
1454   unsigned char msgbuf[9];
1455
1456   slotp = reader_table + slot;
1457
1458   if (slotp->pcsc.req_fd == -1
1459       || slotp->pcsc.rsp_fd == -1
1460       || slotp->pcsc.pid == (pid_t)(-1) )
1461     {
1462       log_error ("close_pcsc_reader: pcsc-wrapper not running\n");
1463       return 0;
1464     }
1465
1466   msgbuf[0] = 0x02; /* CLOSE command. */
1467   len = 0;
1468   msgbuf[1] = (len >> 24);
1469   msgbuf[2] = (len >> 16);
1470   msgbuf[3] = (len >>  8);
1471   msgbuf[4] = (len      );
1472   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
1473     {
1474       log_error ("error sending PC/SC CLOSE request: %s\n",
1475                  strerror (errno));
1476       goto command_failed;
1477     }
1478
1479   /* Read the response. */
1480   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1481     {
1482       log_error ("error receiving PC/SC CLOSE response: %s\n",
1483                  i? strerror (errno) : "premature EOF");
1484       goto command_failed;
1485     }
1486   len = buf32_to_size_t (msgbuf+1);
1487   if (msgbuf[0] != 0x81 || len < 4)
1488     {
1489       log_error ("invalid response header from PC/SC received\n");
1490       goto command_failed;
1491     }
1492   len -= 4; /* Already read the error code. */
1493   err = PCSC_ERR_MASK (buf32_to_ulong (msgbuf+5));
1494   if (err)
1495     log_error ("pcsc_close failed: %s (0x%lx)\n",
1496                pcsc_error_string (err), err);
1497
1498   /* We will close the wrapper in any case - errors are merely
1499      informational. */
1500
1501  command_failed:
1502   close (slotp->pcsc.req_fd);
1503   close (slotp->pcsc.rsp_fd);
1504   slotp->pcsc.req_fd = -1;
1505   slotp->pcsc.rsp_fd = -1;
1506   if (slotp->pcsc.pid != -1)
1507     kill (slotp->pcsc.pid, SIGTERM);
1508   slotp->pcsc.pid = (pid_t)(-1);
1509   slotp->used = 0;
1510   return 0;
1511 }
1512 #endif /*NEED_PCSC_WRAPPER*/
1513
1514
1515 static int
1516 close_pcsc_reader (int slot)
1517 {
1518 #ifdef NEED_PCSC_WRAPPER
1519   return close_pcsc_reader_wrapped (slot);
1520 #else
1521   return close_pcsc_reader_direct (slot);
1522 #endif
1523 }
1524
1525
1526 /* Connect a PC/SC card.  */
1527 #ifndef NEED_PCSC_WRAPPER
1528 static int
1529 connect_pcsc_card (int slot)
1530 {
1531   long err;
1532
1533   assert (slot >= 0 && slot < MAX_READER);
1534
1535   if (reader_table[slot].pcsc.card)
1536     return SW_HOST_ALREADY_CONNECTED;
1537
1538   reader_table[slot].atrlen = 0;
1539   reader_table[slot].is_t0 = 0;
1540
1541   err = pcsc_connect (reader_table[slot].pcsc.context,
1542                       reader_table[slot].rdrname,
1543                       PCSC_SHARE_EXCLUSIVE,
1544                       PCSC_PROTOCOL_T0|PCSC_PROTOCOL_T1,
1545                       &reader_table[slot].pcsc.card,
1546                       &reader_table[slot].pcsc.protocol);
1547   if (err)
1548     {
1549       reader_table[slot].pcsc.card = 0;
1550       if (err != PCSC_E_NO_SMARTCARD)
1551         log_error ("pcsc_connect failed: %s (0x%lx)\n",
1552                    pcsc_error_string (err), err);
1553     }
1554   else
1555     {
1556       char reader[250];
1557       pcsc_dword_t readerlen, atrlen;
1558       pcsc_dword_t card_state, card_protocol;
1559
1560       pcsc_vendor_specific_init (slot);
1561
1562       atrlen = DIM (reader_table[0].atr);
1563       readerlen = sizeof reader -1 ;
1564       err = pcsc_status (reader_table[slot].pcsc.card,
1565                          reader, &readerlen,
1566                          &card_state, &card_protocol,
1567                          reader_table[slot].atr, &atrlen);
1568       if (err)
1569         log_error ("pcsc_status failed: %s (0x%lx) %lu\n",
1570                    pcsc_error_string (err), err, (long unsigned int)readerlen);
1571       else
1572         {
1573           if (atrlen > DIM (reader_table[0].atr))
1574             log_bug ("ATR returned by pcsc_status is too large\n");
1575           reader_table[slot].atrlen = atrlen;
1576           reader_table[slot].is_t0 = !!(card_protocol & PCSC_PROTOCOL_T0);
1577         }
1578     }
1579
1580   dump_reader_status (slot);
1581   return pcsc_error_to_sw (err);
1582 }
1583 #endif /*!NEED_PCSC_WRAPPER*/
1584
1585
1586 /* Disconnect a PC/SC card.  Note that this succeeds even if the card
1587    is not connected.  */
1588 #ifndef NEED_PCSC_WRAPPER
1589 static int
1590 disconnect_pcsc_card (int slot)
1591 {
1592   long err;
1593
1594   assert (slot >= 0 && slot < MAX_READER);
1595
1596   if (!reader_table[slot].pcsc.card)
1597     return 0;
1598
1599   err = pcsc_disconnect (reader_table[slot].pcsc.card, PCSC_LEAVE_CARD);
1600   if (err)
1601     {
1602       log_error ("pcsc_disconnect failed: %s (0x%lx)\n",
1603                  pcsc_error_string (err), err);
1604       return SW_HOST_CARD_IO_ERROR;
1605     }
1606   reader_table[slot].pcsc.card = 0;
1607   return 0;
1608 }
1609 #endif /*!NEED_PCSC_WRAPPER*/
1610
1611
1612 #ifndef NEED_PCSC_WRAPPER
1613 static int
1614 reset_pcsc_reader_direct (int slot)
1615 {
1616   int sw;
1617
1618   sw = disconnect_pcsc_card (slot);
1619   if (!sw)
1620     sw = connect_pcsc_card (slot);
1621
1622   return sw;
1623 }
1624 #endif /*NEED_PCSC_WRAPPER*/
1625
1626
1627 #ifdef NEED_PCSC_WRAPPER
1628 static int
1629 reset_pcsc_reader_wrapped (int slot)
1630 {
1631   long err;
1632   reader_table_t slotp;
1633   size_t len;
1634   int i, n;
1635   unsigned char msgbuf[9];
1636   unsigned int dummy_status;
1637   int sw = SW_HOST_CARD_IO_ERROR;
1638
1639   slotp = reader_table + slot;
1640
1641   if (slotp->pcsc.req_fd == -1
1642       || slotp->pcsc.rsp_fd == -1
1643       || slotp->pcsc.pid == (pid_t)(-1) )
1644     {
1645       log_error ("pcsc_get_status: pcsc-wrapper not running\n");
1646       return sw;
1647     }
1648
1649   msgbuf[0] = 0x05; /* RESET command. */
1650   len = 0;
1651   msgbuf[1] = (len >> 24);
1652   msgbuf[2] = (len >> 16);
1653   msgbuf[3] = (len >>  8);
1654   msgbuf[4] = (len      );
1655   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
1656     {
1657       log_error ("error sending PC/SC RESET request: %s\n",
1658                  strerror (errno));
1659       goto command_failed;
1660     }
1661
1662   /* Read the response. */
1663   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1664     {
1665       log_error ("error receiving PC/SC RESET response: %s\n",
1666                  i? strerror (errno) : "premature EOF");
1667       goto command_failed;
1668     }
1669   len = buf32_to_size_t (msgbuf+1);
1670   if (msgbuf[0] != 0x81 || len < 4)
1671     {
1672       log_error ("invalid response header from PC/SC received\n");
1673       goto command_failed;
1674     }
1675   len -= 4; /* Already read the error code. */
1676   if (len > DIM (slotp->atr))
1677     {
1678       log_error ("PC/SC returned a too large ATR (len=%lx)\n",
1679                  (unsigned long)len);
1680       sw = SW_HOST_GENERAL_ERROR;
1681       goto command_failed;
1682     }
1683   err = PCSC_ERR_MASK (buf32_to_ulong (msgbuf+5));
1684   if (err)
1685     {
1686       log_error ("PC/SC RESET failed: %s (0x%lx)\n",
1687                  pcsc_error_string (err), err);
1688       /* If the error code is no smart card, we should not considere
1689          this a major error and close the wrapper.  */
1690       sw = pcsc_error_to_sw (err);
1691       if (err == PCSC_E_NO_SMARTCARD)
1692         return sw;
1693       goto command_failed;
1694     }
1695
1696   /* The open function may return a zero for the ATR length to
1697      indicate that no card is present.  */
1698   n = len;
1699   if (n)
1700     {
1701       if ((i=readn (slotp->pcsc.rsp_fd, slotp->atr, n, &len)) || len != n)
1702         {
1703           log_error ("error receiving PC/SC RESET response: %s\n",
1704                      i? strerror (errno) : "premature EOF");
1705           goto command_failed;
1706         }
1707     }
1708   slotp->atrlen = len;
1709
1710   /* Read the status so that IS_T0 will be set. */
1711   pcsc_get_status (slot, &dummy_status, 1);
1712
1713   return 0;
1714
1715  command_failed:
1716   close (slotp->pcsc.req_fd);
1717   close (slotp->pcsc.rsp_fd);
1718   slotp->pcsc.req_fd = -1;
1719   slotp->pcsc.rsp_fd = -1;
1720   if (slotp->pcsc.pid != -1)
1721     kill (slotp->pcsc.pid, SIGTERM);
1722   slotp->pcsc.pid = (pid_t)(-1);
1723   slotp->used = 0;
1724   return sw;
1725 }
1726 #endif /* !NEED_PCSC_WRAPPER */
1727
1728
1729 /* Send an PC/SC reset command and return a status word on error or 0
1730    on success. */
1731 static int
1732 reset_pcsc_reader (int slot)
1733 {
1734 #ifdef NEED_PCSC_WRAPPER
1735   return reset_pcsc_reader_wrapped (slot);
1736 #else
1737   return reset_pcsc_reader_direct (slot);
1738 #endif
1739 }
1740
1741
1742 /* Examine reader specific parameters and initialize.  This is mostly
1743    for pinpad input.  Called at opening the connection to the reader.  */
1744 static int
1745 pcsc_vendor_specific_init (int slot)
1746 {
1747   unsigned char buf[256];
1748   pcsc_dword_t len;
1749   int sw;
1750   int vendor = 0;
1751   int product = 0;
1752   pcsc_dword_t get_tlv_ioctl = (pcsc_dword_t)-1;
1753   unsigned char *p;
1754
1755   len = sizeof (buf);
1756   sw = control_pcsc (slot, CM_IOCTL_GET_FEATURE_REQUEST, NULL, 0, buf, &len);
1757   if (sw)
1758     {
1759       log_error ("pcsc_vendor_specific_init: GET_FEATURE_REQUEST failed: %d\n",
1760                  sw);
1761       return SW_NOT_SUPPORTED;
1762     }
1763   else
1764     {
1765       p = buf;
1766       while (p < buf + len)
1767         {
1768           unsigned char code = *p++;
1769           int l = *p++;
1770           unsigned int v = 0;
1771
1772           if (l == 1)
1773             v = p[0];
1774           else if (l == 2)
1775             v = buf16_to_uint (p);
1776           else if (l == 4)
1777             v = buf32_to_uint (p);
1778
1779           if (code == FEATURE_VERIFY_PIN_DIRECT)
1780             reader_table[slot].pcsc.verify_ioctl = v;
1781           else if (code == FEATURE_MODIFY_PIN_DIRECT)
1782             reader_table[slot].pcsc.modify_ioctl = v;
1783           else if (code == FEATURE_GET_TLV_PROPERTIES)
1784             get_tlv_ioctl = v;
1785
1786           if (DBG_CARD_IO)
1787             log_debug ("feature: code=%02X, len=%d, v=%02X\n", code, l, v);
1788
1789           p += l;
1790         }
1791     }
1792
1793   if (get_tlv_ioctl == (pcsc_dword_t)-1)
1794     {
1795       /*
1796        * For system which doesn't support GET_TLV_PROPERTIES,
1797        * we put some heuristics here.
1798        */
1799       if (reader_table[slot].rdrname)
1800         {
1801           if (strstr (reader_table[slot].rdrname, "SPRx32"))
1802             {
1803               reader_table[slot].is_spr532 = 1;
1804               reader_table[slot].pinpad_varlen_supported = 1;
1805             }
1806           else if (strstr (reader_table[slot].rdrname, "ST-2xxx"))
1807             {
1808               reader_table[slot].pcsc.pinmax = 15;
1809               reader_table[slot].pinpad_varlen_supported = 1;
1810             }
1811           else if (strstr (reader_table[slot].rdrname, "cyberJack")
1812                    || strstr (reader_table[slot].rdrname, "DIGIPASS")
1813                    || strstr (reader_table[slot].rdrname, "Gnuk")
1814                    || strstr (reader_table[slot].rdrname, "KAAN"))
1815             reader_table[slot].pinpad_varlen_supported = 1;
1816         }
1817
1818       return 0;
1819     }
1820
1821   len = sizeof (buf);
1822   sw = control_pcsc (slot, get_tlv_ioctl, NULL, 0, buf, &len);
1823   if (sw)
1824     {
1825       log_error ("pcsc_vendor_specific_init: GET_TLV_IOCTL failed: %d\n", sw);
1826       return SW_NOT_SUPPORTED;
1827     }
1828
1829   p = buf;
1830   while (p < buf + len)
1831     {
1832       unsigned char tag = *p++;
1833       int l = *p++;
1834       unsigned int v = 0;
1835
1836       /* Umm... here is little endian, while the encoding above is big.  */
1837       if (l == 1)
1838         v = p[0];
1839       else if (l == 2)
1840         v = (((unsigned int)p[1] << 8) | p[0]);
1841       else if (l == 4)
1842         v = (((unsigned int)p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]);
1843
1844       if (tag == PCSCv2_PART10_PROPERTY_bMinPINSize)
1845         reader_table[slot].pcsc.pinmin = v;
1846       else if (tag == PCSCv2_PART10_PROPERTY_bMaxPINSize)
1847         reader_table[slot].pcsc.pinmax = v;
1848       else if (tag == PCSCv2_PART10_PROPERTY_wIdVendor)
1849         vendor = v;
1850       else if (tag == PCSCv2_PART10_PROPERTY_wIdProduct)
1851         product = v;
1852
1853       if (DBG_CARD_IO)
1854         log_debug ("TLV properties: tag=%02X, len=%d, v=%08X\n", tag, l, v);
1855
1856       p += l;
1857     }
1858
1859   if (vendor == VENDOR_VEGA && product == VEGA_ALPHA)
1860     {
1861       /*
1862        * Please read the comment of ccid_vendor_specific_init in
1863        * ccid-driver.c.
1864        */
1865       const unsigned char cmd[] = { '\xb5', '\x01', '\x00', '\x03', '\x00' };
1866       sw = control_pcsc (slot, CM_IOCTL_VENDOR_IFD_EXCHANGE,
1867                          cmd, sizeof (cmd), NULL, 0);
1868       if (sw)
1869         return SW_NOT_SUPPORTED;
1870     }
1871   else if (vendor == VENDOR_SCM && product == SCM_SPR532) /* SCM SPR532 */
1872     {
1873       reader_table[slot].is_spr532 = 1;
1874       reader_table[slot].pinpad_varlen_supported = 1;
1875     }
1876   else if (vendor == 0x046a)
1877     {
1878       /* Cherry ST-2xxx (product == 0x003e) supports TPDU level
1879        * exchange.  Other products which only support short APDU level
1880        * exchange only work with shorter keys like RSA 1024.
1881        */
1882       reader_table[slot].pcsc.pinmax = 15;
1883       reader_table[slot].pinpad_varlen_supported = 1;
1884     }
1885   else if (vendor == 0x0c4b /* Tested with Reiner cyberJack GO */
1886            || vendor == 0x1a44 /* Tested with Vasco DIGIPASS 920 */
1887            || vendor == 0x234b /* Tested with FSIJ Gnuk Token */
1888            || vendor == 0x0d46 /* Tested with KAAN Advanced??? */)
1889     reader_table[slot].pinpad_varlen_supported = 1;
1890
1891   return 0;
1892 }
1893
1894
1895 /* Open the PC/SC reader without using the wrapper.  Returns -1 on
1896    error or a slot number for the reader.  */
1897 #ifndef NEED_PCSC_WRAPPER
1898 static int
1899 open_pcsc_reader_direct (const char *portstr)
1900 {
1901   long err;
1902   int slot;
1903   char *list = NULL;
1904   char *rdrname = NULL;
1905   pcsc_dword_t nreader;
1906   char *p;
1907
1908   slot = new_reader_slot ();
1909   if (slot == -1)
1910     return -1;
1911
1912   /* Fixme: Allocating a context for each slot is not required.  One
1913      global context should be sufficient.  */
1914   err = pcsc_establish_context (PCSC_SCOPE_SYSTEM, NULL, NULL,
1915                                 &reader_table[slot].pcsc.context);
1916   if (err)
1917     {
1918       log_error ("pcsc_establish_context failed: %s (0x%lx)\n",
1919                  pcsc_error_string (err), err);
1920       reader_table[slot].used = 0;
1921       unlock_slot (slot);
1922       return -1;
1923     }
1924
1925   err = pcsc_list_readers (reader_table[slot].pcsc.context,
1926                            NULL, NULL, &nreader);
1927   if (!err)
1928     {
1929       list = xtrymalloc (nreader+1); /* Better add 1 for safety reasons. */
1930       if (!list)
1931         {
1932           log_error ("error allocating memory for reader list\n");
1933           pcsc_release_context (reader_table[slot].pcsc.context);
1934           reader_table[slot].used = 0;
1935           unlock_slot (slot);
1936           return -1 /*SW_HOST_OUT_OF_CORE*/;
1937         }
1938       err = pcsc_list_readers (reader_table[slot].pcsc.context,
1939                                NULL, list, &nreader);
1940     }
1941   if (err)
1942     {
1943       log_error ("pcsc_list_readers failed: %s (0x%lx)\n",
1944                  pcsc_error_string (err), err);
1945       pcsc_release_context (reader_table[slot].pcsc.context);
1946       reader_table[slot].used = 0;
1947       xfree (list);
1948       unlock_slot (slot);
1949       return -1;
1950     }
1951
1952   p = list;
1953   while (nreader)
1954     {
1955       if (!*p && !p[1])
1956         break;
1957       log_info ("detected reader '%s'\n", p);
1958       if (nreader < (strlen (p)+1))
1959         {
1960           log_error ("invalid response from pcsc_list_readers\n");
1961           break;
1962         }
1963       if (!rdrname && portstr && !strncmp (p, portstr, strlen (portstr)))
1964         rdrname = p;
1965       nreader -= strlen (p)+1;
1966       p += strlen (p) + 1;
1967     }
1968
1969   if (!rdrname)
1970     rdrname = list;
1971
1972   reader_table[slot].rdrname = xtrystrdup (rdrname);
1973   if (!reader_table[slot].rdrname)
1974     {
1975       log_error ("error allocating memory for reader name\n");
1976       pcsc_release_context (reader_table[slot].pcsc.context);
1977       reader_table[slot].used = 0;
1978       unlock_slot (slot);
1979       return -1;
1980     }
1981   xfree (list);
1982   list = NULL;
1983
1984   reader_table[slot].pcsc.card = 0;
1985   reader_table[slot].atrlen = 0;
1986
1987   reader_table[slot].connect_card = connect_pcsc_card;
1988   reader_table[slot].disconnect_card = disconnect_pcsc_card;
1989   reader_table[slot].close_reader = close_pcsc_reader;
1990   reader_table[slot].reset_reader = reset_pcsc_reader;
1991   reader_table[slot].get_status_reader = pcsc_get_status;
1992   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
1993   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
1994
1995   dump_reader_status (slot);
1996   unlock_slot (slot);
1997   return slot;
1998 }
1999 #endif /*!NEED_PCSC_WRAPPER */
2000
2001
2002 /* Open the PC/SC reader using the pcsc_wrapper program.  This is
2003    needed to cope with different thread models and other peculiarities
2004    of libpcsclite. */
2005 #ifdef NEED_PCSC_WRAPPER
2006 static int
2007 open_pcsc_reader_wrapped (const char *portstr)
2008 {
2009   int slot;
2010   reader_table_t slotp;
2011   int fd, rp[2], wp[2];
2012   int n, i;
2013   pid_t pid;
2014   size_t len;
2015   unsigned char msgbuf[9];
2016   int err;
2017   unsigned int dummy_status;
2018
2019   /* Note that we use the constant and not the function because this
2020      code won't be used under Windows.  */
2021   const char *wrapperpgm = GNUPG_LIBEXECDIR "/gnupg-pcsc-wrapper";
2022
2023   if (access (wrapperpgm, X_OK))
2024     {
2025       log_error ("can't run PC/SC access module '%s': %s\n",
2026                  wrapperpgm, strerror (errno));
2027       return -1;
2028     }
2029
2030   slot = new_reader_slot ();
2031   if (slot == -1)
2032     return -1;
2033   slotp = reader_table + slot;
2034
2035   /* Fire up the PC/SCc wrapper.  We don't use any fork/exec code from
2036      the common directy but implement it directly so that this file
2037      may still be source copied. */
2038
2039   if (pipe (rp) == -1)
2040     {
2041       log_error ("error creating a pipe: %s\n", strerror (errno));
2042       slotp->used = 0;
2043       unlock_slot (slot);
2044       return -1;
2045     }
2046   if (pipe (wp) == -1)
2047     {
2048       log_error ("error creating a pipe: %s\n", strerror (errno));
2049       close (rp[0]);
2050       close (rp[1]);
2051       slotp->used = 0;
2052       unlock_slot (slot);
2053       return -1;
2054     }
2055
2056   pid = fork ();
2057   if (pid == -1)
2058     {
2059       log_error ("error forking process: %s\n", strerror (errno));
2060       close (rp[0]);
2061       close (rp[1]);
2062       close (wp[0]);
2063       close (wp[1]);
2064       slotp->used = 0;
2065       unlock_slot (slot);
2066       return -1;
2067     }
2068   slotp->pcsc.pid = pid;
2069
2070   if (!pid)
2071     { /*
2072          === Child ===
2073        */
2074
2075       /* Double fork. */
2076       pid = fork ();
2077       if (pid == -1)
2078         _exit (31);
2079       if (pid)
2080         _exit (0); /* Immediate exit this parent, so that the child
2081                       gets cleaned up by the init process. */
2082
2083       /* Connect our pipes. */
2084       if (wp[0] != 0 && dup2 (wp[0], 0) == -1)
2085         log_fatal ("dup2 stdin failed: %s\n", strerror (errno));
2086       if (rp[1] != 1 && dup2 (rp[1], 1) == -1)
2087         log_fatal ("dup2 stdout failed: %s\n", strerror (errno));
2088
2089       /* Send stderr to the bit bucket. */
2090       fd = open ("/dev/null", O_WRONLY);
2091       if (fd == -1)
2092         log_fatal ("can't open '/dev/null': %s", strerror (errno));
2093       if (fd != 2 && dup2 (fd, 2) == -1)
2094         log_fatal ("dup2 stderr failed: %s\n", strerror (errno));
2095
2096       /* Close all other files. */
2097       close_all_fds (3, NULL);
2098
2099       execl (wrapperpgm,
2100              "pcsc-wrapper",
2101              "--",
2102              "1", /* API version */
2103              opt.pcsc_driver, /* Name of the PC/SC library. */
2104               NULL);
2105       _exit (31);
2106     }
2107
2108   /*
2109      === Parent ===
2110    */
2111   close (wp[0]);
2112   close (rp[1]);
2113   slotp->pcsc.req_fd = wp[1];
2114   slotp->pcsc.rsp_fd = rp[0];
2115
2116   /* Wait for the intermediate child to terminate. */
2117 #ifdef USE_NPTH
2118 #define WAIT npth_waitpid
2119 #else
2120 #define WAIT waitpid
2121 #endif
2122   while ( (i=WAIT (pid, NULL, 0)) == -1 && errno == EINTR)
2123     ;
2124 #undef WAIT
2125
2126   /* Now send the open request. */
2127   msgbuf[0] = 0x01; /* OPEN command. */
2128   len = portstr? strlen (portstr):0;
2129   msgbuf[1] = (len >> 24);
2130   msgbuf[2] = (len >> 16);
2131   msgbuf[3] = (len >>  8);
2132   msgbuf[4] = (len      );
2133   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
2134        || (portstr && writen (slotp->pcsc.req_fd, portstr, len)))
2135     {
2136       log_error ("error sending PC/SC OPEN request: %s\n",
2137                  strerror (errno));
2138       goto command_failed;
2139     }
2140   /* Read the response. */
2141   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
2142     {
2143       log_error ("error receiving PC/SC OPEN response: %s\n",
2144                  i? strerror (errno) : "premature EOF");
2145       goto command_failed;
2146     }
2147   len = buf32_to_size_t (msgbuf+1);
2148   if (msgbuf[0] != 0x81 || len < 4)
2149     {
2150       log_error ("invalid response header from PC/SC received\n");
2151       goto command_failed;
2152     }
2153   len -= 4; /* Already read the error code. */
2154   if (len > DIM (slotp->atr))
2155     {
2156       log_error ("PC/SC returned a too large ATR (len=%lx)\n",
2157                  (unsigned long)len);
2158       goto command_failed;
2159     }
2160   err = PCSC_ERR_MASK (buf32_to_ulong (msgbuf+5));
2161   if (err)
2162     {
2163       log_error ("PC/SC OPEN failed: %s\n", pcsc_error_string (err));
2164       goto command_failed;
2165     }
2166
2167   /* The open request may return a zero for the ATR length to
2168      indicate that no card is present.  */
2169   n = len;
2170   if (n)
2171     {
2172       if ((i=readn (slotp->pcsc.rsp_fd, slotp->atr, n, &len)) || len != n)
2173         {
2174           log_error ("error receiving PC/SC OPEN response: %s\n",
2175                      i? strerror (errno) : "premature EOF");
2176           goto command_failed;
2177         }
2178     }
2179   slotp->atrlen = len;
2180
2181   reader_table[slot].close_reader = close_pcsc_reader;
2182   reader_table[slot].reset_reader = reset_pcsc_reader;
2183   reader_table[slot].get_status_reader = pcsc_get_status;
2184   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
2185   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
2186
2187   pcsc_vendor_specific_init (slot);
2188
2189   /* Read the status so that IS_T0 will be set. */
2190   pcsc_get_status (slot, &dummy_status, 1);
2191
2192   dump_reader_status (slot);
2193   unlock_slot (slot);
2194   return slot;
2195
2196  command_failed:
2197   close (slotp->pcsc.req_fd);
2198   close (slotp->pcsc.rsp_fd);
2199   slotp->pcsc.req_fd = -1;
2200   slotp->pcsc.rsp_fd = -1;
2201   if (slotp->pcsc.pid != -1)
2202     kill (slotp->pcsc.pid, SIGTERM);
2203   slotp->pcsc.pid = (pid_t)(-1);
2204   slotp->used = 0;
2205   unlock_slot (slot);
2206   /* There is no way to return SW. */
2207   return -1;
2208
2209 }
2210 #endif /*NEED_PCSC_WRAPPER*/
2211
2212
2213 static int
2214 open_pcsc_reader (const char *portstr)
2215 {
2216 #ifdef NEED_PCSC_WRAPPER
2217   return open_pcsc_reader_wrapped (portstr);
2218 #else
2219   return open_pcsc_reader_direct (portstr);
2220 #endif
2221 }
2222
2223
2224 /* Check whether the reader supports the ISO command code COMMAND
2225    on the pinpad.  Return 0 on success.  */
2226 static int
2227 check_pcsc_pinpad (int slot, int command, pininfo_t *pininfo)
2228 {
2229   int r;
2230
2231   if (reader_table[slot].pcsc.pinmin >= 0)
2232     pininfo->minlen = reader_table[slot].pcsc.pinmin;
2233
2234   if (reader_table[slot].pcsc.pinmax >= 0)
2235     pininfo->maxlen = reader_table[slot].pcsc.pinmax;
2236
2237   if (!pininfo->minlen)
2238     pininfo->minlen = 1;
2239   if (!pininfo->maxlen)
2240     pininfo->maxlen = 15;
2241
2242   if ((command == ISO7816_VERIFY && reader_table[slot].pcsc.verify_ioctl != 0)
2243       || (command == ISO7816_CHANGE_REFERENCE_DATA
2244           && reader_table[slot].pcsc.modify_ioctl != 0))
2245     r = 0;                       /* Success */
2246   else
2247     r = SW_NOT_SUPPORTED;
2248
2249   if (DBG_CARD_IO)
2250     log_debug ("check_pcsc_pinpad: command=%02X, r=%d\n",
2251                (unsigned int)command, r);
2252
2253   if (reader_table[slot].pinpad_varlen_supported)
2254     pininfo->fixedlen = 0;
2255
2256   return r;
2257 }
2258
2259 #define PIN_VERIFY_STRUCTURE_SIZE 24
2260 static int
2261 pcsc_pinpad_verify (int slot, int class, int ins, int p0, int p1,
2262                     pininfo_t *pininfo)
2263 {
2264   int sw;
2265   unsigned char *pin_verify;
2266   int len = PIN_VERIFY_STRUCTURE_SIZE + pininfo->fixedlen;
2267   /*
2268    * The result buffer is only expected to have two-byte result on
2269    * return.  However, some implementation uses this buffer for lower
2270    * layer too and it assumes that there is enough space for lower
2271    * layer communication.  Such an implementation fails for TPDU
2272    * readers with "insufficient buffer", as it needs header and
2273    * trailer.  Six is the number for header + result + trailer (TPDU).
2274    */
2275   unsigned char result[6];
2276   pcsc_dword_t resultlen = 6;
2277   int no_lc;
2278
2279   if (!reader_table[slot].atrlen
2280       && (sw = reset_pcsc_reader (slot)))
2281     return sw;
2282
2283   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2284     return SW_NOT_SUPPORTED;
2285
2286   pin_verify = xtrymalloc (len);
2287   if (!pin_verify)
2288     return SW_HOST_OUT_OF_CORE;
2289
2290   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2291
2292   pin_verify[0] = 0x00; /* bTimeOut */
2293   pin_verify[1] = 0x00; /* bTimeOut2 */
2294   pin_verify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2295   pin_verify[3] = pininfo->fixedlen; /* bmPINBlockString */
2296   pin_verify[4] = 0x00; /* bmPINLengthFormat */
2297   pin_verify[5] = pininfo->maxlen; /* wPINMaxExtraDigit */
2298   pin_verify[6] = pininfo->minlen; /* wPINMaxExtraDigit */
2299   pin_verify[7] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2300   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2301     pin_verify[7] |= 0x01; /* Max size reached.  */
2302   pin_verify[8] = 0x01; /* bNumberMessage: One message */
2303   pin_verify[9] =  0x09; /* wLangId: 0x0409: US English */
2304   pin_verify[10] = 0x04; /* wLangId: 0x0409: US English */
2305   pin_verify[11] = 0x00; /* bMsgIndex */
2306   pin_verify[12] = 0x00; /* bTeoPrologue[0] */
2307   pin_verify[13] = 0x00; /* bTeoPrologue[1] */
2308   pin_verify[14] = pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2309   pin_verify[15] = pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2310   pin_verify[16] = 0x00; /* ulDataLength */
2311   pin_verify[17] = 0x00; /* ulDataLength */
2312   pin_verify[18] = 0x00; /* ulDataLength */
2313   pin_verify[19] = class; /* abData[0] */
2314   pin_verify[20] = ins; /* abData[1] */
2315   pin_verify[21] = p0; /* abData[2] */
2316   pin_verify[22] = p1; /* abData[3] */
2317   pin_verify[23] = pininfo->fixedlen; /* abData[4] */
2318   if (pininfo->fixedlen)
2319     memset (&pin_verify[24], 0xff, pininfo->fixedlen);
2320   else if (no_lc)
2321     len--;
2322
2323   if (DBG_CARD_IO)
2324     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2325                class, ins, p0, p1, len, pininfo->maxlen);
2326
2327   sw = control_pcsc (slot, reader_table[slot].pcsc.verify_ioctl,
2328                      pin_verify, len, result, &resultlen);
2329   xfree (pin_verify);
2330   if (sw || resultlen < 2)
2331     {
2332       log_error ("control_pcsc failed: %d\n", sw);
2333       return sw? sw: SW_HOST_INCOMPLETE_CARD_RESPONSE;
2334     }
2335   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2336   if (DBG_CARD_IO)
2337     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2338   return sw;
2339 }
2340
2341
2342 #define PIN_MODIFY_STRUCTURE_SIZE 29
2343 static int
2344 pcsc_pinpad_modify (int slot, int class, int ins, int p0, int p1,
2345                     pininfo_t *pininfo)
2346 {
2347   int sw;
2348   unsigned char *pin_modify;
2349   int len = PIN_MODIFY_STRUCTURE_SIZE + 2 * pininfo->fixedlen;
2350   unsigned char result[6];      /* See the comment at pinpad_verify.  */
2351   pcsc_dword_t resultlen = 6;
2352   int no_lc;
2353
2354   if (!reader_table[slot].atrlen
2355       && (sw = reset_pcsc_reader (slot)))
2356     return sw;
2357
2358   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2359     return SW_NOT_SUPPORTED;
2360
2361   pin_modify = xtrymalloc (len);
2362   if (!pin_modify)
2363     return SW_HOST_OUT_OF_CORE;
2364
2365   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2366
2367   pin_modify[0] = 0x00; /* bTimeOut */
2368   pin_modify[1] = 0x00; /* bTimeOut2 */
2369   pin_modify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2370   pin_modify[3] = pininfo->fixedlen; /* bmPINBlockString */
2371   pin_modify[4] = 0x00; /* bmPINLengthFormat */
2372   pin_modify[5] = 0x00; /* bInsertionOffsetOld */
2373   pin_modify[6] = pininfo->fixedlen; /* bInsertionOffsetNew */
2374   pin_modify[7] = pininfo->maxlen; /* wPINMaxExtraDigit */
2375   pin_modify[8] = pininfo->minlen; /* wPINMaxExtraDigit */
2376   pin_modify[9] = (p0 == 0 ? 0x03 : 0x01);
2377                   /* bConfirmPIN
2378                    *    0x00: new PIN once
2379                    *    0x01: new PIN twice (confirmation)
2380                    *    0x02: old PIN and new PIN once
2381                    *    0x03: old PIN and new PIN twice (confirmation)
2382                    */
2383   pin_modify[10] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2384   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2385     pin_modify[10] |= 0x01; /* Max size reached.  */
2386   pin_modify[11] = 0x03; /* bNumberMessage: Three messages */
2387   pin_modify[12] = 0x09; /* wLangId: 0x0409: US English */
2388   pin_modify[13] = 0x04; /* wLangId: 0x0409: US English */
2389   pin_modify[14] = 0x00; /* bMsgIndex1 */
2390   pin_modify[15] = 0x01; /* bMsgIndex2 */
2391   pin_modify[16] = 0x02; /* bMsgIndex3 */
2392   pin_modify[17] = 0x00; /* bTeoPrologue[0] */
2393   pin_modify[18] = 0x00; /* bTeoPrologue[1] */
2394   pin_modify[19] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2395   pin_modify[20] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2396   pin_modify[21] = 0x00; /* ulDataLength */
2397   pin_modify[22] = 0x00; /* ulDataLength */
2398   pin_modify[23] = 0x00; /* ulDataLength */
2399   pin_modify[24] = class; /* abData[0] */
2400   pin_modify[25] = ins; /* abData[1] */
2401   pin_modify[26] = p0; /* abData[2] */
2402   pin_modify[27] = p1; /* abData[3] */
2403   pin_modify[28] = 2 * pininfo->fixedlen; /* abData[4] */
2404   if (pininfo->fixedlen)
2405     memset (&pin_modify[29], 0xff, 2 * pininfo->fixedlen);
2406   else if (no_lc)
2407     len--;
2408
2409   if (DBG_CARD_IO)
2410     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2411                class, ins, p0, p1, len, (int)pininfo->maxlen);
2412
2413   sw = control_pcsc (slot, reader_table[slot].pcsc.modify_ioctl,
2414                      pin_modify, len, result, &resultlen);
2415   xfree (pin_modify);
2416   if (sw || resultlen < 2)
2417     {
2418       log_error ("control_pcsc failed: %d\n", sw);
2419       return sw? sw : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2420     }
2421   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2422   if (DBG_CARD_IO)
2423     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2424   return sw;
2425 }
2426 \f
2427 #ifdef HAVE_LIBUSB
2428 /*
2429      Internal CCID driver interface.
2430  */
2431
2432
2433 static void
2434 dump_ccid_reader_status (int slot)
2435 {
2436   log_info ("reader slot %d: using ccid driver\n", slot);
2437 }
2438
2439 static int
2440 close_ccid_reader (int slot)
2441 {
2442   ccid_close_reader (reader_table[slot].ccid.handle);
2443   return 0;
2444 }
2445
2446
2447 static int
2448 reset_ccid_reader (int slot)
2449 {
2450   int err;
2451   reader_table_t slotp = reader_table + slot;
2452   unsigned char atr[33];
2453   size_t atrlen;
2454
2455   err = ccid_get_atr (slotp->ccid.handle, atr, sizeof atr, &atrlen);
2456   if (err)
2457     return err;
2458   /* If the reset was successful, update the ATR. */
2459   assert (sizeof slotp->atr >= sizeof atr);
2460   slotp->atrlen = atrlen;
2461   memcpy (slotp->atr, atr, atrlen);
2462   dump_reader_status (slot);
2463   return 0;
2464 }
2465
2466
2467 static int
2468 set_progress_cb_ccid_reader (int slot, gcry_handler_progress_t cb, void *cb_arg)
2469 {
2470   reader_table_t slotp = reader_table + slot;
2471
2472   return ccid_set_progress_cb (slotp->ccid.handle, cb, cb_arg);
2473 }
2474
2475
2476 static int
2477 get_status_ccid (int slot, unsigned int *status, int on_wire)
2478 {
2479   int rc;
2480   int bits;
2481
2482   rc = ccid_slot_status (reader_table[slot].ccid.handle, &bits, on_wire);
2483   if (rc)
2484     return rc;
2485
2486   if (bits == 0)
2487     *status = (APDU_CARD_USABLE|APDU_CARD_PRESENT|APDU_CARD_ACTIVE);
2488   else if (bits == 1)
2489     *status = APDU_CARD_PRESENT;
2490   else
2491     *status = 0;
2492
2493   return 0;
2494 }
2495
2496
2497 /* Actually send the APDU of length APDULEN to SLOT and return a
2498    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2499    set to BUFLEN.  Returns: Internal CCID driver error code. */
2500 static int
2501 send_apdu_ccid (int slot, unsigned char *apdu, size_t apdulen,
2502                 unsigned char *buffer, size_t *buflen,
2503                 pininfo_t *pininfo)
2504 {
2505   long err;
2506   size_t maxbuflen;
2507
2508   /* If we don't have an ATR, we need to reset the reader first. */
2509   if (!reader_table[slot].atrlen
2510       && (err = reset_ccid_reader (slot)))
2511     return err;
2512
2513   if (DBG_CARD_IO)
2514     log_printhex (" raw apdu:", apdu, apdulen);
2515
2516   maxbuflen = *buflen;
2517   if (pininfo)
2518     err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2519                                   apdu, apdulen, pininfo,
2520                                   buffer, maxbuflen, buflen);
2521   else
2522     err = ccid_transceive (reader_table[slot].ccid.handle,
2523                            apdu, apdulen,
2524                            buffer, maxbuflen, buflen);
2525   if (err)
2526     log_error ("ccid_transceive failed: (0x%lx)\n",
2527                err);
2528
2529   return err;
2530 }
2531
2532
2533 /* Check whether the CCID reader supports the ISO command code COMMAND
2534    on the pinpad.  Return 0 on success.  For a description of the pin
2535    parameters, see ccid-driver.c */
2536 static int
2537 check_ccid_pinpad (int slot, int command, pininfo_t *pininfo)
2538 {
2539   unsigned char apdu[] = { 0, 0, 0, 0x81 };
2540
2541   apdu[1] = command;
2542   return ccid_transceive_secure (reader_table[slot].ccid.handle, apdu,
2543                                  sizeof apdu, pininfo, NULL, 0, NULL);
2544 }
2545
2546
2547 static int
2548 ccid_pinpad_operation (int slot, int class, int ins, int p0, int p1,
2549                        pininfo_t *pininfo)
2550 {
2551   unsigned char apdu[4];
2552   int err, sw;
2553   unsigned char result[2];
2554   size_t resultlen = 2;
2555
2556   apdu[0] = class;
2557   apdu[1] = ins;
2558   apdu[2] = p0;
2559   apdu[3] = p1;
2560   err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2561                                 apdu, sizeof apdu, pininfo,
2562                                 result, 2, &resultlen);
2563   if (err)
2564     return err;
2565
2566   if (resultlen < 2)
2567     return SW_HOST_INCOMPLETE_CARD_RESPONSE;
2568
2569   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2570   return sw;
2571 }
2572
2573
2574 /* Open the reader and try to read an ATR.  */
2575 static int
2576 open_ccid_reader (struct dev_list *dl)
2577 {
2578   int err;
2579   int slot;
2580   int require_get_status;
2581   reader_table_t slotp;
2582
2583   slot = new_reader_slot ();
2584   if (slot == -1)
2585     return -1;
2586   slotp = reader_table + slot;
2587
2588   err = ccid_open_reader (dl->portstr, dl->idx, dl->ccid_table,
2589                           &slotp->ccid.handle, &slotp->rdrname);
2590   if (err)
2591     {
2592       slotp->used = 0;
2593       unlock_slot (slot);
2594       return -1;
2595     }
2596
2597   err = ccid_get_atr (slotp->ccid.handle,
2598                       slotp->atr, sizeof slotp->atr, &slotp->atrlen);
2599   if (err)
2600     {
2601       slotp->atrlen = 0;
2602       err = 0;
2603     }
2604
2605   require_get_status = ccid_require_get_status (slotp->ccid.handle);
2606
2607   reader_table[slot].close_reader = close_ccid_reader;
2608   reader_table[slot].reset_reader = reset_ccid_reader;
2609   reader_table[slot].get_status_reader = get_status_ccid;
2610   reader_table[slot].send_apdu_reader = send_apdu_ccid;
2611   reader_table[slot].check_pinpad = check_ccid_pinpad;
2612   reader_table[slot].dump_status_reader = dump_ccid_reader_status;
2613   reader_table[slot].set_progress_cb = set_progress_cb_ccid_reader;
2614   reader_table[slot].pinpad_verify = ccid_pinpad_operation;
2615   reader_table[slot].pinpad_modify = ccid_pinpad_operation;
2616   /* Our CCID reader code does not support T=0 at all, thus reset the
2617      flag.  */
2618   reader_table[slot].is_t0 = 0;
2619   reader_table[slot].require_get_status = require_get_status;
2620
2621   dump_reader_status (slot);
2622   unlock_slot (slot);
2623   return slot;
2624 }
2625 #endif /* HAVE_LIBUSB */
2626 \f
2627 #ifdef USE_G10CODE_RAPDU
2628 /*
2629      The Remote APDU Interface.
2630
2631      This uses the Remote APDU protocol to contact a reader.
2632
2633      The port number is actually an index into the list of ports as
2634      returned via the protocol.
2635  */
2636
2637
2638 static int
2639 rapdu_status_to_sw (int status)
2640 {
2641   int rc;
2642
2643   switch (status)
2644     {
2645     case RAPDU_STATUS_SUCCESS:  rc = 0; break;
2646
2647     case RAPDU_STATUS_INVCMD:
2648     case RAPDU_STATUS_INVPROT:
2649     case RAPDU_STATUS_INVSEQ:
2650     case RAPDU_STATUS_INVCOOKIE:
2651     case RAPDU_STATUS_INVREADER:  rc = SW_HOST_INV_VALUE;  break;
2652
2653     case RAPDU_STATUS_TIMEOUT:  rc = SW_HOST_CARD_IO_ERROR; break;
2654     case RAPDU_STATUS_CARDIO:   rc = SW_HOST_CARD_IO_ERROR; break;
2655     case RAPDU_STATUS_NOCARD:   rc = SW_HOST_NO_CARD; break;
2656     case RAPDU_STATUS_CARDCHG:  rc = SW_HOST_NO_CARD; break;
2657     case RAPDU_STATUS_BUSY:     rc = SW_HOST_BUSY; break;
2658     case RAPDU_STATUS_NEEDRESET: rc = SW_HOST_CARD_INACTIVE; break;
2659
2660     default: rc = SW_HOST_GENERAL_ERROR; break;
2661     }
2662
2663   return rc;
2664 }
2665
2666
2667
2668 static int
2669 close_rapdu_reader (int slot)
2670 {
2671   rapdu_release (reader_table[slot].rapdu.handle);
2672   return 0;
2673 }
2674
2675
2676 static int
2677 reset_rapdu_reader (int slot)
2678 {
2679   int err;
2680   reader_table_t slotp;
2681   rapdu_msg_t msg = NULL;
2682
2683   slotp = reader_table + slot;
2684
2685   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2686   if (err)
2687     {
2688       log_error ("sending rapdu command RESET failed: %s\n",
2689                 err < 0 ? strerror (errno): rapdu_strerror (err));
2690       rapdu_msg_release (msg);
2691       return rapdu_status_to_sw (err);
2692     }
2693   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2694   if (err)
2695     {
2696       log_error ("receiving rapdu message failed: %s\n",
2697                 err < 0 ? strerror (errno): rapdu_strerror (err));
2698       rapdu_msg_release (msg);
2699       return rapdu_status_to_sw (err);
2700     }
2701   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2702     {
2703       int sw = rapdu_status_to_sw (msg->cmd);
2704       log_error ("rapdu command RESET failed: %s\n",
2705                  rapdu_strerror (msg->cmd));
2706       rapdu_msg_release (msg);
2707       return sw;
2708     }
2709   if (msg->datalen > DIM (slotp->atr))
2710     {
2711       log_error ("ATR returned by the RAPDU layer is too large\n");
2712       rapdu_msg_release (msg);
2713       return SW_HOST_INV_VALUE;
2714     }
2715   slotp->atrlen = msg->datalen;
2716   memcpy (slotp->atr, msg->data, msg->datalen);
2717
2718   rapdu_msg_release (msg);
2719   return 0;
2720 }
2721
2722
2723 static int
2724 my_rapdu_get_status (int slot, unsigned int *status, int on_wire)
2725 {
2726   int err;
2727   reader_table_t slotp;
2728   rapdu_msg_t msg = NULL;
2729   int oldslot;
2730
2731   (void)on_wire;
2732   slotp = reader_table + slot;
2733
2734   oldslot = rapdu_set_reader (slotp->rapdu.handle, slot);
2735   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_STATUS);
2736   rapdu_set_reader (slotp->rapdu.handle, oldslot);
2737   if (err)
2738     {
2739       log_error ("sending rapdu command GET_STATUS failed: %s\n",
2740                 err < 0 ? strerror (errno): rapdu_strerror (err));
2741       return rapdu_status_to_sw (err);
2742     }
2743   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2744   if (err)
2745     {
2746       log_error ("receiving rapdu message failed: %s\n",
2747                 err < 0 ? strerror (errno): rapdu_strerror (err));
2748       rapdu_msg_release (msg);
2749       return rapdu_status_to_sw (err);
2750     }
2751   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2752     {
2753       int sw = rapdu_status_to_sw (msg->cmd);
2754       log_error ("rapdu command GET_STATUS failed: %s\n",
2755                  rapdu_strerror (msg->cmd));
2756       rapdu_msg_release (msg);
2757       return sw;
2758     }
2759   *status = msg->data[0];
2760
2761   rapdu_msg_release (msg);
2762   return 0;
2763 }
2764
2765
2766 /* Actually send the APDU of length APDULEN to SLOT and return a
2767    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2768    set to BUFLEN.  Returns: APDU error code. */
2769 static int
2770 my_rapdu_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
2771                     unsigned char *buffer, size_t *buflen,
2772                     pininfo_t *pininfo)
2773 {
2774   int err;
2775   reader_table_t slotp;
2776   rapdu_msg_t msg = NULL;
2777   size_t maxlen = *buflen;
2778
2779   slotp = reader_table + slot;
2780
2781   *buflen = 0;
2782   if (DBG_CARD_IO)
2783     log_printhex ("  APDU_data:", apdu, apdulen);
2784
2785   if (apdulen < 4)
2786     {
2787       log_error ("rapdu_send_apdu: APDU is too short\n");
2788       return SW_HOST_INV_VALUE;
2789     }
2790
2791   err = rapdu_send_apdu (slotp->rapdu.handle, apdu, apdulen);
2792   if (err)
2793     {
2794       log_error ("sending rapdu command APDU failed: %s\n",
2795                 err < 0 ? strerror (errno): rapdu_strerror (err));
2796       rapdu_msg_release (msg);
2797       return rapdu_status_to_sw (err);
2798     }
2799   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2800   if (err)
2801     {
2802       log_error ("receiving rapdu message failed: %s\n",
2803                 err < 0 ? strerror (errno): rapdu_strerror (err));
2804       rapdu_msg_release (msg);
2805       return rapdu_status_to_sw (err);
2806     }
2807   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2808     {
2809       int sw = rapdu_status_to_sw (msg->cmd);
2810       log_error ("rapdu command APDU failed: %s\n",
2811                  rapdu_strerror (msg->cmd));
2812       rapdu_msg_release (msg);
2813       return sw;
2814     }
2815
2816   if (msg->datalen > maxlen)
2817     {
2818       log_error ("rapdu response apdu too large\n");
2819       rapdu_msg_release (msg);
2820       return SW_HOST_INV_VALUE;
2821     }
2822
2823   *buflen = msg->datalen;
2824   memcpy (buffer, msg->data, msg->datalen);
2825
2826   rapdu_msg_release (msg);
2827   return 0;
2828 }
2829
2830 static int
2831 open_rapdu_reader (int portno,
2832                    const unsigned char *cookie, size_t length,
2833                    int (*readfnc) (void *opaque,
2834                                    void *buffer, size_t size),
2835                    void *readfnc_value,
2836                    int (*writefnc) (void *opaque,
2837                                     const void *buffer, size_t size),
2838                    void *writefnc_value,
2839                    void (*closefnc) (void *opaque),
2840                    void *closefnc_value)
2841 {
2842   int err;
2843   int slot;
2844   reader_table_t slotp;
2845   rapdu_msg_t msg = NULL;
2846
2847   slot = new_reader_slot ();
2848   if (slot == -1)
2849     return -1;
2850   slotp = reader_table + slot;
2851
2852   slotp->rapdu.handle = rapdu_new ();
2853   if (!slotp->rapdu.handle)
2854     {
2855       slotp->used = 0;
2856       unlock_slot (slot);
2857       return -1;
2858     }
2859
2860   rapdu_set_reader (slotp->rapdu.handle, portno);
2861
2862   rapdu_set_iofunc (slotp->rapdu.handle,
2863                     readfnc, readfnc_value,
2864                     writefnc, writefnc_value,
2865                     closefnc, closefnc_value);
2866   rapdu_set_cookie (slotp->rapdu.handle, cookie, length);
2867
2868   /* First try to get the current ATR, but if the card is inactive
2869      issue a reset instead.  */
2870   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_ATR);
2871   if (err == RAPDU_STATUS_NEEDRESET)
2872     err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2873   if (err)
2874     {
2875       log_info ("sending rapdu command GET_ATR/RESET failed: %s\n",
2876                 err < 0 ? strerror (errno): rapdu_strerror (err));
2877       goto failure;
2878     }
2879   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2880   if (err)
2881     {
2882       log_info ("receiving rapdu message failed: %s\n",
2883                 err < 0 ? strerror (errno): rapdu_strerror (err));
2884       goto failure;
2885     }
2886   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2887     {
2888       log_info ("rapdu command GET ATR failed: %s\n",
2889                  rapdu_strerror (msg->cmd));
2890       goto failure;
2891     }
2892   if (msg->datalen > DIM (slotp->atr))
2893     {
2894       log_error ("ATR returned by the RAPDU layer is too large\n");
2895       goto failure;
2896     }
2897   slotp->atrlen = msg->datalen;
2898   memcpy (slotp->atr, msg->data, msg->datalen);
2899
2900   reader_table[slot].close_reader = close_rapdu_reader;
2901   reader_table[slot].reset_reader = reset_rapdu_reader;
2902   reader_table[slot].get_status_reader = my_rapdu_get_status;
2903   reader_table[slot].send_apdu_reader = my_rapdu_send_apdu;
2904   reader_table[slot].check_pinpad = NULL;
2905   reader_table[slot].dump_status_reader = NULL;
2906   reader_table[slot].pinpad_verify = NULL;
2907   reader_table[slot].pinpad_modify = NULL;
2908
2909   dump_reader_status (slot);
2910   rapdu_msg_release (msg);
2911   unlock_slot (slot);
2912   return slot;
2913
2914  failure:
2915   rapdu_msg_release (msg);
2916   rapdu_release (slotp->rapdu.handle);
2917   slotp->used = 0;
2918   unlock_slot (slot);
2919   return -1;
2920 }
2921
2922 #endif /*USE_G10CODE_RAPDU*/
2923
2924
2925 \f
2926 /*
2927        Driver Access
2928  */
2929 gpg_error_t
2930 apdu_dev_list_start (const char *portstr, struct dev_list **l_p)
2931 {
2932   struct dev_list *dl = xtrymalloc (sizeof (struct dev_list));
2933
2934   *l_p = NULL;
2935   if (!dl)
2936     return gpg_error_from_syserror ();
2937
2938   dl->portstr = portstr;
2939   dl->idx = 0;
2940
2941   npth_mutex_lock (&reader_table_lock);
2942
2943 #ifdef HAVE_LIBUSB
2944   if (opt.disable_ccid)
2945     {
2946       dl->ccid_table = NULL;
2947       dl->idx_max = 1;
2948     }
2949   else
2950     {
2951       gpg_error_t err;
2952
2953       err = ccid_dev_scan (&dl->idx_max, &dl->ccid_table);
2954       if (err)
2955         return err;
2956
2957       if (dl->idx_max == 0)
2958         {
2959           /* If a CCID reader specification has been given, the user does
2960              not want a fallback to other drivers. */
2961           if (portstr && strlen (portstr) > 5 && portstr[4] == ':')
2962             {
2963               if (DBG_READER)
2964                 log_debug ("leave: apdu_open_reader => slot=-1 (no ccid)\n");
2965
2966               xfree (dl);
2967               npth_mutex_unlock (&reader_table_lock);
2968               return gpg_error (GPG_ERR_ENODEV);
2969             }
2970           else
2971             dl->idx_max = 1;
2972         }
2973     }
2974 #else
2975   dl->ccid_table = NULL;
2976   dl->idx_max = 1;
2977 #endif /* HAVE_LIBUSB */
2978
2979   *l_p = dl;
2980   return 0;
2981 }
2982
2983 void
2984 apdu_dev_list_finish (struct dev_list *dl)
2985 {
2986 #ifdef HAVE_LIBUSB
2987   if (dl->ccid_table)
2988     ccid_dev_scan_finish (dl->ccid_table, dl->idx_max);
2989 #endif
2990   xfree (dl);
2991   npth_mutex_unlock (&reader_table_lock);
2992 }
2993
2994
2995 /* Open the reader and return an internal slot number or -1 on
2996    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
2997    the first USB reader.  For PC/SC the first listed reader). */
2998 static int
2999 apdu_open_one_reader (const char *portstr)
3000 {
3001   static int pcsc_api_loaded, ct_api_loaded;
3002   int slot;
3003
3004   if (DBG_READER)
3005     log_debug ("enter: apdu_open_reader: portstr=%s\n", portstr);
3006
3007   if (opt.ctapi_driver && *opt.ctapi_driver)
3008     {
3009       int port = portstr? atoi (portstr) : 32768;
3010
3011       if (!ct_api_loaded)
3012         {
3013           void *handle;
3014
3015           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
3016           if (!handle)
3017             {
3018               log_error ("apdu_open_reader: failed to open driver: %s\n",
3019                          dlerror ());
3020               return -1;
3021             }
3022           CT_init = dlsym (handle, "CT_init");
3023           CT_data = dlsym (handle, "CT_data");
3024           CT_close = dlsym (handle, "CT_close");
3025           if (!CT_init || !CT_data || !CT_close)
3026             {
3027               log_error ("apdu_open_reader: invalid CT-API driver\n");
3028               dlclose (handle);
3029               return -1;
3030             }
3031           ct_api_loaded = 1;
3032         }
3033       return open_ct_reader (port);
3034     }
3035
3036   /* No ctAPI configured, so lets try the PC/SC API */
3037   if (!pcsc_api_loaded)
3038     {
3039 #ifndef NEED_PCSC_WRAPPER
3040       void *handle;
3041
3042       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
3043       if (!handle)
3044         {
3045           log_error ("apdu_open_reader: failed to open driver '%s': %s\n",
3046                      opt.pcsc_driver, dlerror ());
3047           return -1;
3048         }
3049
3050       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
3051       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
3052       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
3053 #if defined(_WIN32) || defined(__CYGWIN__)
3054       if (!pcsc_list_readers)
3055         pcsc_list_readers    = dlsym (handle, "SCardListReadersA");
3056 #endif
3057       pcsc_get_status_change = dlsym (handle, "SCardGetStatusChange");
3058 #if defined(_WIN32) || defined(__CYGWIN__)
3059       if (!pcsc_get_status_change)
3060         pcsc_get_status_change = dlsym (handle, "SCardGetStatusChangeA");
3061 #endif
3062       pcsc_connect           = dlsym (handle, "SCardConnect");
3063 #if defined(_WIN32) || defined(__CYGWIN__)
3064       if (!pcsc_connect)
3065         pcsc_connect         = dlsym (handle, "SCardConnectA");
3066 #endif
3067       pcsc_reconnect         = dlsym (handle, "SCardReconnect");
3068 #if defined(_WIN32) || defined(__CYGWIN__)
3069       if (!pcsc_reconnect)
3070         pcsc_reconnect       = dlsym (handle, "SCardReconnectA");
3071 #endif
3072       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
3073       pcsc_status            = dlsym (handle, "SCardStatus");
3074 #if defined(_WIN32) || defined(__CYGWIN__)
3075       if (!pcsc_status)
3076         pcsc_status          = dlsym (handle, "SCardStatusA");
3077 #endif
3078       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
3079       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
3080       pcsc_transmit          = dlsym (handle, "SCardTransmit");
3081       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
3082       pcsc_control           = dlsym (handle, "SCardControl");
3083
3084       if (!pcsc_establish_context
3085           || !pcsc_release_context
3086           || !pcsc_list_readers
3087           || !pcsc_get_status_change
3088           || !pcsc_connect
3089           || !pcsc_reconnect
3090           || !pcsc_disconnect
3091           || !pcsc_status
3092           || !pcsc_begin_transaction
3093           || !pcsc_end_transaction
3094           || !pcsc_transmit
3095           || !pcsc_control
3096           /* || !pcsc_set_timeout */)
3097         {
3098           /* Note that set_timeout is currently not used and also not
3099              available under Windows. */
3100           log_error ("apdu_open_reader: invalid PC/SC driver "
3101                      "(%d%d%d%d%d%d%d%d%d%d%d%d%d)\n",
3102                      !!pcsc_establish_context,
3103                      !!pcsc_release_context,
3104                      !!pcsc_list_readers,
3105                      !!pcsc_get_status_change,
3106                      !!pcsc_connect,
3107                      !!pcsc_reconnect,
3108                      !!pcsc_disconnect,
3109                      !!pcsc_status,
3110                      !!pcsc_begin_transaction,
3111                      !!pcsc_end_transaction,
3112                      !!pcsc_transmit,
3113                      !!pcsc_set_timeout,
3114                      !!pcsc_control );
3115           dlclose (handle);
3116           return -1;
3117         }
3118 #endif /*!NEED_PCSC_WRAPPER*/
3119       pcsc_api_loaded = 1;
3120     }
3121
3122   slot = open_pcsc_reader (portstr);
3123
3124   if (DBG_READER)
3125     log_debug ("leave: apdu_open_reader => slot=%d [pc/sc]\n", slot);
3126   return slot;
3127 }
3128
3129 int
3130 apdu_open_reader (struct dev_list *dl, int app_empty)
3131 {
3132   int slot;
3133
3134 #ifdef HAVE_LIBUSB
3135   if (dl->ccid_table)
3136     { /* CCID readers.  */
3137       int readerno;
3138
3139       /* See whether we want to use the reader ID string or a reader
3140          number. A readerno of -1 indicates that the reader ID string is
3141          to be used. */
3142       if (dl->portstr && strchr (dl->portstr, ':'))
3143         readerno = -1; /* We want to use the readerid.  */
3144       else if (dl->portstr)
3145         {
3146           readerno = atoi (dl->portstr);
3147           if (readerno < 0)
3148             {
3149               return -1;
3150             }
3151         }
3152       else
3153         readerno = 0;  /* Default. */
3154
3155       if (readerno > 0)
3156         { /* Use single, the specific reader.  */
3157           if (readerno >= dl->idx_max)
3158             return -1;
3159
3160           dl->idx = readerno;
3161           dl->portstr = NULL;
3162           slot = open_ccid_reader (dl);
3163           dl->idx = dl->idx_max;
3164           if (slot >= 0)
3165             return slot;
3166           else
3167             return -1;
3168         }
3169
3170       while (dl->idx < dl->idx_max)
3171         {
3172           unsigned int bai = ccid_get_BAI (dl->idx, dl->ccid_table);
3173
3174           if (DBG_READER)
3175             log_debug ("apdu_open_reader: BAI=%x\n", bai);
3176
3177           /* Check identity by BAI against already opened HANDLEs.  */
3178           for (slot = 0; slot < MAX_READER; slot++)
3179             if (reader_table[slot].used
3180                 && reader_table[slot].ccid.handle
3181                 && ccid_compare_BAI (reader_table[slot].ccid.handle, bai))
3182               break;
3183
3184           if (slot == MAX_READER)
3185             { /* Found a new device.  */
3186               if (DBG_READER)
3187                 log_debug ("apdu_open_reader: new device=%x\n", bai);
3188
3189               slot = open_ccid_reader (dl);
3190
3191               dl->idx++;
3192               if (slot >= 0)
3193                 return slot;
3194               else
3195                 {
3196                   /* Skip this reader.  */
3197                   log_error ("ccid open error: skip\n");
3198                   continue;
3199                 }
3200             }
3201           else
3202             dl->idx++;
3203         }
3204
3205       /* Not found.  Try one for PC/SC, only when it's the initial scan.  */
3206       if (app_empty && dl->idx == dl->idx_max)
3207         {
3208           dl->idx++;
3209           slot = apdu_open_one_reader (dl->portstr);
3210         }
3211       else
3212         slot = -1;
3213     }
3214   else
3215 #endif
3216     { /* PC/SC readers.  */
3217       if (app_empty && dl->idx == 0)
3218         {
3219           dl->idx++;
3220           slot = apdu_open_one_reader (dl->portstr);
3221         }
3222       else
3223         slot = -1;
3224     }
3225
3226   return slot;
3227 }
3228
3229
3230 /* Open an remote reader and return an internal slot number or -1 on
3231    error. This function is an alternative to apdu_open_reader and used
3232    with remote readers only.  Note that the supplied CLOSEFNC will
3233    only be called once and the slot will not be valid afther this.
3234
3235    If PORTSTR is NULL we default to the first available port.
3236 */
3237 int
3238 apdu_open_remote_reader (const char *portstr,
3239                          const unsigned char *cookie, size_t length,
3240                          int (*readfnc) (void *opaque,
3241                                          void *buffer, size_t size),
3242                          void *readfnc_value,
3243                          int (*writefnc) (void *opaque,
3244                                           const void *buffer, size_t size),
3245                          void *writefnc_value,
3246                          void (*closefnc) (void *opaque),
3247                          void *closefnc_value)
3248 {
3249 #ifdef USE_G10CODE_RAPDU
3250   return open_rapdu_reader (portstr? atoi (portstr) : 0,
3251                             cookie, length,
3252                             readfnc, readfnc_value,
3253                             writefnc, writefnc_value,
3254                             closefnc, closefnc_value);
3255 #else
3256   (void)portstr;
3257   (void)cookie;
3258   (void)length;
3259   (void)readfnc;
3260   (void)readfnc_value;
3261   (void)writefnc;
3262   (void)writefnc_value;
3263   (void)closefnc;
3264   (void)closefnc_value;
3265 #ifdef _WIN32
3266   errno = ENOENT;
3267 #else
3268   errno = ENOSYS;
3269 #endif
3270   return -1;
3271 #endif
3272 }
3273
3274
3275 int
3276 apdu_close_reader (int slot)
3277 {
3278   int sw;
3279
3280   if (DBG_READER)
3281     log_debug ("enter: apdu_close_reader: slot=%d\n", slot);
3282
3283   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3284     {
3285       if (DBG_READER)
3286         log_debug ("leave: apdu_close_reader => SW_HOST_NO_DRIVER\n");
3287       return SW_HOST_NO_DRIVER;
3288     }
3289   sw = apdu_disconnect (slot);
3290   if (sw)
3291     {
3292       /*
3293        * When the reader/token was removed it might come here.
3294        * It should go through to call CLOSE_READER even if we got an error.
3295        */
3296       if (DBG_READER)
3297         log_debug ("apdu_close_reader => 0x%x (apdu_disconnect)\n", sw);
3298     }
3299   if (reader_table[slot].close_reader)
3300     {
3301       sw = reader_table[slot].close_reader (slot);
3302       reader_table[slot].used = 0;
3303       if (DBG_READER)
3304         log_debug ("leave: apdu_close_reader => 0x%x (close_reader)\n", sw);
3305       return sw;
3306     }
3307   xfree (reader_table[slot].rdrname);
3308   reader_table[slot].rdrname = NULL;
3309   reader_table[slot].used = 0;
3310   if (DBG_READER)
3311     log_debug ("leave: apdu_close_reader => SW_HOST_NOT_SUPPORTED\n");
3312   return SW_HOST_NOT_SUPPORTED;
3313 }
3314
3315
3316 /* Function suitable for a cleanup function to close all reader.  It
3317    should not be used if the reader will be opened again.  The reason
3318    for implementing this to properly close USB devices so that they
3319    will startup the next time without error. */
3320 void
3321 apdu_prepare_exit (void)
3322 {
3323   static int sentinel;
3324   int slot;
3325
3326   if (!sentinel)
3327     {
3328       sentinel = 1;
3329       npth_mutex_lock (&reader_table_lock);
3330       for (slot = 0; slot < MAX_READER; slot++)
3331         if (reader_table[slot].used)
3332           {
3333             apdu_disconnect (slot);
3334             if (reader_table[slot].close_reader)
3335               reader_table[slot].close_reader (slot);
3336             xfree (reader_table[slot].rdrname);
3337             reader_table[slot].rdrname = NULL;
3338             reader_table[slot].used = 0;
3339           }
3340       npth_mutex_unlock (&reader_table_lock);
3341       sentinel = 0;
3342     }
3343 }
3344
3345
3346 /* Enumerate all readers and return information on whether this reader
3347    is in use.  The caller should start with SLOT set to 0 and
3348    increment it with each call until an error is returned. */
3349 int
3350 apdu_enum_reader (int slot, int *used)
3351 {
3352   if (slot < 0 || slot >= MAX_READER)
3353     return SW_HOST_NO_DRIVER;
3354   *used = reader_table[slot].used;
3355   return 0;
3356 }
3357
3358
3359 /* Connect a card.  This is used to power up the card and make sure
3360    that an ATR is available.  Depending on the reader backend it may
3361    return an error for an inactive card or if no card is available.
3362    Return -1 on error.  Return 1 if reader requires get_status to
3363    watch card removal.  Return 0 if it's a token (always with a card),
3364    or it supports INTERRUPT endpoint to watch card removal.
3365   */
3366 int
3367 apdu_connect (int slot)
3368 {
3369   int sw = 0;
3370   unsigned int status = 0;
3371
3372   if (DBG_READER)
3373     log_debug ("enter: apdu_connect: slot=%d\n", slot);
3374
3375   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3376     {
3377       if (DBG_READER)
3378         log_debug ("leave: apdu_connect => SW_HOST_NO_DRIVER\n");
3379       return -1;
3380     }
3381
3382   /* Only if the access method provides a connect function we use it.
3383      If not, we expect that the card has been implicitly connected by
3384      apdu_open_reader.  */
3385   if (reader_table[slot].connect_card)
3386     {
3387       sw = lock_slot (slot);
3388       if (!sw)
3389         {
3390           sw = reader_table[slot].connect_card (slot);
3391           unlock_slot (slot);
3392         }
3393     }
3394
3395   /* We need to call apdu_get_status_internal, so that the last-status
3396      machinery gets setup properly even if a card is inserted while
3397      scdaemon is fired up and apdu_get_status has not yet been called.
3398      Without that we would force a reset of the card with the next
3399      call to apdu_get_status.  */
3400   if (!sw)
3401     sw = apdu_get_status_internal (slot, 1, &status, 1);
3402
3403   if (sw)
3404     ;
3405   else if (!(status & APDU_CARD_PRESENT))
3406     sw = SW_HOST_NO_CARD;
3407   else if ((status & APDU_CARD_PRESENT) && !(status & APDU_CARD_ACTIVE))
3408     sw = SW_HOST_CARD_INACTIVE;
3409
3410   if (sw == SW_HOST_CARD_INACTIVE)
3411     {
3412       /* Try power it up again.  */
3413       sw = apdu_reset (slot);
3414     }
3415
3416   if (DBG_READER)
3417     log_debug ("leave: apdu_connect => sw=0x%x\n", sw);
3418
3419   if (sw)
3420     return -1;
3421
3422   return reader_table[slot].require_get_status;
3423 }
3424
3425
3426 int
3427 apdu_disconnect (int slot)
3428 {
3429   int sw;
3430
3431   if (DBG_READER)
3432     log_debug ("enter: apdu_disconnect: slot=%d\n", slot);
3433
3434   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3435     {
3436       if (DBG_READER)
3437         log_debug ("leave: apdu_disconnect => SW_HOST_NO_DRIVER\n");
3438       return SW_HOST_NO_DRIVER;
3439     }
3440
3441   if (reader_table[slot].disconnect_card)
3442     {
3443       sw = lock_slot (slot);
3444       if (!sw)
3445         {
3446           sw = reader_table[slot].disconnect_card (slot);
3447           unlock_slot (slot);
3448         }
3449     }
3450   else
3451     sw = 0;
3452
3453   if (DBG_READER)
3454     log_debug ("leave: apdu_disconnect => sw=0x%x\n", sw);
3455   return sw;
3456 }
3457
3458
3459 /* Set the progress callback of SLOT to CB and its args to CB_ARG.  If
3460    CB is NULL the progress callback is removed.  */
3461 int
3462 apdu_set_progress_cb (int slot, gcry_handler_progress_t cb, void *cb_arg)
3463 {
3464   int sw;
3465
3466   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3467     return SW_HOST_NO_DRIVER;
3468
3469   if (reader_table[slot].set_progress_cb)
3470     {
3471       sw = lock_slot (slot);
3472       if (!sw)
3473         {
3474           sw = reader_table[slot].set_progress_cb (slot, cb, cb_arg);
3475           unlock_slot (slot);
3476         }
3477     }
3478   else
3479     sw = 0;
3480   return sw;
3481 }
3482
3483
3484 /* Do a reset for the card in reader at SLOT. */
3485 int
3486 apdu_reset (int slot)
3487 {
3488   int sw;
3489
3490   if (DBG_READER)
3491     log_debug ("enter: apdu_reset: slot=%d\n", slot);
3492
3493   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3494     {
3495       if (DBG_READER)
3496         log_debug ("leave: apdu_reset => SW_HOST_NO_DRIVER\n");
3497       return SW_HOST_NO_DRIVER;
3498     }
3499
3500   if ((sw = lock_slot (slot)))
3501     {
3502       if (DBG_READER)
3503         log_debug ("leave: apdu_reset => sw=0x%x (lock_slot)\n", sw);
3504       return sw;
3505     }
3506
3507   if (reader_table[slot].reset_reader)
3508     sw = reader_table[slot].reset_reader (slot);
3509
3510   unlock_slot (slot);
3511   if (DBG_READER)
3512     log_debug ("leave: apdu_reset => sw=0x%x\n", sw);
3513   return sw;
3514 }
3515
3516
3517 /* Return the ATR or NULL if none is available.  On success the length
3518    of the ATR is stored at ATRLEN.  The caller must free the returned
3519    value.  */
3520 unsigned char *
3521 apdu_get_atr (int slot, size_t *atrlen)
3522 {
3523   unsigned char *buf;
3524
3525   if (DBG_READER)
3526     log_debug ("enter: apdu_get_atr: slot=%d\n", slot);
3527
3528   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3529     {
3530       if (DBG_READER)
3531         log_debug ("leave: apdu_get_atr => NULL (bad slot)\n");
3532       return NULL;
3533     }
3534   if (!reader_table[slot].atrlen)
3535     {
3536       if (DBG_READER)
3537         log_debug ("leave: apdu_get_atr => NULL (no ATR)\n");
3538       return NULL;
3539     }
3540
3541   buf = xtrymalloc (reader_table[slot].atrlen);
3542   if (!buf)
3543     {
3544       if (DBG_READER)
3545         log_debug ("leave: apdu_get_atr => NULL (out of core)\n");
3546       return NULL;
3547     }
3548   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
3549   *atrlen = reader_table[slot].atrlen;
3550   if (DBG_READER)
3551     log_debug ("leave: apdu_get_atr => atrlen=%zu\n", *atrlen);
3552   return buf;
3553 }
3554
3555
3556
3557 /* Retrieve the status for SLOT. The function does only wait for the
3558    card to become available if HANG is set to true. On success the
3559    bits in STATUS will be set to
3560
3561      APDU_CARD_USABLE  (bit 0) = card present and usable
3562      APDU_CARD_PRESENT (bit 1) = card present
3563      APDU_CARD_ACTIVE  (bit 2) = card active
3564                        (bit 3) = card access locked [not yet implemented]
3565
3566    For most applications, testing bit 0 is sufficient.
3567 */
3568 static int
3569 apdu_get_status_internal (int slot, int hang, unsigned int *status, int on_wire)
3570 {
3571   int sw;
3572   unsigned int s;
3573
3574   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3575     return SW_HOST_NO_DRIVER;
3576
3577   if ((sw = hang? lock_slot (slot) : trylock_slot (slot)))
3578     return sw;
3579
3580   if (reader_table[slot].get_status_reader)
3581     sw = reader_table[slot].get_status_reader (slot, &s, on_wire);
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