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