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