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