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