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