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