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