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