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