po: Update Japanese translation.
[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 # define SCARD_CTL_CODE(code) (0x42000000 + (code))
250 #endif
251
252 #define CM_IOCTL_GET_FEATURE_REQUEST     SCARD_CTL_CODE(3400)
253 #define CM_IOCTL_VENDOR_IFD_EXCHANGE     SCARD_CTL_CODE(1)
254 #define FEATURE_VERIFY_PIN_DIRECT        0x06
255 #define FEATURE_MODIFY_PIN_DIRECT        0x07
256 #define FEATURE_GET_TLV_PROPERTIES       0x12
257
258 #define PCSCv2_PART10_PROPERTY_bEntryValidationCondition 2
259 #define PCSCv2_PART10_PROPERTY_bTimeOut2                 3
260 #define PCSCv2_PART10_PROPERTY_bMinPINSize               6
261 #define PCSCv2_PART10_PROPERTY_bMaxPINSize               7
262 #define PCSCv2_PART10_PROPERTY_wIdVendor                11
263 #define PCSCv2_PART10_PROPERTY_wIdProduct               12
264
265
266 /* The PC/SC error is defined as a long as per specs.  Due to left
267    shifts bit 31 will get sign extended.  We use this mask to fix
268    it. */
269 #define PCSC_ERR_MASK(a)  ((a) & 0xffffffff)
270
271
272 struct pcsc_io_request_s
273 {
274   unsigned long protocol;
275   unsigned long pci_len;
276 };
277
278 typedef struct pcsc_io_request_s *pcsc_io_request_t;
279
280 #ifdef __APPLE__
281 #pragma pack(1)
282 #endif
283
284 struct pcsc_readerstate_s
285 {
286   const char *reader;
287   void *user_data;
288   pcsc_dword_t current_state;
289   pcsc_dword_t event_state;
290   pcsc_dword_t atrlen;
291   unsigned char atr[33];
292 };
293
294 #ifdef __APPLE__
295 #pragma pack()
296 #endif
297
298 typedef struct pcsc_readerstate_s *pcsc_readerstate_t;
299
300 long (* DLSTDCALL pcsc_establish_context) (pcsc_dword_t scope,
301                                            const void *reserved1,
302                                            const void *reserved2,
303                                            long *r_context);
304 long (* DLSTDCALL pcsc_release_context) (long context);
305 long (* DLSTDCALL pcsc_list_readers) (long context,
306                                       const char *groups,
307                                       char *readers, pcsc_dword_t*readerslen);
308 long (* DLSTDCALL pcsc_get_status_change) (long context,
309                                            pcsc_dword_t timeout,
310                                            pcsc_readerstate_t readerstates,
311                                            pcsc_dword_t nreaderstates);
312 long (* DLSTDCALL pcsc_connect) (long context,
313                                  const char *reader,
314                                  pcsc_dword_t share_mode,
315                                  pcsc_dword_t preferred_protocols,
316                                  long *r_card,
317                                  pcsc_dword_t *r_active_protocol);
318 long (* DLSTDCALL pcsc_reconnect) (long card,
319                                    pcsc_dword_t share_mode,
320                                    pcsc_dword_t preferred_protocols,
321                                    pcsc_dword_t initialization,
322                                    pcsc_dword_t *r_active_protocol);
323 long (* DLSTDCALL pcsc_disconnect) (long card,
324                                     pcsc_dword_t disposition);
325 long (* DLSTDCALL pcsc_status) (long card,
326                                 char *reader, pcsc_dword_t *readerlen,
327                                 pcsc_dword_t *r_state,
328                                 pcsc_dword_t *r_protocol,
329                                 unsigned char *atr, pcsc_dword_t *atrlen);
330 long (* DLSTDCALL pcsc_begin_transaction) (long card);
331 long (* DLSTDCALL pcsc_end_transaction) (long card,
332                                          pcsc_dword_t disposition);
333 long (* DLSTDCALL pcsc_transmit) (long card,
334                                   const pcsc_io_request_t send_pci,
335                                   const unsigned char *send_buffer,
336                                   pcsc_dword_t send_len,
337                                   pcsc_io_request_t recv_pci,
338                                   unsigned char *recv_buffer,
339                                   pcsc_dword_t *recv_len);
340 long (* DLSTDCALL pcsc_set_timeout) (long context,
341                                      pcsc_dword_t timeout);
342 long (* DLSTDCALL pcsc_control) (long card,
343                                  pcsc_dword_t control_code,
344                                  const void *send_buffer,
345                                  pcsc_dword_t send_len,
346                                  void *recv_buffer,
347                                  pcsc_dword_t recv_len,
348                                  pcsc_dword_t *bytes_returned);
349
350
351 /*  Prototypes.  */
352 static int pcsc_get_status (int slot, unsigned int *status);
353 static int reset_pcsc_reader (int slot);
354 static int apdu_get_status_internal (int slot, int hang, int no_atr_reset,
355                                      unsigned int *status,
356                                      unsigned int *changed);
357 static int check_pcsc_pinpad (int slot, int command, pininfo_t *pininfo);
358 static int pcsc_pinpad_verify (int slot, int class, int ins, int p0, int p1,
359                                pininfo_t *pininfo);
360 static int pcsc_pinpad_modify (int slot, int class, int ins, int p0, int p1,
361                                pininfo_t *pininfo);
362
363
364 \f
365 /*
366       Helper
367  */
368
369
370 /* Find an unused reader slot for PORTSTR and put it into the reader
371    table.  Return -1 on error or the index into the reader table. */
372 static int
373 new_reader_slot (void)
374 {
375   int i, reader = -1;
376   int err;
377
378   for (i=0; i < MAX_READER; i++)
379     {
380       if (!reader_table[i].used && reader == -1)
381         reader = i;
382     }
383   if (reader == -1)
384     {
385       log_error ("new_reader_slot: out of slots\n");
386       return -1;
387     }
388 #ifdef USE_NPTH
389   if (!reader_table[reader].lock_initialized)
390     {
391       err = npth_mutex_init (&reader_table[reader].lock, NULL);
392       if (err)
393         {
394           log_error ("error initializing mutex: %s\n", strerror (err));
395           return -1;
396         }
397       reader_table[reader].lock_initialized = 1;
398     }
399 #endif /*USE_NPTH*/
400   reader_table[reader].connect_card = NULL;
401   reader_table[reader].disconnect_card = NULL;
402   reader_table[reader].close_reader = NULL;
403   reader_table[reader].shutdown_reader = NULL;
404   reader_table[reader].reset_reader = NULL;
405   reader_table[reader].get_status_reader = NULL;
406   reader_table[reader].send_apdu_reader = NULL;
407   reader_table[reader].check_pinpad = check_pcsc_pinpad;
408   reader_table[reader].dump_status_reader = NULL;
409   reader_table[reader].set_progress_cb = NULL;
410   reader_table[reader].pinpad_verify = pcsc_pinpad_verify;
411   reader_table[reader].pinpad_modify = pcsc_pinpad_modify;
412
413   reader_table[reader].used = 1;
414   reader_table[reader].any_status = 0;
415   reader_table[reader].last_status = 0;
416   reader_table[reader].is_t0 = 1;
417   reader_table[reader].is_spr532 = 0;
418   reader_table[reader].pinpad_varlen_supported = 0;
419 #ifdef NEED_PCSC_WRAPPER
420   reader_table[reader].pcsc.req_fd = -1;
421   reader_table[reader].pcsc.rsp_fd = -1;
422   reader_table[reader].pcsc.pid = (pid_t)(-1);
423 #endif
424   reader_table[reader].pcsc.verify_ioctl = 0;
425   reader_table[reader].pcsc.modify_ioctl = 0;
426   reader_table[reader].pcsc.pinmin = -1;
427   reader_table[reader].pcsc.pinmax = -1;
428
429   return reader;
430 }
431
432
433 static void
434 dump_reader_status (int slot)
435 {
436   if (!opt.verbose)
437     return;
438
439   if (reader_table[slot].dump_status_reader)
440     reader_table[slot].dump_status_reader (slot);
441
442   if (reader_table[slot].status != -1
443       && reader_table[slot].atrlen)
444     {
445       log_info ("slot %d: ATR=", slot);
446       log_printhex ("", reader_table[slot].atr, reader_table[slot].atrlen);
447     }
448 }
449
450
451
452 static const char *
453 host_sw_string (long err)
454 {
455   switch (err)
456     {
457     case 0: return "okay";
458     case SW_HOST_OUT_OF_CORE: return "out of core";
459     case SW_HOST_INV_VALUE: return "invalid value";
460     case SW_HOST_NO_DRIVER: return "no driver";
461     case SW_HOST_NOT_SUPPORTED: return "not supported";
462     case SW_HOST_LOCKING_FAILED: return "locking failed";
463     case SW_HOST_BUSY: return "busy";
464     case SW_HOST_NO_CARD: return "no card";
465     case SW_HOST_CARD_INACTIVE: return "card inactive";
466     case SW_HOST_CARD_IO_ERROR: return "card I/O error";
467     case SW_HOST_GENERAL_ERROR: return "general error";
468     case SW_HOST_NO_READER: return "no reader";
469     case SW_HOST_ABORTED: return "aborted";
470     case SW_HOST_NO_PINPAD: return "no pinpad";
471     case SW_HOST_ALREADY_CONNECTED: return "already connected";
472     default: return "unknown host status error";
473     }
474 }
475
476
477 const char *
478 apdu_strerror (int rc)
479 {
480   switch (rc)
481     {
482     case SW_EOF_REACHED    : return "eof reached";
483     case SW_EEPROM_FAILURE : return "eeprom failure";
484     case SW_WRONG_LENGTH   : return "wrong length";
485     case SW_CHV_WRONG      : return "CHV wrong";
486     case SW_CHV_BLOCKED    : return "CHV blocked";
487     case SW_USE_CONDITIONS : return "use conditions not satisfied";
488     case SW_BAD_PARAMETER  : return "bad parameter";
489     case SW_NOT_SUPPORTED  : return "not supported";
490     case SW_FILE_NOT_FOUND : return "file not found";
491     case SW_RECORD_NOT_FOUND:return "record not found";
492     case SW_REF_NOT_FOUND  : return "reference not found";
493     case SW_NOT_ENOUGH_MEMORY: return "not enough memory space in the file";
494     case SW_INCONSISTENT_LC: return "Lc inconsistent with TLV structure.";
495     case SW_INCORRECT_P0_P1: return "incorrect parameters P0,P1";
496     case SW_BAD_LC         : return "Lc inconsistent with P0,P1";
497     case SW_BAD_P0_P1      : return "bad P0,P1";
498     case SW_INS_NOT_SUP    : return "instruction not supported";
499     case SW_CLA_NOT_SUP    : return "class not supported";
500     case SW_SUCCESS        : return "success";
501     default:
502       if ((rc & ~0x00ff) == SW_MORE_DATA)
503         return "more data available";
504       if ( (rc & 0x10000) )
505         return host_sw_string (rc);
506       return "unknown status error";
507     }
508 }
509
510
511 \f
512 /*
513        ct API Interface
514  */
515
516 static const char *
517 ct_error_string (long err)
518 {
519   switch (err)
520     {
521     case 0: return "okay";
522     case -1: return "invalid data";
523     case -8: return "ct error";
524     case -10: return "transmission error";
525     case -11: return "memory allocation error";
526     case -128: return "HTSI error";
527     default: return "unknown CT-API error";
528     }
529 }
530
531
532 static void
533 ct_dump_reader_status (int slot)
534 {
535   log_info ("reader slot %d: %s\n", slot,
536             reader_table[slot].status == 1? "Processor ICC present" :
537             reader_table[slot].status == 0? "Memory ICC present" :
538             "ICC not present" );
539 }
540
541
542 /* Wait for the card in SLOT and activate it.  Return a status word
543    error or 0 on success. */
544 static int
545 ct_activate_card (int slot)
546 {
547   int rc;
548   unsigned char dad[1], sad[1], cmd[11], buf[256];
549   unsigned short buflen;
550
551   /* Check whether card has been inserted. */
552   dad[0] = 1;     /* Destination address: CT. */
553   sad[0] = 2;     /* Source address: Host. */
554
555   cmd[0] = 0x20;  /* Class byte. */
556   cmd[1] = 0x13;  /* Request status. */
557   cmd[2] = 0x00;  /* From kernel. */
558   cmd[3] = 0x80;  /* Return card's DO. */
559   cmd[4] = 0x00;
560
561   buflen = DIM(buf);
562
563   rc = CT_data (slot, dad, sad, 5, cmd, &buflen, buf);
564   if (rc || buflen < 2 || buf[buflen-2] != 0x90)
565     {
566       log_error ("ct_activate_card: can't get status of reader %d: %s\n",
567                  slot, ct_error_string (rc));
568       return SW_HOST_CARD_IO_ERROR;
569     }
570
571   /* Connected, now activate the card. */
572   dad[0] = 1;    /* Destination address: CT. */
573   sad[0] = 2;    /* Source address: Host. */
574
575   cmd[0] = 0x20;  /* Class byte. */
576   cmd[1] = 0x12;  /* Request ICC. */
577   cmd[2] = 0x01;  /* From first interface. */
578   cmd[3] = 0x01;  /* Return card's ATR. */
579   cmd[4] = 0x00;
580
581   buflen = DIM(buf);
582
583   rc = CT_data (slot, dad, sad, 5, cmd, &buflen, buf);
584   if (rc || buflen < 2 || buf[buflen-2] != 0x90)
585     {
586       log_error ("ct_activate_card(%d): activation failed: %s\n",
587                  slot, ct_error_string (rc));
588       if (!rc)
589         log_printhex ("  received data:", buf, buflen);
590       return SW_HOST_CARD_IO_ERROR;
591     }
592
593   /* Store the type and the ATR. */
594   if (buflen - 2 > DIM (reader_table[0].atr))
595     {
596       log_error ("ct_activate_card(%d): ATR too long\n", slot);
597       return SW_HOST_CARD_IO_ERROR;
598     }
599
600   reader_table[slot].status = buf[buflen - 1];
601   memcpy (reader_table[slot].atr, buf, buflen - 2);
602   reader_table[slot].atrlen = buflen - 2;
603   return 0;
604 }
605
606
607 static int
608 close_ct_reader (int slot)
609 {
610   CT_close (slot);
611   reader_table[slot].used = 0;
612   return 0;
613 }
614
615 static int
616 reset_ct_reader (int slot)
617 {
618   /* FIXME: Check is this is sufficient do do a reset. */
619   return ct_activate_card (slot);
620 }
621
622
623 static int
624 ct_get_status (int slot, unsigned int *status)
625 {
626   (void)slot;
627   /* The status we returned is wrong but we don't care becuase ctAPI
628      is not anymore required.  */
629   *status = APDU_CARD_USABLE|APDU_CARD_PRESENT|APDU_CARD_ACTIVE;
630   return 0;
631 }
632
633 /* Actually send the APDU of length APDULEN to SLOT and return a
634    maximum of *BUFLEN data in BUFFER, the actual retruned size will be
635    set to BUFLEN.  Returns: CT API error code. */
636 static int
637 ct_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
638               unsigned char *buffer, size_t *buflen, pininfo_t *pininfo)
639 {
640   int rc;
641   unsigned char dad[1], sad[1];
642   unsigned short ctbuflen;
643
644   (void)pininfo;
645
646   /* If we don't have an ATR, we need to reset the reader first. */
647   if (!reader_table[slot].atrlen
648       && (rc = reset_ct_reader (slot)))
649     return rc;
650
651   dad[0] = 0;     /* Destination address: Card. */
652   sad[0] = 2;     /* Source address: Host. */
653   ctbuflen = *buflen;
654   if (DBG_CARD_IO)
655     log_printhex ("  CT_data:", apdu, apdulen);
656   rc = CT_data (slot, dad, sad, apdulen, apdu, &ctbuflen, buffer);
657   *buflen = ctbuflen;
658
659   return rc? SW_HOST_CARD_IO_ERROR: 0;
660 }
661
662
663
664 /* Open a reader and return an internal handle for it.  PORT is a
665    non-negative value with the port number of the reader. USB readers
666    do have port numbers starting at 32769. */
667 static int
668 open_ct_reader (int port)
669 {
670   int rc, reader;
671
672   if (port < 0 || port > 0xffff)
673     {
674       log_error ("open_ct_reader: invalid port %d requested\n", port);
675       return -1;
676     }
677   reader = new_reader_slot ();
678   if (reader == -1)
679     return reader;
680   reader_table[reader].port = port;
681
682   rc = CT_init (reader, (unsigned short)port);
683   if (rc)
684     {
685       log_error ("apdu_open_ct_reader failed on port %d: %s\n",
686                  port, ct_error_string (rc));
687       reader_table[reader].used = 0;
688       return -1;
689     }
690
691   /* Only try to activate the card. */
692   rc = ct_activate_card (reader);
693   if (rc)
694     {
695       reader_table[reader].atrlen = 0;
696       rc = 0;
697     }
698
699   reader_table[reader].close_reader = close_ct_reader;
700   reader_table[reader].reset_reader = reset_ct_reader;
701   reader_table[reader].get_status_reader = ct_get_status;
702   reader_table[reader].send_apdu_reader = ct_send_apdu;
703   reader_table[reader].check_pinpad = NULL;
704   reader_table[reader].dump_status_reader = ct_dump_reader_status;
705   reader_table[reader].pinpad_verify = NULL;
706   reader_table[reader].pinpad_modify = NULL;
707
708   dump_reader_status (reader);
709   return reader;
710 }
711
712 \f
713 /*
714        PC/SC Interface
715  */
716
717 #ifdef NEED_PCSC_WRAPPER
718 static int
719 writen (int fd, const void *buf, size_t nbytes)
720 {
721   size_t nleft = nbytes;
722   int nwritten;
723
724 /*   log_printhex (" writen:", buf, nbytes); */
725
726   while (nleft > 0)
727     {
728 #ifdef USE_NPTH
729       nwritten = npth_write (fd, buf, nleft);
730 #else
731       nwritten = write (fd, buf, nleft);
732 #endif
733       if (nwritten < 0 && errno == EINTR)
734         continue;
735       if (nwritten < 0)
736         return -1;
737       nleft -= nwritten;
738       buf = (const char*)buf + nwritten;
739     }
740   return 0;
741 }
742
743 /* Read up to BUFLEN bytes from FD and return the number of bytes
744    actually read in NREAD.  Returns -1 on error or 0 on success. */
745 static int
746 readn (int fd, void *buf, size_t buflen, size_t *nread)
747 {
748   size_t nleft = buflen;
749   int n;
750 /*   void *orig_buf = buf; */
751
752   while (nleft > 0)
753     {
754 #ifdef USE_NPTH
755 # ifdef HAVE_W32_SYSTEM
756 #  error Cannot use npth_read here because it expects a system HANDLE.
757 # endif
758       n = npth_read (fd, buf, nleft);
759 #else
760       n = read (fd, buf, nleft);
761 #endif
762       if (n < 0 && errno == EINTR)
763         continue;
764       if (n < 0)
765         return -1; /* read error. */
766       if (!n)
767         break; /* EOF */
768       nleft -= n;
769       buf = (char*)buf + n;
770     }
771   if (nread)
772     *nread = buflen - nleft;
773
774 /*   log_printhex ("  readn:", orig_buf, *nread); */
775
776   return 0;
777 }
778 #endif /*NEED_PCSC_WRAPPER*/
779
780 static const char *
781 pcsc_error_string (long err)
782 {
783   const char *s;
784
785   if (!err)
786     return "okay";
787   if ((err & 0x80100000) != 0x80100000)
788     return "invalid PC/SC error code";
789   err &= 0xffff;
790   switch (err)
791     {
792     case 0x0002: s = "cancelled"; break;
793     case 0x000e: s = "can't dispose"; break;
794     case 0x0008: s = "insufficient buffer"; break;
795     case 0x0015: s = "invalid ATR"; break;
796     case 0x0003: s = "invalid handle"; break;
797     case 0x0004: s = "invalid parameter"; break;
798     case 0x0005: s = "invalid target"; break;
799     case 0x0011: s = "invalid value"; break;
800     case 0x0006: s = "no memory"; break;
801     case 0x0013: s = "comm error"; break;
802     case 0x0001: s = "internal error"; break;
803     case 0x0014: s = "unknown error"; break;
804     case 0x0007: s = "waited too long"; break;
805     case 0x0009: s = "unknown reader"; break;
806     case 0x000a: s = "timeout"; break;
807     case 0x000b: s = "sharing violation"; break;
808     case 0x000c: s = "no smartcard"; break;
809     case 0x000d: s = "unknown card"; break;
810     case 0x000f: s = "proto mismatch"; break;
811     case 0x0010: s = "not ready"; break;
812     case 0x0012: s = "system cancelled"; break;
813     case 0x0016: s = "not transacted"; break;
814     case 0x0017: s = "reader unavailable"; break;
815     case 0x0065: s = "unsupported card"; break;
816     case 0x0066: s = "unresponsive card"; break;
817     case 0x0067: s = "unpowered card"; break;
818     case 0x0068: s = "reset card"; break;
819     case 0x0069: s = "removed card"; break;
820     case 0x006a: s = "inserted card"; break;
821     case 0x001f: s = "unsupported feature"; break;
822     case 0x0019: s = "PCI too small"; break;
823     case 0x001a: s = "reader unsupported"; break;
824     case 0x001b: s = "duplicate reader"; break;
825     case 0x001c: s = "card unsupported"; break;
826     case 0x001d: s = "no service"; break;
827     case 0x001e: s = "service stopped"; break;
828     default:     s = "unknown PC/SC error code"; break;
829     }
830   return s;
831 }
832
833 /* Map PC/SC error codes to our special host status words.  */
834 static int
835 pcsc_error_to_sw (long ec)
836 {
837   int rc;
838
839   switch ( PCSC_ERR_MASK (ec) )
840     {
841     case 0:  rc = 0; break;
842
843     case PCSC_E_CANCELLED:           rc = SW_HOST_ABORTED; break;
844     case PCSC_E_NO_MEMORY:           rc = SW_HOST_OUT_OF_CORE; break;
845     case PCSC_E_TIMEOUT:             rc = SW_HOST_CARD_IO_ERROR; break;
846     case PCSC_E_UNKNOWN_READER:      rc = SW_HOST_NO_READER; break;
847     case PCSC_E_SHARING_VIOLATION:   rc = SW_HOST_LOCKING_FAILED; break;
848     case PCSC_E_NO_SMARTCARD:        rc = SW_HOST_NO_CARD; break;
849     case PCSC_W_REMOVED_CARD:        rc = SW_HOST_NO_CARD; break;
850
851     case PCSC_E_INVALID_TARGET:
852     case PCSC_E_INVALID_VALUE:
853     case PCSC_E_INVALID_HANDLE:
854     case PCSC_E_INVALID_PARAMETER:
855     case PCSC_E_INSUFFICIENT_BUFFER: rc = SW_HOST_INV_VALUE; break;
856
857     default:  rc = SW_HOST_GENERAL_ERROR; break;
858     }
859
860   return rc;
861 }
862
863 static void
864 dump_pcsc_reader_status (int slot)
865 {
866   if (reader_table[slot].pcsc.card)
867     {
868       log_info ("reader slot %d: active protocol:", slot);
869       if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T0))
870         log_printf (" T0");
871       else if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
872         log_printf (" T1");
873       else if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_RAW))
874         log_printf (" raw");
875       log_printf ("\n");
876     }
877   else
878     log_info ("reader slot %d: not connected\n", slot);
879 }
880
881
882 #ifndef NEED_PCSC_WRAPPER
883 static int
884 pcsc_get_status_direct (int slot, unsigned int *status)
885 {
886   long err;
887   struct pcsc_readerstate_s rdrstates[1];
888
889   memset (rdrstates, 0, sizeof *rdrstates);
890   rdrstates[0].reader = reader_table[slot].rdrname;
891   rdrstates[0].current_state = PCSC_STATE_UNAWARE;
892   err = pcsc_get_status_change (reader_table[slot].pcsc.context,
893                                 0,
894                                 rdrstates, 1);
895   if (err == PCSC_E_TIMEOUT)
896     err = 0; /* Timeout is no error error here. */
897   if (err)
898     {
899       log_error ("pcsc_get_status_change failed: %s (0x%lx)\n",
900                  pcsc_error_string (err), err);
901       return pcsc_error_to_sw (err);
902     }
903
904   /*   log_debug  */
905   /*     ("pcsc_get_status_change: %s%s%s%s%s%s%s%s%s%s\n", */
906   /*      (rdrstates[0].event_state & PCSC_STATE_IGNORE)? " ignore":"", */
907   /*      (rdrstates[0].event_state & PCSC_STATE_CHANGED)? " changed":"", */
908   /*      (rdrstates[0].event_state & PCSC_STATE_UNKNOWN)? " unknown":"", */
909   /*      (rdrstates[0].event_state & PCSC_STATE_UNAVAILABLE)?" unavail":"", */
910   /*      (rdrstates[0].event_state & PCSC_STATE_EMPTY)? " empty":"", */
911   /*      (rdrstates[0].event_state & PCSC_STATE_PRESENT)? " present":"", */
912   /*      (rdrstates[0].event_state & PCSC_STATE_ATRMATCH)? " atr":"", */
913   /*      (rdrstates[0].event_state & PCSC_STATE_EXCLUSIVE)? " excl":"", */
914   /*      (rdrstates[0].event_state & PCSC_STATE_INUSE)? " unuse":"", */
915   /*      (rdrstates[0].event_state & PCSC_STATE_MUTE)? " mute":"" ); */
916
917   *status = 0;
918   if ( (rdrstates[0].event_state & PCSC_STATE_PRESENT) )
919     {
920       *status |= APDU_CARD_PRESENT;
921       if ( !(rdrstates[0].event_state & PCSC_STATE_MUTE) )
922         *status |= APDU_CARD_ACTIVE;
923     }
924 #ifndef HAVE_W32_SYSTEM
925   /* We indicate a useful card if it is not in use by another
926      application.  This is because we only use exclusive access
927      mode.  */
928   if ( (*status & (APDU_CARD_PRESENT|APDU_CARD_ACTIVE))
929        == (APDU_CARD_PRESENT|APDU_CARD_ACTIVE)
930        && !(rdrstates[0].event_state & PCSC_STATE_INUSE) )
931     *status |= APDU_CARD_USABLE;
932 #else
933   /* Some winscard drivers may set EXCLUSIVE and INUSE at the same
934      time when we are the only user (SCM SCR335) under Windows.  */
935   if ((*status & (APDU_CARD_PRESENT|APDU_CARD_ACTIVE))
936       == (APDU_CARD_PRESENT|APDU_CARD_ACTIVE))
937     *status |= APDU_CARD_USABLE;
938 #endif
939
940   return 0;
941 }
942 #endif /*!NEED_PCSC_WRAPPER*/
943
944
945 #ifdef NEED_PCSC_WRAPPER
946 static int
947 pcsc_get_status_wrapped (int slot, unsigned int *status)
948 {
949   long err;
950   reader_table_t slotp;
951   size_t len, full_len;
952   int i, n;
953   unsigned char msgbuf[9];
954   unsigned char buffer[16];
955   int sw = SW_HOST_CARD_IO_ERROR;
956
957   slotp = reader_table + slot;
958
959   if (slotp->pcsc.req_fd == -1
960       || slotp->pcsc.rsp_fd == -1
961       || slotp->pcsc.pid == (pid_t)(-1) )
962     {
963       log_error ("pcsc_get_status: pcsc-wrapper not running\n");
964       return sw;
965     }
966
967   msgbuf[0] = 0x04; /* STATUS command. */
968   len = 0;
969   msgbuf[1] = (len >> 24);
970   msgbuf[2] = (len >> 16);
971   msgbuf[3] = (len >>  8);
972   msgbuf[4] = (len      );
973   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
974     {
975       log_error ("error sending PC/SC STATUS request: %s\n",
976                  strerror (errno));
977       goto command_failed;
978     }
979
980   /* Read the response. */
981   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
982     {
983       log_error ("error receiving PC/SC STATUS response: %s\n",
984                  i? strerror (errno) : "premature EOF");
985       goto command_failed;
986     }
987   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
988   if (msgbuf[0] != 0x81 || len < 4)
989     {
990       log_error ("invalid response header from PC/SC received\n");
991       goto command_failed;
992     }
993   len -= 4; /* Already read the error code. */
994   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
995                        | (msgbuf[7] << 8 ) | msgbuf[8]);
996   if (err)
997     {
998       log_error ("pcsc_status failed: %s (0x%lx)\n",
999                  pcsc_error_string (err), err);
1000       /* This is a proper error code, so return immediately.  */
1001       return pcsc_error_to_sw (err);
1002     }
1003
1004   full_len = len;
1005
1006   /* The current version returns 3 words but we allow also for old
1007      versions returning only 2 words. */
1008   n = 12 < len ? 12 : len;
1009   if ((i=readn (slotp->pcsc.rsp_fd, buffer, n, &len))
1010       || (len != 8 && len != 12))
1011     {
1012       log_error ("error receiving PC/SC STATUS response: %s\n",
1013                  i? strerror (errno) : "premature EOF");
1014       goto command_failed;
1015     }
1016
1017   slotp->is_t0 = (len == 12 && !!(buffer[11] & PCSC_PROTOCOL_T0));
1018
1019
1020   full_len -= len;
1021   /* Newer versions of the wrapper might send more status bytes.
1022      Read them. */
1023   while (full_len)
1024     {
1025       unsigned char dummybuf[128];
1026
1027       n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
1028       if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
1029         {
1030           log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1031                      i? strerror (errno) : "premature EOF");
1032           goto command_failed;
1033         }
1034       full_len -= n;
1035     }
1036
1037   /* We are lucky: The wrapper already returns the data in the
1038      required format. */
1039   *status = buffer[3];
1040   return 0;
1041
1042  command_failed:
1043   close (slotp->pcsc.req_fd);
1044   close (slotp->pcsc.rsp_fd);
1045   slotp->pcsc.req_fd = -1;
1046   slotp->pcsc.rsp_fd = -1;
1047   if (slotp->pcsc.pid != -1)
1048     kill (slotp->pcsc.pid, SIGTERM);
1049   slotp->pcsc.pid = (pid_t)(-1);
1050   slotp->used = 0;
1051   return sw;
1052 }
1053 #endif /*NEED_PCSC_WRAPPER*/
1054
1055
1056 static int
1057 pcsc_get_status (int slot, unsigned int *status)
1058 {
1059 #ifdef NEED_PCSC_WRAPPER
1060   return pcsc_get_status_wrapped (slot, status);
1061 #else
1062   return pcsc_get_status_direct (slot, status);
1063 #endif
1064 }
1065
1066
1067 #ifndef NEED_PCSC_WRAPPER
1068 static int
1069 pcsc_send_apdu_direct (int slot, unsigned char *apdu, size_t apdulen,
1070                        unsigned char *buffer, size_t *buflen,
1071                        pininfo_t *pininfo)
1072 {
1073   long err;
1074   struct pcsc_io_request_s send_pci;
1075   pcsc_dword_t recv_len;
1076
1077   if (!reader_table[slot].atrlen
1078       && (err = reset_pcsc_reader (slot)))
1079     return err;
1080
1081   if (DBG_CARD_IO)
1082     log_printhex ("  PCSC_data:", apdu, apdulen);
1083
1084   if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
1085       send_pci.protocol = PCSC_PROTOCOL_T1;
1086   else
1087       send_pci.protocol = PCSC_PROTOCOL_T0;
1088   send_pci.pci_len = sizeof send_pci;
1089   recv_len = *buflen;
1090   err = pcsc_transmit (reader_table[slot].pcsc.card,
1091                        &send_pci, apdu, apdulen,
1092                        NULL, buffer, &recv_len);
1093   *buflen = recv_len;
1094   if (err)
1095     log_error ("pcsc_transmit failed: %s (0x%lx)\n",
1096                pcsc_error_string (err), err);
1097
1098   return pcsc_error_to_sw (err);
1099 }
1100 #endif /*!NEED_PCSC_WRAPPER*/
1101
1102
1103 #ifdef NEED_PCSC_WRAPPER
1104 static int
1105 pcsc_send_apdu_wrapped (int slot, unsigned char *apdu, size_t apdulen,
1106                         unsigned char *buffer, size_t *buflen,
1107                         pininfo_t *pininfo)
1108 {
1109   long err;
1110   reader_table_t slotp;
1111   size_t len, full_len;
1112   int i, n;
1113   unsigned char msgbuf[9];
1114   int sw = SW_HOST_CARD_IO_ERROR;
1115
1116   (void)pininfo;
1117
1118   if (!reader_table[slot].atrlen
1119       && (err = reset_pcsc_reader (slot)))
1120     return err;
1121
1122   if (DBG_CARD_IO)
1123     log_printhex ("  PCSC_data:", apdu, apdulen);
1124
1125   slotp = reader_table + slot;
1126
1127   if (slotp->pcsc.req_fd == -1
1128       || slotp->pcsc.rsp_fd == -1
1129       || slotp->pcsc.pid == (pid_t)(-1) )
1130     {
1131       log_error ("pcsc_send_apdu: pcsc-wrapper not running\n");
1132       return sw;
1133     }
1134
1135   msgbuf[0] = 0x03; /* TRANSMIT command. */
1136   len = apdulen;
1137   msgbuf[1] = (len >> 24);
1138   msgbuf[2] = (len >> 16);
1139   msgbuf[3] = (len >>  8);
1140   msgbuf[4] = (len      );
1141   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
1142        || writen (slotp->pcsc.req_fd, apdu, len))
1143     {
1144       log_error ("error sending PC/SC TRANSMIT request: %s\n",
1145                  strerror (errno));
1146       goto command_failed;
1147     }
1148
1149   /* Read the response. */
1150   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1151     {
1152       log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1153                  i? strerror (errno) : "premature EOF");
1154       goto command_failed;
1155     }
1156   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1157   if (msgbuf[0] != 0x81 || len < 4)
1158     {
1159       log_error ("invalid response header from PC/SC received\n");
1160       goto command_failed;
1161     }
1162   len -= 4; /* Already read the error code. */
1163   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
1164                        | (msgbuf[7] << 8 ) | msgbuf[8]);
1165   if (err)
1166     {
1167       log_error ("pcsc_transmit failed: %s (0x%lx)\n",
1168                  pcsc_error_string (err), err);
1169       return pcsc_error_to_sw (err);
1170     }
1171
1172    full_len = len;
1173
1174    n = *buflen < len ? *buflen : len;
1175    if ((i=readn (slotp->pcsc.rsp_fd, buffer, n, &len)) || len != n)
1176      {
1177        log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1178                   i? strerror (errno) : "premature EOF");
1179        goto command_failed;
1180      }
1181    *buflen = n;
1182
1183    full_len -= len;
1184    if (full_len)
1185      {
1186        log_error ("pcsc_send_apdu: provided buffer too short - truncated\n");
1187        err = SW_HOST_INV_VALUE;
1188      }
1189    /* We need to read any rest of the response, to keep the
1190       protocol running.  */
1191    while (full_len)
1192      {
1193        unsigned char dummybuf[128];
1194
1195        n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
1196        if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
1197          {
1198            log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1199                       i? strerror (errno) : "premature EOF");
1200            goto command_failed;
1201          }
1202        full_len -= n;
1203      }
1204
1205    return err;
1206
1207  command_failed:
1208   close (slotp->pcsc.req_fd);
1209   close (slotp->pcsc.rsp_fd);
1210   slotp->pcsc.req_fd = -1;
1211   slotp->pcsc.rsp_fd = -1;
1212   if (slotp->pcsc.pid != -1)
1213     kill (slotp->pcsc.pid, SIGTERM);
1214   slotp->pcsc.pid = (pid_t)(-1);
1215   slotp->used = 0;
1216   return sw;
1217 }
1218 #endif /*NEED_PCSC_WRAPPER*/
1219
1220
1221 /* Send the APDU of length APDULEN to SLOT and return a maximum of
1222    *BUFLEN data in BUFFER, the actual returned size will be stored at
1223    BUFLEN.  Returns: A status word. */
1224 static int
1225 pcsc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
1226                 unsigned char *buffer, size_t *buflen,
1227                 pininfo_t *pininfo)
1228 {
1229 #ifdef NEED_PCSC_WRAPPER
1230   return pcsc_send_apdu_wrapped (slot, apdu, apdulen, buffer, buflen, pininfo);
1231 #else
1232   return pcsc_send_apdu_direct (slot, apdu, apdulen, buffer, buflen, pininfo);
1233 #endif
1234 }
1235
1236
1237 #ifndef NEED_PCSC_WRAPPER
1238 static int
1239 control_pcsc_direct (int slot, pcsc_dword_t ioctl_code,
1240                      const unsigned char *cntlbuf, size_t len,
1241                      unsigned char *buffer, pcsc_dword_t *buflen)
1242 {
1243   long err;
1244
1245   err = pcsc_control (reader_table[slot].pcsc.card, ioctl_code,
1246                       cntlbuf, len, buffer, *buflen, buflen);
1247   if (err)
1248     {
1249       log_error ("pcsc_control failed: %s (0x%lx)\n",
1250                  pcsc_error_string (err), err);
1251       return pcsc_error_to_sw (err);
1252     }
1253
1254   return 0;
1255 }
1256 #endif /*!NEED_PCSC_WRAPPER*/
1257
1258
1259 #ifdef NEED_PCSC_WRAPPER
1260 static int
1261 control_pcsc_wrapped (int slot, pcsc_dword_t ioctl_code,
1262                       const unsigned char *cntlbuf, size_t len,
1263                       unsigned char *buffer, pcsc_dword_t *buflen)
1264 {
1265   long err = PCSC_E_NOT_TRANSACTED;
1266   reader_table_t slotp;
1267   unsigned char msgbuf[9];
1268   int i, n;
1269   size_t full_len;
1270
1271   slotp = reader_table + slot;
1272
1273   msgbuf[0] = 0x06; /* CONTROL command. */
1274   msgbuf[1] = ((len + 4) >> 24);
1275   msgbuf[2] = ((len + 4) >> 16);
1276   msgbuf[3] = ((len + 4) >>  8);
1277   msgbuf[4] = ((len + 4)      );
1278   msgbuf[5] = (ioctl_code >> 24);
1279   msgbuf[6] = (ioctl_code >> 16);
1280   msgbuf[7] = (ioctl_code >>  8);
1281   msgbuf[8] = (ioctl_code      );
1282   if ( writen (slotp->pcsc.req_fd, msgbuf, 9)
1283        || writen (slotp->pcsc.req_fd, cntlbuf, len))
1284     {
1285       log_error ("error sending PC/SC CONTROL request: %s\n",
1286                  strerror (errno));
1287       goto command_failed;
1288     }
1289
1290   /* Read the response. */
1291   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1292     {
1293       log_error ("error receiving PC/SC CONTROL response: %s\n",
1294                  i? strerror (errno) : "premature EOF");
1295       goto command_failed;
1296     }
1297   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1298   if (msgbuf[0] != 0x81 || len < 4)
1299     {
1300       log_error ("invalid response header from PC/SC received\n");
1301       goto command_failed;
1302     }
1303   len -= 4; /* Already read the error code. */
1304   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
1305                        | (msgbuf[7] << 8 ) | msgbuf[8]);
1306   if (err)
1307     {
1308       log_error ("pcsc_control failed: %s (0x%lx)\n",
1309                  pcsc_error_string (err), err);
1310       return pcsc_error_to_sw (err);
1311     }
1312
1313   full_len = len;
1314
1315   n = *buflen < len ? *buflen : len;
1316   if ((i=readn (slotp->pcsc.rsp_fd, buffer, n, &len)) || len != n)
1317     {
1318       log_error ("error receiving PC/SC CONTROL response: %s\n",
1319                  i? strerror (errno) : "premature EOF");
1320       goto command_failed;
1321     }
1322   *buflen = n;
1323
1324   full_len -= len;
1325   if (full_len)
1326     {
1327       log_error ("pcsc_send_apdu: provided buffer too short - truncated\n");
1328       err = PCSC_E_INVALID_VALUE;
1329     }
1330   /* We need to read any rest of the response, to keep the
1331      protocol running.  */
1332   while (full_len)
1333     {
1334       unsigned char dummybuf[128];
1335
1336       n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
1337       if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
1338         {
1339           log_error ("error receiving PC/SC CONTROL response: %s\n",
1340                      i? strerror (errno) : "premature EOF");
1341           goto command_failed;
1342         }
1343       full_len -= n;
1344     }
1345
1346   if (!err)
1347     return 0;
1348
1349  command_failed:
1350   close (slotp->pcsc.req_fd);
1351   close (slotp->pcsc.rsp_fd);
1352   slotp->pcsc.req_fd = -1;
1353   slotp->pcsc.rsp_fd = -1;
1354   if (slotp->pcsc.pid != -1)
1355     kill (slotp->pcsc.pid, SIGTERM);
1356   slotp->pcsc.pid = (pid_t)(-1);
1357   slotp->used = 0;
1358   return pcsc_error_to_sw (err);
1359 }
1360 #endif /*NEED_PCSC_WRAPPER*/
1361
1362
1363
1364 /* Do some control with the value of IOCTL_CODE to the card inserted
1365    to SLOT.  Input buffer is specified by CNTLBUF of length LEN.
1366    Output buffer is specified by BUFFER of length *BUFLEN, and the
1367    actual output size will be stored at BUFLEN.  Returns: A status word.
1368    This routine is used for PIN pad input support.  */
1369 static int
1370 control_pcsc (int slot, pcsc_dword_t ioctl_code,
1371               const unsigned char *cntlbuf, size_t len,
1372               unsigned char *buffer, pcsc_dword_t *buflen)
1373 {
1374 #ifdef NEED_PCSC_WRAPPER
1375   return control_pcsc_wrapped (slot, ioctl_code, cntlbuf, len, buffer, buflen);
1376 #else
1377   return control_pcsc_direct (slot, ioctl_code, cntlbuf, len, buffer, buflen);
1378 #endif
1379 }
1380
1381
1382 #ifndef NEED_PCSC_WRAPPER
1383 static int
1384 close_pcsc_reader_direct (int slot)
1385 {
1386   pcsc_release_context (reader_table[slot].pcsc.context);
1387   xfree (reader_table[slot].rdrname);
1388   reader_table[slot].rdrname = NULL;
1389   reader_table[slot].used = 0;
1390   return 0;
1391 }
1392 #endif /*!NEED_PCSC_WRAPPER*/
1393
1394
1395 #ifdef NEED_PCSC_WRAPPER
1396 static int
1397 close_pcsc_reader_wrapped (int slot)
1398 {
1399   long err;
1400   reader_table_t slotp;
1401   size_t len;
1402   int i;
1403   unsigned char msgbuf[9];
1404
1405   slotp = reader_table + slot;
1406
1407   if (slotp->pcsc.req_fd == -1
1408       || slotp->pcsc.rsp_fd == -1
1409       || slotp->pcsc.pid == (pid_t)(-1) )
1410     {
1411       log_error ("close_pcsc_reader: pcsc-wrapper not running\n");
1412       return 0;
1413     }
1414
1415   msgbuf[0] = 0x02; /* CLOSE command. */
1416   len = 0;
1417   msgbuf[1] = (len >> 24);
1418   msgbuf[2] = (len >> 16);
1419   msgbuf[3] = (len >>  8);
1420   msgbuf[4] = (len      );
1421   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
1422     {
1423       log_error ("error sending PC/SC CLOSE request: %s\n",
1424                  strerror (errno));
1425       goto command_failed;
1426     }
1427
1428   /* Read the response. */
1429   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1430     {
1431       log_error ("error receiving PC/SC CLOSE response: %s\n",
1432                  i? strerror (errno) : "premature EOF");
1433       goto command_failed;
1434     }
1435   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1436   if (msgbuf[0] != 0x81 || len < 4)
1437     {
1438       log_error ("invalid response header from PC/SC received\n");
1439       goto command_failed;
1440     }
1441   len -= 4; /* Already read the error code. */
1442   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
1443                        | (msgbuf[7] << 8 ) | msgbuf[8]);
1444   if (err)
1445     log_error ("pcsc_close failed: %s (0x%lx)\n",
1446                pcsc_error_string (err), err);
1447
1448   /* We will close the wrapper in any case - errors are merely
1449      informational. */
1450
1451  command_failed:
1452   close (slotp->pcsc.req_fd);
1453   close (slotp->pcsc.rsp_fd);
1454   slotp->pcsc.req_fd = -1;
1455   slotp->pcsc.rsp_fd = -1;
1456   if (slotp->pcsc.pid != -1)
1457     kill (slotp->pcsc.pid, SIGTERM);
1458   slotp->pcsc.pid = (pid_t)(-1);
1459   slotp->used = 0;
1460   return 0;
1461 }
1462 #endif /*NEED_PCSC_WRAPPER*/
1463
1464
1465 static int
1466 close_pcsc_reader (int slot)
1467 {
1468 #ifdef NEED_PCSC_WRAPPER
1469   return close_pcsc_reader_wrapped (slot);
1470 #else
1471   return close_pcsc_reader_direct (slot);
1472 #endif
1473 }
1474
1475
1476 /* Connect a PC/SC card.  */
1477 #ifndef NEED_PCSC_WRAPPER
1478 static int
1479 connect_pcsc_card (int slot)
1480 {
1481   long err;
1482
1483   assert (slot >= 0 && slot < MAX_READER);
1484
1485   if (reader_table[slot].pcsc.card)
1486     return SW_HOST_ALREADY_CONNECTED;
1487
1488   reader_table[slot].atrlen = 0;
1489   reader_table[slot].last_status = 0;
1490   reader_table[slot].is_t0 = 0;
1491
1492   err = pcsc_connect (reader_table[slot].pcsc.context,
1493                       reader_table[slot].rdrname,
1494                       PCSC_SHARE_EXCLUSIVE,
1495                       PCSC_PROTOCOL_T0|PCSC_PROTOCOL_T1,
1496                       &reader_table[slot].pcsc.card,
1497                       &reader_table[slot].pcsc.protocol);
1498   if (err)
1499     {
1500       reader_table[slot].pcsc.card = 0;
1501       if (err != PCSC_E_NO_SMARTCARD)
1502         log_error ("pcsc_connect failed: %s (0x%lx)\n",
1503                    pcsc_error_string (err), err);
1504     }
1505   else
1506     {
1507       char reader[250];
1508       pcsc_dword_t readerlen, atrlen;
1509       long card_state, card_protocol;
1510
1511       atrlen = DIM (reader_table[0].atr);
1512       readerlen = sizeof reader -1 ;
1513       err = pcsc_status (reader_table[slot].pcsc.card,
1514                          reader, &readerlen,
1515                          &card_state, &card_protocol,
1516                          reader_table[slot].atr, &atrlen);
1517       if (err)
1518         log_error ("pcsc_status failed: %s (0x%lx) %lu\n",
1519                    pcsc_error_string (err), err, readerlen);
1520       else
1521         {
1522           if (atrlen > DIM (reader_table[0].atr))
1523             log_bug ("ATR returned by pcsc_status is too large\n");
1524           reader_table[slot].atrlen = atrlen;
1525           /* If we got to here we know that a card is present
1526              and usable.  Remember this.  */
1527           reader_table[slot].last_status = (   APDU_CARD_USABLE
1528                                              | APDU_CARD_PRESENT
1529                                              | APDU_CARD_ACTIVE);
1530           reader_table[slot].is_t0 = !!(card_protocol & PCSC_PROTOCOL_T0);
1531         }
1532     }
1533
1534   dump_reader_status (slot);
1535   return pcsc_error_to_sw (err);
1536 }
1537 #endif /*!NEED_PCSC_WRAPPER*/
1538
1539
1540 /* Disconnect a PC/SC card.  Note that this succeeds even if the card
1541    is not connected.  */
1542 #ifndef NEED_PCSC_WRAPPER
1543 static int
1544 disconnect_pcsc_card (int slot)
1545 {
1546   long err;
1547
1548   assert (slot >= 0 && slot < MAX_READER);
1549
1550   if (!reader_table[slot].pcsc.card)
1551     return 0;
1552
1553   err = pcsc_disconnect (reader_table[slot].pcsc.card, PCSC_LEAVE_CARD);
1554   if (err)
1555     {
1556       log_error ("pcsc_disconnect failed: %s (0x%lx)\n",
1557                  pcsc_error_string (err), err);
1558       return SW_HOST_CARD_IO_ERROR;
1559     }
1560   reader_table[slot].pcsc.card = 0;
1561   return 0;
1562 }
1563 #endif /*!NEED_PCSC_WRAPPER*/
1564
1565
1566 #ifndef NEED_PCSC_WRAPPER
1567 static int
1568 reset_pcsc_reader_direct (int slot)
1569 {
1570   int sw;
1571
1572   sw = disconnect_pcsc_card (slot);
1573   if (!sw)
1574     sw = connect_pcsc_card (slot);
1575
1576   return sw;
1577 }
1578 #endif /*NEED_PCSC_WRAPPER*/
1579
1580
1581 #ifdef NEED_PCSC_WRAPPER
1582 static int
1583 reset_pcsc_reader_wrapped (int slot)
1584 {
1585   long err;
1586   reader_table_t slotp;
1587   size_t len;
1588   int i, n;
1589   unsigned char msgbuf[9];
1590   unsigned int dummy_status;
1591   int sw = SW_HOST_CARD_IO_ERROR;
1592
1593   slotp = reader_table + slot;
1594
1595   if (slotp->pcsc.req_fd == -1
1596       || slotp->pcsc.rsp_fd == -1
1597       || slotp->pcsc.pid == (pid_t)(-1) )
1598     {
1599       log_error ("pcsc_get_status: pcsc-wrapper not running\n");
1600       return sw;
1601     }
1602
1603   msgbuf[0] = 0x05; /* RESET command. */
1604   len = 0;
1605   msgbuf[1] = (len >> 24);
1606   msgbuf[2] = (len >> 16);
1607   msgbuf[3] = (len >>  8);
1608   msgbuf[4] = (len      );
1609   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
1610     {
1611       log_error ("error sending PC/SC RESET request: %s\n",
1612                  strerror (errno));
1613       goto command_failed;
1614     }
1615
1616   /* Read the response. */
1617   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1618     {
1619       log_error ("error receiving PC/SC RESET response: %s\n",
1620                  i? strerror (errno) : "premature EOF");
1621       goto command_failed;
1622     }
1623   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1624   if (msgbuf[0] != 0x81 || len < 4)
1625     {
1626       log_error ("invalid response header from PC/SC received\n");
1627       goto command_failed;
1628     }
1629   len -= 4; /* Already read the error code. */
1630   if (len > DIM (slotp->atr))
1631     {
1632       log_error ("PC/SC returned a too large ATR (len=%lx)\n",
1633                  (unsigned long)len);
1634       sw = SW_HOST_GENERAL_ERROR;
1635       goto command_failed;
1636     }
1637   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
1638                        | (msgbuf[7] << 8 ) | msgbuf[8]);
1639   if (err)
1640     {
1641       log_error ("PC/SC RESET failed: %s (0x%lx)\n",
1642                  pcsc_error_string (err), err);
1643       /* If the error code is no smart card, we should not considere
1644          this a major error and close the wrapper.  */
1645       sw = pcsc_error_to_sw (err);
1646       if (err == PCSC_E_NO_SMARTCARD)
1647         return sw;
1648       goto command_failed;
1649     }
1650
1651   /* The open function may return a zero for the ATR length to
1652      indicate that no card is present.  */
1653   n = len;
1654   if (n)
1655     {
1656       if ((i=readn (slotp->pcsc.rsp_fd, slotp->atr, n, &len)) || len != n)
1657         {
1658           log_error ("error receiving PC/SC RESET response: %s\n",
1659                      i? strerror (errno) : "premature EOF");
1660           goto command_failed;
1661         }
1662     }
1663   slotp->atrlen = len;
1664
1665   /* Read the status so that IS_T0 will be set. */
1666   pcsc_get_status (slot, &dummy_status);
1667
1668   return 0;
1669
1670  command_failed:
1671   close (slotp->pcsc.req_fd);
1672   close (slotp->pcsc.rsp_fd);
1673   slotp->pcsc.req_fd = -1;
1674   slotp->pcsc.rsp_fd = -1;
1675   if (slotp->pcsc.pid != -1)
1676     kill (slotp->pcsc.pid, SIGTERM);
1677   slotp->pcsc.pid = (pid_t)(-1);
1678   slotp->used = 0;
1679   return sw;
1680 }
1681 #endif /* !NEED_PCSC_WRAPPER */
1682
1683
1684 /* Send an PC/SC reset command and return a status word on error or 0
1685    on success. */
1686 static int
1687 reset_pcsc_reader (int slot)
1688 {
1689 #ifdef NEED_PCSC_WRAPPER
1690   return reset_pcsc_reader_wrapped (slot);
1691 #else
1692   return reset_pcsc_reader_direct (slot);
1693 #endif
1694 }
1695
1696
1697 /* Examine reader specific parameters and initialize.  This is mostly
1698    for pinpad input.  Called at opening the connection to the reader.  */
1699 static int
1700 pcsc_vendor_specific_init (int slot)
1701 {
1702   unsigned char buf[256];
1703   pcsc_dword_t len;
1704   int sw;
1705   int vendor = 0;
1706   int product = 0;
1707   pcsc_dword_t get_tlv_ioctl = (pcsc_dword_t)-1;
1708   unsigned char *p;
1709
1710   len = sizeof (buf);
1711   sw = control_pcsc (slot, CM_IOCTL_GET_FEATURE_REQUEST, NULL, 0, buf, &len);
1712   if (sw)
1713     {
1714       log_error ("pcsc_vendor_specific_init: GET_FEATURE_REQUEST failed: %d\n",
1715                  sw);
1716       return SW_NOT_SUPPORTED;
1717     }
1718   else
1719     {
1720       p = buf;
1721       while (p < buf + len)
1722         {
1723           unsigned char code = *p++;
1724           int l = *p++;
1725           unsigned int v = 0;
1726
1727           if (l == 1)
1728             v = p[0];
1729           else if (l == 2)
1730             v = ((p[0] << 8) | p[1]);
1731           else if (l == 4)
1732             v = ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
1733
1734           if (code == FEATURE_VERIFY_PIN_DIRECT)
1735             reader_table[slot].pcsc.verify_ioctl = v;
1736           else if (code == FEATURE_MODIFY_PIN_DIRECT)
1737             reader_table[slot].pcsc.modify_ioctl = v;
1738           else if (code == FEATURE_GET_TLV_PROPERTIES)
1739             get_tlv_ioctl = v;
1740
1741           if (DBG_CARD_IO)
1742             log_debug ("feature: code=%02X, len=%d, v=%02X\n", code, l, v);
1743
1744           p += l;
1745         }
1746     }
1747
1748   if (get_tlv_ioctl == (pcsc_dword_t)-1)
1749     {
1750       /*
1751        * For system which doesn't support GET_TLV_PROPERTIES,
1752        * we put some heuristics here.
1753        */
1754       if (reader_table[slot].rdrname)
1755         {
1756           if (strstr (reader_table[slot].rdrname, "SPRx32"))
1757             {
1758               reader_table[slot].is_spr532 = 1;
1759               reader_table[slot].pinpad_varlen_supported = 1;
1760             }
1761           else if (strstr (reader_table[slot].rdrname, "ST-2xxx")
1762                    || strstr (reader_table[slot].rdrname, "cyberJack")
1763                    || strstr (reader_table[slot].rdrname, "DIGIPASS")
1764                    || strstr (reader_table[slot].rdrname, "Gnuk")
1765                    || strstr (reader_table[slot].rdrname, "KAAN"))
1766             reader_table[slot].pinpad_varlen_supported = 1;
1767         }
1768
1769       return 0;
1770     }
1771
1772   len = sizeof (buf);
1773   sw = control_pcsc (slot, get_tlv_ioctl, NULL, 0, buf, &len);
1774   if (sw)
1775     {
1776       log_error ("pcsc_vendor_specific_init: GET_TLV_IOCTL failed: %d\n", sw);
1777       return SW_NOT_SUPPORTED;
1778     }
1779
1780   p = buf;
1781   while (p < buf + len)
1782     {
1783       unsigned char tag = *p++;
1784       int l = *p++;
1785       unsigned int v = 0;
1786
1787       /* Umm... here is little endian, while the encoding above is big.  */
1788       if (l == 1)
1789         v = p[0];
1790       else if (l == 2)
1791         v = ((p[1] << 8) | p[0]);
1792       else if (l == 4)
1793         v = ((p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]);
1794
1795       if (tag == PCSCv2_PART10_PROPERTY_bMinPINSize)
1796         reader_table[slot].pcsc.pinmin = v;
1797       else if (tag == PCSCv2_PART10_PROPERTY_bMaxPINSize)
1798         reader_table[slot].pcsc.pinmax = v;
1799       else if (tag == PCSCv2_PART10_PROPERTY_wIdVendor)
1800         vendor = v;
1801       else if (tag == PCSCv2_PART10_PROPERTY_wIdProduct)
1802         product = v;
1803
1804       if (DBG_CARD_IO)
1805         log_debug ("TLV properties: tag=%02X, len=%d, v=%08X\n", tag, l, v);
1806
1807       p += l;
1808     }
1809
1810   if (vendor == VENDOR_VEGA && product == VEGA_ALPHA)
1811     {
1812       /*
1813        * Please read the comment of ccid_vendor_specific_init in
1814        * ccid-driver.c.
1815        */
1816       const unsigned char cmd[] = { '\xb5', '\x01', '\x00', '\x03', '\x00' };
1817       sw = control_pcsc (slot, CM_IOCTL_VENDOR_IFD_EXCHANGE,
1818                          cmd, sizeof (cmd), NULL, 0);
1819       if (sw)
1820         return SW_NOT_SUPPORTED;
1821     }
1822   else if (vendor == VENDOR_SCM && product == SCM_SPR532) /* SCM SPR532 */
1823     {
1824       reader_table[slot].is_spr532 = 1;
1825       reader_table[slot].pinpad_varlen_supported = 1;
1826     }
1827   else if (vendor == 0x046a && product == 0x003e  /* Cherry ST-2xxx */
1828            || vendor == 0x0c4b /* Tested with Reiner cyberJack GO */
1829            || vendor == 0x1a44 /* Tested with Vasco DIGIPASS 920 */
1830            || vendor == 0x234b /* Tested with FSIJ Gnuk Token */
1831            || vendor == 0x0d46 /* Tested with KAAN Advanced??? */)
1832     reader_table[slot].pinpad_varlen_supported = 1;
1833
1834   return 0;
1835 }
1836
1837
1838 /* Open the PC/SC reader without using the wrapper.  Returns -1 on
1839    error or a slot number for the reader.  */
1840 #ifndef NEED_PCSC_WRAPPER
1841 static int
1842 open_pcsc_reader_direct (const char *portstr)
1843 {
1844   long err;
1845   int slot;
1846   char *list = NULL;
1847   pcsc_dword_t nreader, listlen;
1848   char *p;
1849
1850   slot = new_reader_slot ();
1851   if (slot == -1)
1852     return -1;
1853
1854   /* Fixme: Allocating a context for each slot is not required.  One
1855      global context should be sufficient.  */
1856   err = pcsc_establish_context (PCSC_SCOPE_SYSTEM, NULL, NULL,
1857                                 &reader_table[slot].pcsc.context);
1858   if (err)
1859     {
1860       log_error ("pcsc_establish_context failed: %s (0x%lx)\n",
1861                  pcsc_error_string (err), err);
1862       reader_table[slot].used = 0;
1863       return -1;
1864     }
1865
1866   err = pcsc_list_readers (reader_table[slot].pcsc.context,
1867                            NULL, NULL, &nreader);
1868   if (!err)
1869     {
1870       list = xtrymalloc (nreader+1); /* Better add 1 for safety reasons. */
1871       if (!list)
1872         {
1873           log_error ("error allocating memory for reader list\n");
1874           pcsc_release_context (reader_table[slot].pcsc.context);
1875           reader_table[slot].used = 0;
1876           return -1 /*SW_HOST_OUT_OF_CORE*/;
1877         }
1878       err = pcsc_list_readers (reader_table[slot].pcsc.context,
1879                                NULL, list, &nreader);
1880     }
1881   if (err)
1882     {
1883       log_error ("pcsc_list_readers failed: %s (0x%lx)\n",
1884                  pcsc_error_string (err), err);
1885       pcsc_release_context (reader_table[slot].pcsc.context);
1886       reader_table[slot].used = 0;
1887       xfree (list);
1888       return -1;
1889     }
1890
1891   listlen = nreader;
1892   p = list;
1893   while (nreader)
1894     {
1895       if (!*p && !p[1])
1896         break;
1897       if (*p)
1898         log_info ("detected reader '%s'\n", p);
1899       if (nreader < (strlen (p)+1))
1900         {
1901           log_error ("invalid response from pcsc_list_readers\n");
1902           break;
1903         }
1904       nreader -= strlen (p)+1;
1905       p += strlen (p) + 1;
1906     }
1907
1908   reader_table[slot].rdrname = xtrymalloc (strlen (portstr? portstr : list)+1);
1909   if (!reader_table[slot].rdrname)
1910     {
1911       log_error ("error allocating memory for reader name\n");
1912       pcsc_release_context (reader_table[slot].pcsc.context);
1913       reader_table[slot].used = 0;
1914       return -1;
1915     }
1916   strcpy (reader_table[slot].rdrname, portstr? portstr : list);
1917   xfree (list);
1918   list = NULL;
1919
1920   reader_table[slot].pcsc.card = 0;
1921   reader_table[slot].atrlen = 0;
1922   reader_table[slot].last_status = 0;
1923
1924   reader_table[slot].connect_card = connect_pcsc_card;
1925   reader_table[slot].disconnect_card = disconnect_pcsc_card;
1926   reader_table[slot].close_reader = close_pcsc_reader;
1927   reader_table[slot].reset_reader = reset_pcsc_reader;
1928   reader_table[slot].get_status_reader = pcsc_get_status;
1929   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
1930   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
1931
1932   pcsc_vendor_specific_init (slot);
1933   dump_reader_status (slot);
1934   return slot;
1935 }
1936 #endif /*!NEED_PCSC_WRAPPER */
1937
1938
1939 /* Open the PC/SC reader using the pcsc_wrapper program.  This is
1940    needed to cope with different thread models and other peculiarities
1941    of libpcsclite. */
1942 #ifdef NEED_PCSC_WRAPPER
1943 static int
1944 open_pcsc_reader_wrapped (const char *portstr)
1945 {
1946   int slot;
1947   reader_table_t slotp;
1948   int fd, rp[2], wp[2];
1949   int n, i;
1950   pid_t pid;
1951   size_t len;
1952   unsigned char msgbuf[9];
1953   int err;
1954   unsigned int dummy_status;
1955
1956   /* Note that we use the constant and not the fucntion because this
1957      code won't be be used under Windows.  */
1958   const char *wrapperpgm = GNUPG_LIBEXECDIR "/gnupg-pcsc-wrapper";
1959
1960   if (access (wrapperpgm, X_OK))
1961     {
1962       log_error ("can't run PC/SC access module '%s': %s\n",
1963                  wrapperpgm, strerror (errno));
1964       return -1;
1965     }
1966
1967   slot = new_reader_slot ();
1968   if (slot == -1)
1969     return -1;
1970   slotp = reader_table + slot;
1971
1972   /* Fire up the PC/SCc wrapper.  We don't use any fork/exec code from
1973      the common directy but implement it directly so that this file
1974      may still be source copied. */
1975
1976   if (pipe (rp) == -1)
1977     {
1978       log_error ("error creating a pipe: %s\n", strerror (errno));
1979       slotp->used = 0;
1980       return -1;
1981     }
1982   if (pipe (wp) == -1)
1983     {
1984       log_error ("error creating a pipe: %s\n", strerror (errno));
1985       close (rp[0]);
1986       close (rp[1]);
1987       slotp->used = 0;
1988       return -1;
1989     }
1990
1991   pid = fork ();
1992   if (pid == -1)
1993     {
1994       log_error ("error forking process: %s\n", strerror (errno));
1995       close (rp[0]);
1996       close (rp[1]);
1997       close (wp[0]);
1998       close (wp[1]);
1999       slotp->used = 0;
2000       return -1;
2001     }
2002   slotp->pcsc.pid = pid;
2003
2004   if (!pid)
2005     { /*
2006          === Child ===
2007        */
2008
2009       /* Double fork. */
2010       pid = fork ();
2011       if (pid == -1)
2012         _exit (31);
2013       if (pid)
2014         _exit (0); /* Immediate exit this parent, so that the child
2015                       gets cleaned up by the init process. */
2016
2017       /* Connect our pipes. */
2018       if (wp[0] != 0 && dup2 (wp[0], 0) == -1)
2019         log_fatal ("dup2 stdin failed: %s\n", strerror (errno));
2020       if (rp[1] != 1 && dup2 (rp[1], 1) == -1)
2021         log_fatal ("dup2 stdout failed: %s\n", strerror (errno));
2022
2023       /* Send stderr to the bit bucket. */
2024       fd = open ("/dev/null", O_WRONLY);
2025       if (fd == -1)
2026         log_fatal ("can't open '/dev/null': %s", strerror (errno));
2027       if (fd != 2 && dup2 (fd, 2) == -1)
2028         log_fatal ("dup2 stderr failed: %s\n", strerror (errno));
2029
2030       /* Close all other files. */
2031       close_all_fds (3, NULL);
2032
2033       execl (wrapperpgm,
2034              "pcsc-wrapper",
2035              "--",
2036              "1", /* API version */
2037              opt.pcsc_driver, /* Name of the PC/SC library. */
2038               NULL);
2039       _exit (31);
2040     }
2041
2042   /*
2043      === Parent ===
2044    */
2045   close (wp[0]);
2046   close (rp[1]);
2047   slotp->pcsc.req_fd = wp[1];
2048   slotp->pcsc.rsp_fd = rp[0];
2049
2050   /* Wait for the intermediate child to terminate. */
2051 #ifdef USE_NPTH
2052 #define WAIT npth_waitpid
2053 #else
2054 #define WAIT waitpid
2055 #endif
2056   while ( (i=WAIT (pid, NULL, 0)) == -1 && errno == EINTR)
2057     ;
2058 #undef WAIT
2059
2060   /* Now send the open request. */
2061   msgbuf[0] = 0x01; /* OPEN command. */
2062   len = portstr? strlen (portstr):0;
2063   msgbuf[1] = (len >> 24);
2064   msgbuf[2] = (len >> 16);
2065   msgbuf[3] = (len >>  8);
2066   msgbuf[4] = (len      );
2067   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
2068        || (portstr && writen (slotp->pcsc.req_fd, portstr, len)))
2069     {
2070       log_error ("error sending PC/SC OPEN request: %s\n",
2071                  strerror (errno));
2072       goto command_failed;
2073     }
2074   /* Read the response. */
2075   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
2076     {
2077       log_error ("error receiving PC/SC OPEN response: %s\n",
2078                  i? strerror (errno) : "premature EOF");
2079       goto command_failed;
2080     }
2081   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
2082   if (msgbuf[0] != 0x81 || len < 4)
2083     {
2084       log_error ("invalid response header from PC/SC received\n");
2085       goto command_failed;
2086     }
2087   len -= 4; /* Already read the error code. */
2088   if (len > DIM (slotp->atr))
2089     {
2090       log_error ("PC/SC returned a too large ATR (len=%lx)\n",
2091                  (unsigned long)len);
2092       goto command_failed;
2093     }
2094   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
2095                        | (msgbuf[7] << 8 ) | msgbuf[8]);
2096
2097   if (err)
2098     {
2099       log_error ("PC/SC OPEN failed: %s\n", pcsc_error_string (err));
2100       goto command_failed;
2101     }
2102
2103   slotp->last_status = 0;
2104
2105   /* The open request may return a zero for the ATR length to
2106      indicate that no card is present.  */
2107   n = len;
2108   if (n)
2109     {
2110       if ((i=readn (slotp->pcsc.rsp_fd, slotp->atr, n, &len)) || len != n)
2111         {
2112           log_error ("error receiving PC/SC OPEN response: %s\n",
2113                      i? strerror (errno) : "premature EOF");
2114           goto command_failed;
2115         }
2116       /* If we got to here we know that a card is present
2117          and usable.  Thus remember this.  */
2118       slotp->last_status = (  APDU_CARD_USABLE
2119                             | APDU_CARD_PRESENT
2120                             | APDU_CARD_ACTIVE);
2121     }
2122   slotp->atrlen = len;
2123
2124   reader_table[slot].close_reader = close_pcsc_reader;
2125   reader_table[slot].reset_reader = reset_pcsc_reader;
2126   reader_table[slot].get_status_reader = pcsc_get_status;
2127   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
2128   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
2129
2130   pcsc_vendor_specific_init (slot);
2131
2132   /* Read the status so that IS_T0 will be set. */
2133   pcsc_get_status (slot, &dummy_status);
2134
2135   dump_reader_status (slot);
2136   return slot;
2137
2138  command_failed:
2139   close (slotp->pcsc.req_fd);
2140   close (slotp->pcsc.rsp_fd);
2141   slotp->pcsc.req_fd = -1;
2142   slotp->pcsc.rsp_fd = -1;
2143   if (slotp->pcsc.pid != -1)
2144     kill (slotp->pcsc.pid, SIGTERM);
2145   slotp->pcsc.pid = (pid_t)(-1);
2146   slotp->used = 0;
2147   /* There is no way to return SW. */
2148   return -1;
2149
2150 }
2151 #endif /*NEED_PCSC_WRAPPER*/
2152
2153
2154 static int
2155 open_pcsc_reader (const char *portstr)
2156 {
2157 #ifdef NEED_PCSC_WRAPPER
2158   return open_pcsc_reader_wrapped (portstr);
2159 #else
2160   return open_pcsc_reader_direct (portstr);
2161 #endif
2162 }
2163
2164
2165 /* Check whether the reader supports the ISO command code COMMAND
2166    on the pinpad.  Return 0 on success.  */
2167 static int
2168 check_pcsc_pinpad (int slot, int command, pininfo_t *pininfo)
2169 {
2170   int r;
2171
2172   pininfo->minlen = reader_table[slot].pcsc.pinmin;
2173   pininfo->maxlen = reader_table[slot].pcsc.pinmax;
2174
2175   if ((command == ISO7816_VERIFY && reader_table[slot].pcsc.verify_ioctl != 0)
2176       || (command == ISO7816_CHANGE_REFERENCE_DATA
2177           && reader_table[slot].pcsc.modify_ioctl != 0))
2178     r = 0;                       /* Success */
2179   else
2180     r = SW_NOT_SUPPORTED;
2181
2182   if (DBG_CARD_IO)
2183     log_debug ("check_pcsc_pinpad: command=%02X, r=%d\n",
2184                (unsigned int)command, r);
2185
2186   if (reader_table[slot].pinpad_varlen_supported)
2187     pininfo->fixedlen = 0;
2188
2189   return r;
2190 }
2191
2192 #define PIN_VERIFY_STRUCTURE_SIZE 24
2193 static int
2194 pcsc_pinpad_verify (int slot, int class, int ins, int p0, int p1,
2195                     pininfo_t *pininfo)
2196 {
2197   int sw;
2198   unsigned char *pin_verify;
2199   int len = PIN_VERIFY_STRUCTURE_SIZE + pininfo->fixedlen;
2200   unsigned char result[2];
2201   pcsc_dword_t resultlen = 2;
2202   int no_lc;
2203
2204   if (!reader_table[slot].atrlen
2205       && (sw = reset_pcsc_reader (slot)))
2206     return sw;
2207
2208   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2209     return SW_NOT_SUPPORTED;
2210
2211   if (!pininfo->minlen)
2212     pininfo->minlen = 1;
2213   if (!pininfo->maxlen)
2214     pininfo->maxlen = 15;
2215
2216   pin_verify = xtrymalloc (len);
2217   if (!pin_verify)
2218     return SW_HOST_OUT_OF_CORE;
2219
2220   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2221
2222   pin_verify[0] = 0x00; /* bTimeOut */
2223   pin_verify[1] = 0x00; /* bTimeOut2 */
2224   pin_verify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2225   pin_verify[3] = pininfo->fixedlen; /* bmPINBlockString */
2226   pin_verify[4] = 0x00; /* bmPINLengthFormat */
2227   pin_verify[5] = pininfo->maxlen; /* wPINMaxExtraDigit */
2228   pin_verify[6] = pininfo->minlen; /* wPINMaxExtraDigit */
2229   pin_verify[7] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2230   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2231     pin_verify[7] |= 0x01; /* Max size reached.  */
2232   pin_verify[8] = 0x01; /* bNumberMessage: One message */
2233   pin_verify[9] =  0x09; /* wLangId: 0x0409: US English */
2234   pin_verify[10] = 0x04; /* wLangId: 0x0409: US English */
2235   pin_verify[11] = 0x00; /* bMsgIndex */
2236   pin_verify[12] = 0x00; /* bTeoPrologue[0] */
2237   pin_verify[13] = 0x00; /* bTeoPrologue[1] */
2238   pin_verify[14] = pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2239   pin_verify[15] = pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2240   pin_verify[16] = 0x00; /* ulDataLength */
2241   pin_verify[17] = 0x00; /* ulDataLength */
2242   pin_verify[18] = 0x00; /* ulDataLength */
2243   pin_verify[19] = class; /* abData[0] */
2244   pin_verify[20] = ins; /* abData[1] */
2245   pin_verify[21] = p0; /* abData[2] */
2246   pin_verify[22] = p1; /* abData[3] */
2247   pin_verify[23] = pininfo->fixedlen; /* abData[4] */
2248   if (pininfo->fixedlen)
2249     memset (&pin_verify[24], 0xff, pininfo->fixedlen);
2250   else if (no_lc)
2251     len--;
2252
2253   if (DBG_CARD_IO)
2254     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2255                class, ins, p0, p1, len, pininfo->maxlen);
2256
2257   sw = control_pcsc (slot, reader_table[slot].pcsc.verify_ioctl,
2258                      pin_verify, len, result, &resultlen);
2259   xfree (pin_verify);
2260   if (sw || resultlen < 2)
2261     return sw? sw : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2262   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2263     {
2264       log_error ("control_pcsc failed: %d\n", sw);
2265       return sw? sw: SW_HOST_INCOMPLETE_CARD_RESPONSE;
2266     }
2267   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2268   if (DBG_CARD_IO)
2269     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2270   return sw;
2271 }
2272
2273
2274 #define PIN_MODIFY_STRUCTURE_SIZE 29
2275 static int
2276 pcsc_pinpad_modify (int slot, int class, int ins, int p0, int p1,
2277                     pininfo_t *pininfo)
2278 {
2279   int sw;
2280   unsigned char *pin_modify;
2281   int len = PIN_MODIFY_STRUCTURE_SIZE + 2 * pininfo->fixedlen;
2282   unsigned char result[2];
2283   pcsc_dword_t resultlen = 2;
2284   int no_lc;
2285
2286   if (!reader_table[slot].atrlen
2287       && (sw = reset_pcsc_reader (slot)))
2288     return sw;
2289
2290   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2291     return SW_NOT_SUPPORTED;
2292
2293   if (!pininfo->minlen)
2294     pininfo->minlen = 1;
2295   if (!pininfo->maxlen)
2296     pininfo->maxlen = 15;
2297
2298   /* Note that the 25 is the maximum value the SPR532 allows.  */
2299   if (pininfo->minlen < 1 || pininfo->minlen > 25
2300       || pininfo->maxlen < 1 || pininfo->maxlen > 25
2301       || pininfo->minlen > pininfo->maxlen)
2302     return SW_HOST_INV_VALUE;
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 <&n