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