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