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