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