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