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