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