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