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