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