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