scd: fix pinpad input on Windows.
[gnupg.git] / scd / apdu.c
1 /* apdu.c - ISO 7816 APDU functions and low level I/O
2  * Copyright (C) 2003, 2004, 2008, 2009, 2010,
3  *               2011 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 /* NOTE: This module is also used by other software, thus the use of
22    the macro USE_NPTH is mandatory.  For GnuPG this macro is
23    guaranteed to be defined true. */
24
25 #include <config.h>
26 #include <errno.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <assert.h>
31 #include <signal.h>
32 #ifdef USE_NPTH
33 # include <unistd.h>
34 # include <fcntl.h>
35 # include <npth.h>
36 #endif
37
38
39 /* If requested include the definitions for the remote APDU protocol
40    code. */
41 #ifdef USE_G10CODE_RAPDU
42 #include "rapdu.h"
43 #endif /*USE_G10CODE_RAPDU*/
44
45 #if defined(GNUPG_SCD_MAIN_HEADER)
46 #include GNUPG_SCD_MAIN_HEADER
47 #elif GNUPG_MAJOR_VERSION == 1
48 /* This is used with GnuPG version < 1.9.  The code has been source
49    copied from the current GnuPG >= 1.9  and is maintained over
50    there. */
51 #include "options.h"
52 #include "errors.h"
53 #include "memory.h"
54 #include "util.h"
55 #include "i18n.h"
56 #include "dynload.h"
57 #include "cardglue.h"
58 #else /* GNUPG_MAJOR_VERSION != 1 */
59 #include "scdaemon.h"
60 #include "exechelp.h"
61 #endif /* GNUPG_MAJOR_VERSION != 1 */
62
63 #include "iso7816.h"
64 #include "apdu.h"
65 #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       pcsc_vendor_specific_init (slot);
1512
1513       atrlen = DIM (reader_table[0].atr);
1514       readerlen = sizeof reader -1 ;
1515       err = pcsc_status (reader_table[slot].pcsc.card,
1516                          reader, &readerlen,
1517                          &card_state, &card_protocol,
1518                          reader_table[slot].atr, &atrlen);
1519       if (err)
1520         log_error ("pcsc_status failed: %s (0x%lx) %lu\n",
1521                    pcsc_error_string (err), err, readerlen);
1522       else
1523         {
1524           if (atrlen > DIM (reader_table[0].atr))
1525             log_bug ("ATR returned by pcsc_status is too large\n");
1526           reader_table[slot].atrlen = atrlen;
1527           /* If we got to here we know that a card is present
1528              and usable.  Remember this.  */
1529           reader_table[slot].last_status = (   APDU_CARD_USABLE
1530                                              | APDU_CARD_PRESENT
1531                                              | APDU_CARD_ACTIVE);
1532           reader_table[slot].is_t0 = !!(card_protocol & PCSC_PROTOCOL_T0);
1533         }
1534     }
1535
1536   dump_reader_status (slot);
1537   return pcsc_error_to_sw (err);
1538 }
1539 #endif /*!NEED_PCSC_WRAPPER*/
1540
1541
1542 /* Disconnect a PC/SC card.  Note that this succeeds even if the card
1543    is not connected.  */
1544 #ifndef NEED_PCSC_WRAPPER
1545 static int
1546 disconnect_pcsc_card (int slot)
1547 {
1548   long err;
1549
1550   assert (slot >= 0 && slot < MAX_READER);
1551
1552   if (!reader_table[slot].pcsc.card)
1553     return 0;
1554
1555   err = pcsc_disconnect (reader_table[slot].pcsc.card, PCSC_LEAVE_CARD);
1556   if (err)
1557     {
1558       log_error ("pcsc_disconnect failed: %s (0x%lx)\n",
1559                  pcsc_error_string (err), err);
1560       return SW_HOST_CARD_IO_ERROR;
1561     }
1562   reader_table[slot].pcsc.card = 0;
1563   return 0;
1564 }
1565 #endif /*!NEED_PCSC_WRAPPER*/
1566
1567
1568 #ifndef NEED_PCSC_WRAPPER
1569 static int
1570 reset_pcsc_reader_direct (int slot)
1571 {
1572   int sw;
1573
1574   sw = disconnect_pcsc_card (slot);
1575   if (!sw)
1576     sw = connect_pcsc_card (slot);
1577
1578   return sw;
1579 }
1580 #endif /*NEED_PCSC_WRAPPER*/
1581
1582
1583 #ifdef NEED_PCSC_WRAPPER
1584 static int
1585 reset_pcsc_reader_wrapped (int slot)
1586 {
1587   long err;
1588   reader_table_t slotp;
1589   size_t len;
1590   int i, n;
1591   unsigned char msgbuf[9];
1592   unsigned int dummy_status;
1593   int sw = SW_HOST_CARD_IO_ERROR;
1594
1595   slotp = reader_table + slot;
1596
1597   if (slotp->pcsc.req_fd == -1
1598       || slotp->pcsc.rsp_fd == -1
1599       || slotp->pcsc.pid == (pid_t)(-1) )
1600     {
1601       log_error ("pcsc_get_status: pcsc-wrapper not running\n");
1602       return sw;
1603     }
1604
1605   msgbuf[0] = 0x05; /* RESET command. */
1606   len = 0;
1607   msgbuf[1] = (len >> 24);
1608   msgbuf[2] = (len >> 16);
1609   msgbuf[3] = (len >>  8);
1610   msgbuf[4] = (len      );
1611   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
1612     {
1613       log_error ("error sending PC/SC RESET request: %s\n",
1614                  strerror (errno));
1615       goto command_failed;
1616     }
1617
1618   /* Read the response. */
1619   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1620     {
1621       log_error ("error receiving PC/SC RESET response: %s\n",
1622                  i? strerror (errno) : "premature EOF");
1623       goto command_failed;
1624     }
1625   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1626   if (msgbuf[0] != 0x81 || len < 4)
1627     {
1628       log_error ("invalid response header from PC/SC received\n");
1629       goto command_failed;
1630     }
1631   len -= 4; /* Already read the error code. */
1632   if (len > DIM (slotp->atr))
1633     {
1634       log_error ("PC/SC returned a too large ATR (len=%lx)\n",
1635                  (unsigned long)len);
1636       sw = SW_HOST_GENERAL_ERROR;
1637       goto command_failed;
1638     }
1639   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
1640                        | (msgbuf[7] << 8 ) | msgbuf[8]);
1641   if (err)
1642     {
1643       log_error ("PC/SC RESET failed: %s (0x%lx)\n",
1644                  pcsc_error_string (err), err);
1645       /* If the error code is no smart card, we should not considere
1646          this a major error and close the wrapper.  */
1647       sw = pcsc_error_to_sw (err);
1648       if (err == PCSC_E_NO_SMARTCARD)
1649         return sw;
1650       goto command_failed;
1651     }
1652
1653   /* The open function may return a zero for the ATR length to
1654      indicate that no card is present.  */
1655   n = len;
1656   if (n)
1657     {
1658       if ((i=readn (slotp->pcsc.rsp_fd, slotp->atr, n, &len)) || len != n)
1659         {
1660           log_error ("error receiving PC/SC RESET response: %s\n",
1661                      i? strerror (errno) : "premature EOF");
1662           goto command_failed;
1663         }
1664     }
1665   slotp->atrlen = len;
1666
1667   /* Read the status so that IS_T0 will be set. */
1668   pcsc_get_status (slot, &dummy_status);
1669
1670   return 0;
1671
1672  command_failed:
1673   close (slotp->pcsc.req_fd);
1674   close (slotp->pcsc.rsp_fd);
1675   slotp->pcsc.req_fd = -1;
1676   slotp->pcsc.rsp_fd = -1;
1677   if (slotp->pcsc.pid != -1)
1678     kill (slotp->pcsc.pid, SIGTERM);
1679   slotp->pcsc.pid = (pid_t)(-1);
1680   slotp->used = 0;
1681   return sw;
1682 }
1683 #endif /* !NEED_PCSC_WRAPPER */
1684
1685
1686 /* Send an PC/SC reset command and return a status word on error or 0
1687    on success. */
1688 static int
1689 reset_pcsc_reader (int slot)
1690 {
1691 #ifdef NEED_PCSC_WRAPPER
1692   return reset_pcsc_reader_wrapped (slot);
1693 #else
1694   return reset_pcsc_reader_direct (slot);
1695 #endif
1696 }
1697
1698
1699 /* Examine reader specific parameters and initialize.  This is mostly
1700    for pinpad input.  Called at opening the connection to the reader.  */
1701 static int
1702 pcsc_vendor_specific_init (int slot)
1703 {
1704   unsigned char buf[256];
1705   pcsc_dword_t len;
1706   int sw;
1707   int vendor = 0;
1708   int product = 0;
1709   pcsc_dword_t get_tlv_ioctl = (pcsc_dword_t)-1;
1710   unsigned char *p;
1711
1712   len = sizeof (buf);
1713   sw = control_pcsc (slot, CM_IOCTL_GET_FEATURE_REQUEST, NULL, 0, buf, &len);
1714   if (sw)
1715     {
1716       log_error ("pcsc_vendor_specific_init: GET_FEATURE_REQUEST failed: %d\n",
1717                  sw);
1718       return SW_NOT_SUPPORTED;
1719     }
1720   else
1721     {
1722       p = buf;
1723       while (p < buf + len)
1724         {
1725           unsigned char code = *p++;
1726           int l = *p++;
1727           unsigned int v = 0;
1728
1729           if (l == 1)
1730             v = p[0];
1731           else if (l == 2)
1732             v = ((p[0] << 8) | p[1]);
1733           else if (l == 4)
1734             v = ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
1735
1736           if (code == FEATURE_VERIFY_PIN_DIRECT)
1737             reader_table[slot].pcsc.verify_ioctl = v;
1738           else if (code == FEATURE_MODIFY_PIN_DIRECT)
1739             reader_table[slot].pcsc.modify_ioctl = v;
1740           else if (code == FEATURE_GET_TLV_PROPERTIES)
1741             get_tlv_ioctl = v;
1742
1743           if (DBG_CARD_IO)
1744             log_debug ("feature: code=%02X, len=%d, v=%02X\n", code, l, v);
1745
1746           p += l;
1747         }
1748     }
1749
1750   if (get_tlv_ioctl == (pcsc_dword_t)-1)
1751     {
1752       /*
1753        * For system which doesn't support GET_TLV_PROPERTIES,
1754        * we put some heuristics here.
1755        */
1756       if (reader_table[slot].rdrname)
1757         {
1758           if (strstr (reader_table[slot].rdrname, "SPRx32"))
1759             {
1760               reader_table[slot].is_spr532 = 1;
1761               reader_table[slot].pinpad_varlen_supported = 1;
1762             }
1763           else if (strstr (reader_table[slot].rdrname, "ST-2xxx")
1764                    || strstr (reader_table[slot].rdrname, "cyberJack")
1765                    || strstr (reader_table[slot].rdrname, "DIGIPASS")
1766                    || strstr (reader_table[slot].rdrname, "Gnuk")
1767                    || strstr (reader_table[slot].rdrname, "KAAN"))
1768             reader_table[slot].pinpad_varlen_supported = 1;
1769         }
1770
1771       return 0;
1772     }
1773
1774   len = sizeof (buf);
1775   sw = control_pcsc (slot, get_tlv_ioctl, NULL, 0, buf, &len);
1776   if (sw)
1777     {
1778       log_error ("pcsc_vendor_specific_init: GET_TLV_IOCTL failed: %d\n", sw);
1779       return SW_NOT_SUPPORTED;
1780     }
1781
1782   p = buf;
1783   while (p < buf + len)
1784     {
1785       unsigned char tag = *p++;
1786       int l = *p++;
1787       unsigned int v = 0;
1788
1789       /* Umm... here is little endian, while the encoding above is big.  */
1790       if (l == 1)
1791         v = p[0];
1792       else if (l == 2)
1793         v = ((p[1] << 8) | p[0]);
1794       else if (l == 4)
1795         v = ((p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]);
1796
1797       if (tag == PCSCv2_PART10_PROPERTY_bMinPINSize)
1798         reader_table[slot].pcsc.pinmin = v;
1799       else if (tag == PCSCv2_PART10_PROPERTY_bMaxPINSize)
1800         reader_table[slot].pcsc.pinmax = v;
1801       else if (tag == PCSCv2_PART10_PROPERTY_wIdVendor)
1802         vendor = v;
1803       else if (tag == PCSCv2_PART10_PROPERTY_wIdProduct)
1804         product = v;
1805
1806       if (DBG_CARD_IO)
1807         log_debug ("TLV properties: tag=%02X, len=%d, v=%08X\n", tag, l, v);
1808
1809       p += l;
1810     }
1811
1812   if (vendor == VENDOR_VEGA && product == VEGA_ALPHA)
1813     {
1814       /*
1815        * Please read the comment of ccid_vendor_specific_init in
1816        * ccid-driver.c.
1817        */
1818       const unsigned char cmd[] = { '\xb5', '\x01', '\x00', '\x03', '\x00' };
1819       sw = control_pcsc (slot, CM_IOCTL_VENDOR_IFD_EXCHANGE,
1820                          cmd, sizeof (cmd), NULL, 0);
1821       if (sw)
1822         return SW_NOT_SUPPORTED;
1823     }
1824   else if (vendor == VENDOR_SCM && product == SCM_SPR532) /* SCM SPR532 */
1825     {
1826       reader_table[slot].is_spr532 = 1;
1827       reader_table[slot].pinpad_varlen_supported = 1;
1828     }
1829   else if (vendor == 0x046a && product == 0x003e  /* Cherry ST-2xxx */
1830            || vendor == 0x0c4b /* Tested with Reiner cyberJack GO */
1831            || vendor == 0x1a44 /* Tested with Vasco DIGIPASS 920 */
1832            || vendor == 0x234b /* Tested with FSIJ Gnuk Token */
1833            || vendor == 0x0d46 /* Tested with KAAN Advanced??? */)
1834     reader_table[slot].pinpad_varlen_supported = 1;
1835
1836   return 0;
1837 }
1838
1839
1840 /* Open the PC/SC reader without using the wrapper.  Returns -1 on
1841    error or a slot number for the reader.  */
1842 #ifndef NEED_PCSC_WRAPPER
1843 static int
1844 open_pcsc_reader_direct (const char *portstr)
1845 {
1846   long err;
1847   int slot;
1848   char *list = NULL;
1849   pcsc_dword_t nreader, listlen;
1850   char *p;
1851
1852   slot = new_reader_slot ();
1853   if (slot == -1)
1854     return -1;
1855
1856   /* Fixme: Allocating a context for each slot is not required.  One
1857      global context should be sufficient.  */
1858   err = pcsc_establish_context (PCSC_SCOPE_SYSTEM, NULL, NULL,
1859                                 &reader_table[slot].pcsc.context);
1860   if (err)
1861     {
1862       log_error ("pcsc_establish_context failed: %s (0x%lx)\n",
1863                  pcsc_error_string (err), err);
1864       reader_table[slot].used = 0;
1865       return -1;
1866     }
1867
1868   err = pcsc_list_readers (reader_table[slot].pcsc.context,
1869                            NULL, NULL, &nreader);
1870   if (!err)
1871     {
1872       list = xtrymalloc (nreader+1); /* Better add 1 for safety reasons. */
1873       if (!list)
1874         {
1875           log_error ("error allocating memory for reader list\n");
1876           pcsc_release_context (reader_table[slot].pcsc.context);
1877           reader_table[slot].used = 0;
1878           return -1 /*SW_HOST_OUT_OF_CORE*/;
1879         }
1880       err = pcsc_list_readers (reader_table[slot].pcsc.context,
1881                                NULL, list, &nreader);
1882     }
1883   if (err)
1884     {
1885       log_error ("pcsc_list_readers failed: %s (0x%lx)\n",
1886                  pcsc_error_string (err), err);
1887       pcsc_release_context (reader_table[slot].pcsc.context);
1888       reader_table[slot].used = 0;
1889       xfree (list);
1890       return -1;
1891     }
1892
1893   listlen = nreader;
1894   p = list;
1895   while (nreader)
1896     {
1897       if (!*p && !p[1])
1898         break;
1899       if (*p)
1900         log_info ("detected reader '%s'\n", p);
1901       if (nreader < (strlen (p)+1))
1902         {
1903           log_error ("invalid response from pcsc_list_readers\n");
1904           break;
1905         }
1906       nreader -= strlen (p)+1;
1907       p += strlen (p) + 1;
1908     }
1909
1910   reader_table[slot].rdrname = xtrymalloc (strlen (portstr? portstr : list)+1);
1911   if (!reader_table[slot].rdrname)
1912     {
1913       log_error ("error allocating memory for reader name\n");
1914       pcsc_release_context (reader_table[slot].pcsc.context);
1915       reader_table[slot].used = 0;
1916       return -1;
1917     }
1918   strcpy (reader_table[slot].rdrname, portstr? portstr : list);
1919   xfree (list);
1920   list = NULL;
1921
1922   reader_table[slot].pcsc.card = 0;
1923   reader_table[slot].atrlen = 0;
1924   reader_table[slot].last_status = 0;
1925
1926   reader_table[slot].connect_card = connect_pcsc_card;
1927   reader_table[slot].disconnect_card = disconnect_pcsc_card;
1928   reader_table[slot].close_reader = close_pcsc_reader;
1929   reader_table[slot].reset_reader = reset_pcsc_reader;
1930   reader_table[slot].get_status_reader = pcsc_get_status;
1931   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
1932   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
1933
1934   dump_reader_status (slot);
1935   return slot;
1936 }
1937 #endif /*!NEED_PCSC_WRAPPER */
1938
1939
1940 /* Open the PC/SC reader using the pcsc_wrapper program.  This is
1941    needed to cope with different thread models and other peculiarities
1942    of libpcsclite. */
1943 #ifdef NEED_PCSC_WRAPPER
1944 static int
1945 open_pcsc_reader_wrapped (const char *portstr)
1946 {
1947   int slot;
1948   reader_table_t slotp;
1949   int fd, rp[2], wp[2];
1950   int n, i;
1951   pid_t pid;
1952   size_t len;
1953   unsigned char msgbuf[9];
1954   int err;
1955   unsigned int dummy_status;
1956
1957   /* Note that we use the constant and not the fucntion because this
1958      code won't be be used under Windows.  */
1959   const char *wrapperpgm = GNUPG_LIBEXECDIR "/gnupg-pcsc-wrapper";
1960
1961   if (access (wrapperpgm, X_OK))
1962     {
1963       log_error ("can't run PC/SC access module '%s': %s\n",
1964                  wrapperpgm, strerror (errno));
1965       return -1;
1966     }
1967
1968   slot = new_reader_slot ();
1969   if (slot == -1)
1970     return -1;
1971   slotp = reader_table + slot;
1972
1973   /* Fire up the PC/SCc wrapper.  We don't use any fork/exec code from
1974      the common directy but implement it directly so that this file
1975      may still be source copied. */
1976
1977   if (pipe (rp) == -1)
1978     {
1979       log_error ("error creating a pipe: %s\n", strerror (errno));
1980       slotp->used = 0;
1981       return -1;
1982     }
1983   if (pipe (wp) == -1)
1984     {
1985       log_error ("error creating a pipe: %s\n", strerror (errno));
1986       close (rp[0]);
1987       close (rp[1]);
1988       slotp->used = 0;
1989       return -1;
1990     }
1991
1992   pid = fork ();
1993   if (pid == -1)
1994     {
1995       log_error ("error forking process: %s\n", strerror (errno));
1996       close (rp[0]);
1997       close (rp[1]);
1998       close (wp[0]);
1999       close (wp[1]);
2000       slotp->used = 0;
2001       return -1;
2002     }
2003   slotp->pcsc.pid = pid;
2004
2005   if (!pid)
2006     { /*
2007          === Child ===
2008        */
2009
2010       /* Double fork. */
2011       pid = fork ();
2012       if (pid == -1)
2013         _exit (31);
2014       if (pid)
2015         _exit (0); /* Immediate exit this parent, so that the child
2016                       gets cleaned up by the init process. */
2017
2018       /* Connect our pipes. */
2019       if (wp[0] != 0 && dup2 (wp[0], 0) == -1)
2020         log_fatal ("dup2 stdin failed: %s\n", strerror (errno));
2021       if (rp[1] != 1 && dup2 (rp[1], 1) == -1)
2022         log_fatal ("dup2 stdout failed: %s\n", strerror (errno));
2023
2024       /* Send stderr to the bit bucket. */
2025       fd = open ("/dev/null", O_WRONLY);
2026       if (fd == -1)
2027         log_fatal ("can't open '/dev/null': %s", strerror (errno));
2028       if (fd != 2 && dup2 (fd, 2) == -1)
2029         log_fatal ("dup2 stderr failed: %s\n", strerror (errno));
2030
2031       /* Close all other files. */
2032       close_all_fds (3, NULL);
2033
2034       execl (wrapperpgm,
2035              "pcsc-wrapper",
2036              "--",
2037              "1", /* API version */
2038              opt.pcsc_driver, /* Name of the PC/SC library. */
2039               NULL);
2040       _exit (31);
2041     }
2042
2043   /*
2044      === Parent ===
2045    */
2046   close (wp[0]);
2047   close (rp[1]);
2048   slotp->pcsc.req_fd = wp[1];
2049   slotp->pcsc.rsp_fd = rp[0];
2050
2051   /* Wait for the intermediate child to terminate. */
2052 #ifdef USE_NPTH
2053 #define WAIT npth_waitpid
2054 #else
2055 #define WAIT waitpid
2056 #endif
2057   while ( (i=WAIT (pid, NULL, 0)) == -1 && errno == EINTR)
2058     ;
2059 #undef WAIT
2060
2061   /* Now send the open request. */
2062   msgbuf[0] = 0x01; /* OPEN command. */
2063   len = portstr? strlen (portstr):0;
2064   msgbuf[1] = (len >> 24);
2065   msgbuf[2] = (len >> 16);
2066   msgbuf[3] = (len >>  8);
2067   msgbuf[4] = (len      );
2068   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
2069        || (portstr && writen (slotp->pcsc.req_fd, portstr, len)))
2070     {
2071       log_error ("error sending PC/SC OPEN request: %s\n",
2072                  strerror (errno));
2073       goto command_failed;
2074     }
2075   /* Read the response. */
2076   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
2077     {
2078       log_error ("error receiving PC/SC OPEN response: %s\n",
2079                  i? strerror (errno) : "premature EOF");
2080       goto command_failed;
2081     }
2082   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
2083   if (msgbuf[0] != 0x81 || len < 4)
2084     {
2085       log_error ("invalid response header from PC/SC received\n");
2086       goto command_failed;
2087     }
2088   len -= 4; /* Already read the error code. */
2089   if (len > DIM (slotp->atr))
2090     {
2091       log_error ("PC/SC returned a too large ATR (len=%lx)\n",
2092                  (unsigned long)len);
2093       goto command_failed;
2094     }
2095   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
2096                        | (msgbuf[7] << 8 ) | msgbuf[8]);
2097
2098   if (err)
2099     {
2100       log_error ("PC/SC OPEN failed: %s\n", pcsc_error_string (err));
2101       goto command_failed;
2102     }
2103
2104   slotp->last_status = 0;
2105
2106   /* The open request may return a zero for the ATR length to
2107      indicate that no card is present.  */
2108   n = len;
2109   if (n)
2110     {
2111       if ((i=readn (slotp->pcsc.rsp_fd, slotp->atr, n, &len)) || len != n)
2112         {
2113           log_error ("error receiving PC/SC OPEN response: %s\n",
2114                      i? strerror (errno) : "premature EOF");
2115           goto command_failed;
2116         }
2117       /* If we got to here we know that a card is present
2118          and usable.  Thus remember this.  */
2119       slotp->last_status = (  APDU_CARD_USABLE
2120                             | APDU_CARD_PRESENT
2121                             | APDU_CARD_ACTIVE);
2122     }
2123   slotp->atrlen = len;
2124
2125   reader_table[slot].close_reader = close_pcsc_reader;
2126   reader_table[slot].reset_reader = reset_pcsc_reader;
2127   reader_table[slot].get_status_reader = pcsc_get_status;
2128   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
2129   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
2130
2131   pcsc_vendor_specific_init (slot);
2132
2133   /* Read the status so that IS_T0 will be set. */
2134   pcsc_get_status (slot, &dummy_status);
2135
2136   dump_reader_status (slot);
2137   return slot;
2138
2139  command_failed:
2140   close (slotp->pcsc.req_fd);
2141   close (slotp->pcsc.rsp_fd);
2142   slotp->pcsc.req_fd = -1;
2143   slotp->pcsc.rsp_fd = -1;
2144   if (slotp->pcsc.pid != -1)
2145     kill (slotp->pcsc.pid, SIGTERM);
2146   slotp->pcsc.pid = (pid_t)(-1);
2147   slotp->used = 0;
2148   /* There is no way to return SW. */
2149   return -1;
2150
2151 }
2152 #endif /*NEED_PCSC_WRAPPER*/
2153
2154
2155 static int
2156 open_pcsc_reader (const char *portstr)
2157 {
2158 #ifdef NEED_PCSC_WRAPPER
2159   return open_pcsc_reader_wrapped (portstr);
2160 #else
2161   return open_pcsc_reader_direct (portstr);
2162 #endif
2163 }
2164
2165
2166 /* Check whether the reader supports the ISO command code COMMAND
2167    on the pinpad.  Return 0 on success.  */
2168 static int
2169 check_pcsc_pinpad (int slot, int command, pininfo_t *pininfo)
2170 {
2171   int r;
2172
2173   pininfo->minlen = reader_table[slot].pcsc.pinmin;
2174   pininfo->maxlen = reader_table[slot].pcsc.pinmax;
2175
2176   if ((command == ISO7816_VERIFY && reader_table[slot].pcsc.verify_ioctl != 0)
2177       || (command == ISO7816_CHANGE_REFERENCE_DATA
2178           && reader_table[slot].pcsc.modify_ioctl != 0))
2179     r = 0;                       /* Success */
2180   else
2181     r = SW_NOT_SUPPORTED;
2182
2183   if (DBG_CARD_IO)
2184     log_debug ("check_pcsc_pinpad: command=%02X, r=%d\n",
2185                (unsigned int)command, r);
2186
2187   if (reader_table[slot].pinpad_varlen_supported)
2188     pininfo->fixedlen = 0;
2189
2190   return r;
2191 }
2192
2193 #define PIN_VERIFY_STRUCTURE_SIZE 24
2194 static int
2195 pcsc_pinpad_verify (int slot, int class, int ins, int p0, int p1,
2196                     pininfo_t *pininfo)
2197 {
2198   int sw;
2199   unsigned char *pin_verify;
2200   int len = PIN_VERIFY_STRUCTURE_SIZE + pininfo->fixedlen;
2201   unsigned char result[2];
2202   pcsc_dword_t resultlen = 2;
2203   int no_lc;
2204
2205   if (!reader_table[slot].atrlen
2206       && (sw = reset_pcsc_reader (slot)))
2207     return sw;
2208
2209   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2210     return SW_NOT_SUPPORTED;
2211
2212   if (!pininfo->minlen)
2213     pininfo->minlen = 1;
2214   if (!pininfo->maxlen)
2215     pininfo->maxlen = 15;
2216
2217   pin_verify = xtrymalloc (len);
2218   if (!pin_verify)
2219     return SW_HOST_OUT_OF_CORE;
2220
2221   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2222
2223   pin_verify[0] = 0x00; /* bTimeOut */
2224   pin_verify[1] = 0x00; /* bTimeOut2 */
2225   pin_verify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2226   pin_verify[3] = pininfo->fixedlen; /* bmPINBlockString */
2227   pin_verify[4] = 0x00; /* bmPINLengthFormat */
2228   pin_verify[5] = pininfo->maxlen; /* wPINMaxExtraDigit */
2229   pin_verify[6] = pininfo->minlen; /* wPINMaxExtraDigit */
2230   pin_verify[7] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2231   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2232     pin_verify[7] |= 0x01; /* Max size reached.  */
2233   pin_verify[8] = 0x01; /* bNumberMessage: One message */
2234   pin_verify[9] =  0x09; /* wLangId: 0x0409: US English */
2235   pin_verify[10] = 0x04; /* wLangId: 0x0409: US English */
2236   pin_verify[11] = 0x00; /* bMsgIndex */
2237   pin_verify[12] = 0x00; /* bTeoPrologue[0] */
2238   pin_verify[13] = 0x00; /* bTeoPrologue[1] */
2239   pin_verify[14] = pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2240   pin_verify[15] = pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2241   pin_verify[16] = 0x00; /* ulDataLength */
2242   pin_verify[17] = 0x00; /* ulDataLength */
2243   pin_verify[18] = 0x00; /* ulDataLength */
2244   pin_verify[19] = class; /* abData[0] */
2245   pin_verify[20] = ins; /* abData[1] */
2246   pin_verify[21] = p0; /* abData[2] */
2247   pin_verify[22] = p1; /* abData[3] */
2248   pin_verify[23] = pininfo->fixedlen; /* abData[4] */
2249   if (pininfo->fixedlen)
2250     memset (&pin_verify[24], 0xff, pininfo->fixedlen);
2251   else if (no_lc)
2252     len--;
2253
2254   if (DBG_CARD_IO)
2255     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2256                class, ins, p0, p1, len, pininfo->maxlen);
2257
2258   sw = control_pcsc (slot, reader_table[slot].pcsc.verify_ioctl,
2259                      pin_verify, len, result, &resultlen);
2260   xfree (pin_verify);
2261   if (sw || resultlen < 2)
2262     return sw? sw : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2263   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2264     {
2265       log_error ("control_pcsc failed: %d\n", sw);
2266       return sw? sw: SW_HOST_INCOMPLETE_CARD_RESPONSE;
2267     }
2268   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2269   if (DBG_CARD_IO)
2270     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2271   return sw;
2272 }
2273
2274
2275 #define PIN_MODIFY_STRUCTURE_SIZE 29
2276 static int
2277 pcsc_pinpad_modify (int slot, int class, int ins, int p0, int p1,
2278                     pininfo_t *pininfo)
2279 {
2280   int sw;
2281   unsigned char *pin_modify;
2282   int len = PIN_MODIFY_STRUCTURE_SIZE + 2 * pininfo->fixedlen;
2283   unsigned char result[2];
2284   pcsc_dword_t resultlen = 2;
2285   int no_lc;
2286
2287   if (!reader_table[slot].atrlen
2288       && (sw = reset_pcsc_reader (slot)))
2289     return sw;
2290
2291   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2292     return SW_NOT_SUPPORTED;
2293
2294   if (!pininfo->minlen)
2295     pininfo->minlen = 1;
2296   if (!pininfo->maxlen)
2297     pininfo->maxlen = 15;
2298
2299   /* Note that the 25 is the maximum value the SPR532 allows.  */
2300   if (pininfo->minlen < 1 || pininfo->minlen > 25
2301       || pininfo->maxlen < 1 || pininfo->maxlen > 25
2302       || pininfo->minlen > pininfo->maxlen)
2303     return SW_HOST_INV_VALUE;
2304
2305   pin_modify = xtrymalloc (len);
2306   if (!pin_modify)
2307     return SW_HOST_OUT_OF_CORE;
2308
2309   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2310
2311   pin_modify[0] = 0x00; /* bTimeOut */
2312   pin_modify[1] = 0x00; /* bTimeOut2 */
2313   pin_modify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2314   pin_modify[3] = pininfo->fixedlen; /* bmPINBlockString */
2315   pin_modify[4] = 0x00; /* bmPINLengthFormat */
2316   pin_modify[5] = 0x00; /* bInsertionOffsetOld */
2317   pin_modify[6] = pininfo->fixedlen; /* bInsertionOffsetNew */
2318   pin_modify[7] = pininfo->maxlen; /* wPINMaxExtraDigit */
2319   pin_modify[8] = pininfo->minlen; /* wPINMaxExtraDigit */
2320   pin_modify[9] = (p0 == 0 ? 0x03 : 0x01);
2321                   /* bConfirmPIN
2322                    *    0x00: new PIN once
2323                    *    0x01: new PIN twice (confirmation)
2324                    *    0x02: old PIN and new PIN once
2325                    *    0x03: old PIN and new PIN twice (confirmation)
2326                    */
2327   pin_modify[10] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2328   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2329     pin_modify[10] |= 0x01; /* Max size reached.  */
2330   pin_modify[11] = 0x03; /* bNumberMessage: Three messages */
2331   pin_modify[12] = 0x09; /* wLangId: 0x0409: US English */
2332   pin_modify[13] = 0x04; /* wLangId: 0x0409: US English */
2333   pin_modify[14] = 0x00; /* bMsgIndex1 */
2334   pin_modify[15] = 0x01; /* bMsgIndex2 */
2335   pin_modify[16] = 0x02; /* bMsgIndex3 */
2336   pin_modify[17] = 0x00; /* bTeoPrologue[0] */
2337   pin_modify[18] = 0x00; /* bTeoPrologue[1] */
2338   pin_modify[19] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2339   pin_modify[20] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2340   pin_modify[21] = 0x00; /* ulDataLength */
2341   pin_modify[22] = 0x00; /* ulDataLength */
2342   pin_modify[23] = 0x00; /* ulDataLength */
2343   pin_modify[24] = class; /* abData[0] */
2344   pin_modify[25] = ins; /* abData[1] */
2345   pin_modify[26] = p0; /* abData[2] */
2346   pin_modify[27] = p1; /* abData[3] */
2347   pin_modify[28] = 2 * pininfo->fixedlen; /* abData[4] */
2348   if (pininfo->fixedlen)
2349     memset (&pin_modify[29], 0xff, 2 * pininfo->fixedlen);
2350   else if (no_lc)
2351     len--;
2352
2353   if (DBG_CARD_IO)
2354     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2355                class, ins, p0, p1, len, (int)pininfo->maxlen);
2356
2357   sw = control_pcsc (slot, reader_table[slot].pcsc.modify_ioctl,
2358                      pin_modify, len, result, &resultlen);
2359   xfree (pin_modify);
2360   if (sw || resultlen < 2)
2361     {
2362       log_error ("control_pcsc failed: %d\n", sw);
2363       return sw? sw : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2364     }
2365   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2366   if (DBG_CARD_IO)
2367     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2368   return sw;
2369 }
2370 \f
2371 #ifdef HAVE_LIBUSB
2372 /*
2373      Internal CCID driver interface.
2374  */
2375
2376
2377 static void
2378 dump_ccid_reader_status (int slot)
2379 {
2380   log_info ("reader slot %d: using ccid driver\n", slot);
2381 }
2382
2383 static int
2384 close_ccid_reader (int slot)
2385 {
2386   ccid_close_reader (reader_table[slot].ccid.handle);
2387   reader_table[slot].used = 0;
2388   return 0;
2389 }
2390
2391
2392 static int
2393 shutdown_ccid_reader (int slot)
2394 {
2395   ccid_shutdown_reader (reader_table[slot].ccid.handle);
2396   return 0;
2397 }
2398
2399
2400 static int
2401 reset_ccid_reader (int slot)
2402 {
2403   int err;
2404   reader_table_t slotp = reader_table + slot;
2405   unsigned char atr[33];
2406   size_t atrlen;
2407
2408   err = ccid_get_atr (slotp->ccid.handle, atr, sizeof atr, &atrlen);
2409   if (err)
2410     return err;
2411   /* If the reset was successful, update the ATR. */
2412   assert (sizeof slotp->atr >= sizeof atr);
2413   slotp->atrlen = atrlen;
2414   memcpy (slotp->atr, atr, atrlen);
2415   dump_reader_status (slot);
2416   return 0;
2417 }
2418
2419
2420 static int
2421 set_progress_cb_ccid_reader (int slot, gcry_handler_progress_t cb, void *cb_arg)
2422 {
2423   reader_table_t slotp = reader_table + slot;
2424
2425   return ccid_set_progress_cb (slotp->ccid.handle, cb, cb_arg);
2426 }
2427
2428
2429 static int
2430 get_status_ccid (int slot, unsigned int *status)
2431 {
2432   int rc;
2433   int bits;
2434
2435   rc = ccid_slot_status (reader_table[slot].ccid.handle, &bits);
2436   if (rc)
2437     return rc;
2438
2439   if (bits == 0)
2440     *status = (APDU_CARD_USABLE|APDU_CARD_PRESENT|APDU_CARD_ACTIVE);
2441   else if (bits == 1)
2442     *status = APDU_CARD_PRESENT;
2443   else
2444     *status = 0;
2445
2446   return 0;
2447 }
2448
2449
2450 /* Actually send the APDU of length APDULEN to SLOT and return a
2451    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2452    set to BUFLEN.  Returns: Internal CCID driver error code. */
2453 static int
2454 send_apdu_ccid (int slot, unsigned char *apdu, size_t apdulen,
2455                 unsigned char *buffer, size_t *buflen,
2456                 pininfo_t *pininfo)
2457 {
2458   long err;
2459   size_t maxbuflen;
2460
2461   /* If we don't have an ATR, we need to reset the reader first. */
2462   if (!reader_table[slot].atrlen
2463       && (err = reset_ccid_reader (slot)))
2464     return err;
2465
2466   if (DBG_CARD_IO)
2467     log_printhex (" raw apdu:", apdu, apdulen);
2468
2469   maxbuflen = *buflen;
2470   if (pininfo)
2471     err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2472                                   apdu, apdulen, pininfo,
2473                                   buffer, maxbuflen, buflen);
2474   else
2475     err = ccid_transceive (reader_table[slot].ccid.handle,
2476                            apdu, apdulen,
2477                            buffer, maxbuflen, buflen);
2478   if (err)
2479     log_error ("ccid_transceive failed: (0x%lx)\n",
2480                err);
2481
2482   return err;
2483 }
2484
2485
2486 /* Check whether the CCID reader supports the ISO command code COMMAND
2487    on the pinpad.  Return 0 on success.  For a description of the pin
2488    parameters, see ccid-driver.c */
2489 static int
2490 check_ccid_pinpad (int slot, int command, pininfo_t *pininfo)
2491 {
2492   unsigned char apdu[] = { 0, 0, 0, 0x81 };
2493
2494   apdu[1] = command;
2495   return ccid_transceive_secure (reader_table[slot].ccid.handle, apdu,
2496                                  sizeof apdu, pininfo, NULL, 0, NULL);
2497 }
2498
2499
2500 static int
2501 ccid_pinpad_operation (int slot, int class, int ins, int p0, int p1,
2502                        pininfo_t *pininfo)
2503 {
2504   unsigned char apdu[4];
2505   int err, sw;
2506   unsigned char result[2];
2507   size_t resultlen = 2;
2508
2509   apdu[0] = class;
2510   apdu[1] = ins;
2511   apdu[2] = p0;
2512   apdu[3] = p1;
2513   err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2514                                 apdu, sizeof apdu, pininfo,
2515                                 result, 2, &resultlen);
2516   if (err)
2517     return err;
2518
2519   if (resultlen < 2)
2520     return SW_HOST_INCOMPLETE_CARD_RESPONSE;
2521
2522   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2523   return sw;
2524 }
2525
2526
2527 /* Open the reader and try to read an ATR.  */
2528 static int
2529 open_ccid_reader (const char *portstr)
2530 {
2531   int err;
2532   int slot;
2533   reader_table_t slotp;
2534
2535   slot = new_reader_slot ();
2536   if (slot == -1)
2537     return -1;
2538   slotp = reader_table + slot;
2539
2540   err = ccid_open_reader (&slotp->ccid.handle, portstr);
2541   if (err)
2542     {
2543       slotp->used = 0;
2544       return -1;
2545     }
2546
2547   err = ccid_get_atr (slotp->ccid.handle,
2548                       slotp->atr, sizeof slotp->atr, &slotp->atrlen);
2549   if (err)
2550     {
2551       slotp->atrlen = 0;
2552       err = 0;
2553     }
2554   else
2555     {
2556       /* If we got to here we know that a card is present
2557          and usable.  Thus remember this.  */
2558       reader_table[slot].last_status = (APDU_CARD_USABLE
2559                                         | APDU_CARD_PRESENT
2560                                         | APDU_CARD_ACTIVE);
2561     }
2562
2563   reader_table[slot].close_reader = close_ccid_reader;
2564   reader_table[slot].shutdown_reader = shutdown_ccid_reader;
2565   reader_table[slot].reset_reader = reset_ccid_reader;
2566   reader_table[slot].get_status_reader = get_status_ccid;
2567   reader_table[slot].send_apdu_reader = send_apdu_ccid;
2568   reader_table[slot].check_pinpad = check_ccid_pinpad;
2569   reader_table[slot].dump_status_reader = dump_ccid_reader_status;
2570   reader_table[slot].set_progress_cb = set_progress_cb_ccid_reader;
2571   reader_table[slot].pinpad_verify = ccid_pinpad_operation;
2572   reader_table[slot].pinpad_modify = ccid_pinpad_operation;
2573   /* Our CCID reader code does not support T=0 at all, thus reset the
2574      flag.  */
2575   reader_table[slot].is_t0 = 0;
2576
2577   dump_reader_status (slot);
2578   return slot;
2579 }
2580
2581
2582
2583 #endif /* HAVE_LIBUSB */
2584
2585
2586 \f
2587 #ifdef USE_G10CODE_RAPDU
2588 /*
2589      The Remote APDU Interface.
2590
2591      This uses the Remote APDU protocol to contact a reader.
2592
2593      The port number is actually an index into the list of ports as
2594      returned via the protocol.
2595  */
2596
2597
2598 static int
2599 rapdu_status_to_sw (int status)
2600 {
2601   int rc;
2602
2603   switch (status)
2604     {
2605     case RAPDU_STATUS_SUCCESS:  rc = 0; break;
2606
2607     case RAPDU_STATUS_INVCMD:
2608     case RAPDU_STATUS_INVPROT:
2609     case RAPDU_STATUS_INVSEQ:
2610     case RAPDU_STATUS_INVCOOKIE:
2611     case RAPDU_STATUS_INVREADER:  rc = SW_HOST_INV_VALUE;  break;
2612
2613     case RAPDU_STATUS_TIMEOUT:  rc = SW_HOST_CARD_IO_ERROR; break;
2614     case RAPDU_STATUS_CARDIO:   rc = SW_HOST_CARD_IO_ERROR; break;
2615     case RAPDU_STATUS_NOCARD:   rc = SW_HOST_NO_CARD; break;
2616     case RAPDU_STATUS_CARDCHG:  rc = SW_HOST_NO_CARD; break;
2617     case RAPDU_STATUS_BUSY:     rc = SW_HOST_BUSY; break;
2618     case RAPDU_STATUS_NEEDRESET: rc = SW_HOST_CARD_INACTIVE; break;
2619
2620     default: rc = SW_HOST_GENERAL_ERROR; break;
2621     }
2622
2623   return rc;
2624 }
2625
2626
2627
2628 static int
2629 close_rapdu_reader (int slot)
2630 {
2631   rapdu_release (reader_table[slot].rapdu.handle);
2632   reader_table[slot].used = 0;
2633   return 0;
2634 }
2635
2636
2637 static int
2638 reset_rapdu_reader (int slot)
2639 {
2640   int err;
2641   reader_table_t slotp;
2642   rapdu_msg_t msg = NULL;
2643
2644   slotp = reader_table + slot;
2645
2646   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2647   if (err)
2648     {
2649       log_error ("sending rapdu command RESET failed: %s\n",
2650                 err < 0 ? strerror (errno): rapdu_strerror (err));
2651       rapdu_msg_release (msg);
2652       return rapdu_status_to_sw (err);
2653     }
2654   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2655   if (err)
2656     {
2657       log_error ("receiving rapdu message failed: %s\n",
2658                 err < 0 ? strerror (errno): rapdu_strerror (err));
2659       rapdu_msg_release (msg);
2660       return rapdu_status_to_sw (err);
2661     }
2662   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2663     {
2664       int sw = rapdu_status_to_sw (msg->cmd);
2665       log_error ("rapdu command RESET failed: %s\n",
2666                  rapdu_strerror (msg->cmd));
2667       rapdu_msg_release (msg);
2668       return sw;
2669     }
2670   if (msg->datalen > DIM (slotp->atr))
2671     {
2672       log_error ("ATR returned by the RAPDU layer is too large\n");
2673       rapdu_msg_release (msg);
2674       return SW_HOST_INV_VALUE;
2675     }
2676   slotp->atrlen = msg->datalen;
2677   memcpy (slotp->atr, msg->data, msg->datalen);
2678
2679   rapdu_msg_release (msg);
2680   return 0;
2681 }
2682
2683
2684 static int
2685 my_rapdu_get_status (int slot, unsigned int *status)
2686 {
2687   int err;
2688   reader_table_t slotp;
2689   rapdu_msg_t msg = NULL;
2690   int oldslot;
2691
2692   slotp = reader_table + slot;
2693
2694   oldslot = rapdu_set_reader (slotp->rapdu.handle, slot);
2695   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_STATUS);
2696   rapdu_set_reader (slotp->rapdu.handle, oldslot);
2697   if (err)
2698     {
2699       log_error ("sending rapdu command GET_STATUS failed: %s\n",
2700                 err < 0 ? strerror (errno): rapdu_strerror (err));
2701       return rapdu_status_to_sw (err);
2702     }
2703   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2704   if (err)
2705     {
2706       log_error ("receiving rapdu message failed: %s\n",
2707                 err < 0 ? strerror (errno): rapdu_strerror (err));
2708       rapdu_msg_release (msg);
2709       return rapdu_status_to_sw (err);
2710     }
2711   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2712     {
2713       int sw = rapdu_status_to_sw (msg->cmd);
2714       log_error ("rapdu command GET_STATUS failed: %s\n",
2715                  rapdu_strerror (msg->cmd));
2716       rapdu_msg_release (msg);
2717       return sw;
2718     }
2719   *status = msg->data[0];
2720
2721   rapdu_msg_release (msg);
2722   return 0;
2723 }
2724
2725
2726 /* Actually send the APDU of length APDULEN to SLOT and return a
2727    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2728    set to BUFLEN.  Returns: APDU error code. */
2729 static int
2730 my_rapdu_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
2731                     unsigned char *buffer, size_t *buflen,
2732                     pininfo_t *pininfo)
2733 {
2734   int err;
2735   reader_table_t slotp;
2736   rapdu_msg_t msg = NULL;
2737   size_t maxlen = *buflen;
2738
2739   slotp = reader_table + slot;
2740
2741   *buflen = 0;
2742   if (DBG_CARD_IO)
2743     log_printhex ("  APDU_data:", apdu, apdulen);
2744
2745   if (apdulen < 4)
2746     {
2747       log_error ("rapdu_send_apdu: APDU is too short\n");
2748       return SW_HOST_INV_VALUE;
2749     }
2750
2751   err = rapdu_send_apdu (slotp->rapdu.handle, apdu, apdulen);
2752   if (err)
2753     {
2754       log_error ("sending rapdu command APDU failed: %s\n",
2755                 err < 0 ? strerror (errno): rapdu_strerror (err));
2756       rapdu_msg_release (msg);
2757       return rapdu_status_to_sw (err);
2758     }
2759   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2760   if (err)
2761     {
2762       log_error ("receiving rapdu message failed: %s\n",
2763                 err < 0 ? strerror (errno): rapdu_strerror (err));
2764       rapdu_msg_release (msg);
2765       return rapdu_status_to_sw (err);
2766     }
2767   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2768     {
2769       int sw = rapdu_status_to_sw (msg->cmd);
2770       log_error ("rapdu command APDU failed: %s\n",
2771                  rapdu_strerror (msg->cmd));
2772       rapdu_msg_release (msg);
2773       return sw;
2774     }
2775
2776   if (msg->datalen > maxlen)
2777     {
2778       log_error ("rapdu response apdu too large\n");
2779       rapdu_msg_release (msg);
2780       return SW_HOST_INV_VALUE;
2781     }
2782
2783   *buflen = msg->datalen;
2784   memcpy (buffer, msg->data, msg->datalen);
2785
2786   rapdu_msg_release (msg);
2787   return 0;
2788 }
2789
2790 static int
2791 open_rapdu_reader (int portno,
2792                    const unsigned char *cookie, size_t length,
2793                    int (*readfnc) (void *opaque,
2794                                    void *buffer, size_t size),
2795                    void *readfnc_value,
2796                    int (*writefnc) (void *opaque,
2797                                     const void *buffer, size_t size),
2798                    void *writefnc_value,
2799                    void (*closefnc) (void *opaque),
2800                    void *closefnc_value)
2801 {
2802   int err;
2803   int slot;
2804   reader_table_t slotp;
2805   rapdu_msg_t msg = NULL;
2806
2807   slot = new_reader_slot ();
2808   if (slot == -1)
2809     return -1;
2810   slotp = reader_table + slot;
2811
2812   slotp->rapdu.handle = rapdu_new ();
2813   if (!slotp->rapdu.handle)
2814     {
2815       slotp->used = 0;
2816       return -1;
2817     }
2818
2819   rapdu_set_reader (slotp->rapdu.handle, portno);
2820
2821   rapdu_set_iofunc (slotp->rapdu.handle,
2822                     readfnc, readfnc_value,
2823                     writefnc, writefnc_value,
2824                     closefnc, closefnc_value);
2825   rapdu_set_cookie (slotp->rapdu.handle, cookie, length);
2826
2827   /* First try to get the current ATR, but if the card is inactive
2828      issue a reset instead.  */
2829   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_ATR);
2830   if (err == RAPDU_STATUS_NEEDRESET)
2831     err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2832   if (err)
2833     {
2834       log_info ("sending rapdu command GET_ATR/RESET failed: %s\n",
2835                 err < 0 ? strerror (errno): rapdu_strerror (err));
2836       goto failure;
2837     }
2838   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2839   if (err)
2840     {
2841       log_info ("receiving rapdu message failed: %s\n",
2842                 err < 0 ? strerror (errno): rapdu_strerror (err));
2843       goto failure;
2844     }
2845   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2846     {
2847       log_info ("rapdu command GET ATR failed: %s\n",
2848                  rapdu_strerror (msg->cmd));
2849       goto failure;
2850     }
2851   if (msg->datalen > DIM (slotp->atr))
2852     {
2853       log_error ("ATR returned by the RAPDU layer is too large\n");
2854       goto failure;
2855     }
2856   slotp->atrlen = msg->datalen;
2857   memcpy (slotp->atr, msg->data, msg->datalen);
2858
2859   reader_table[slot].close_reader = close_rapdu_reader;
2860   reader_table[slot].reset_reader = reset_rapdu_reader;
2861   reader_table[slot].get_status_reader = my_rapdu_get_status;
2862   reader_table[slot].send_apdu_reader = my_rapdu_send_apdu;
2863   reader_table[slot].check_pinpad = NULL;
2864   reader_table[slot].dump_status_reader = NULL;
2865   reader_table[slot].pinpad_verify = NULL;
2866   reader_table[slot].pinpad_modify = NULL;
2867
2868   dump_reader_status (slot);
2869   rapdu_msg_release (msg);
2870   return slot;
2871
2872  failure:
2873   rapdu_msg_release (msg);
2874   rapdu_release (slotp->rapdu.handle);
2875   slotp->used = 0;
2876   return -1;
2877 }
2878
2879 #endif /*USE_G10CODE_RAPDU*/
2880
2881
2882 \f
2883 /*
2884        Driver Access
2885  */
2886
2887
2888 static int
2889 lock_slot (int slot)
2890 {
2891 #ifdef USE_NPTH
2892   int err;
2893
2894   err = npth_mutex_lock (&reader_table[slot].lock);
2895   if (err)
2896     {
2897       log_error ("failed to acquire apdu lock: %s\n", strerror (err));
2898       return SW_HOST_LOCKING_FAILED;
2899     }
2900 #endif /*USE_NPTH*/
2901   return 0;
2902 }
2903
2904 static int
2905 trylock_slot (int slot)
2906 {
2907 #ifdef USE_NPTH
2908   int err;
2909
2910   err = npth_mutex_trylock (&reader_table[slot].lock);
2911   if (err == EBUSY)
2912     return SW_HOST_BUSY;
2913   else if (err)
2914     {
2915       log_error ("failed to acquire apdu lock: %s\n", strerror (err));
2916       return SW_HOST_LOCKING_FAILED;
2917     }
2918 #endif /*USE_NPTH*/
2919   return 0;
2920 }
2921
2922 static void
2923 unlock_slot (int slot)
2924 {
2925 #ifdef USE_NPTH
2926   int err;
2927
2928   err = npth_mutex_unlock (&reader_table[slot].lock);
2929   if (err)
2930     log_error ("failed to release apdu lock: %s\n", strerror (errno));
2931 #endif /*USE_NPTH*/
2932 }
2933
2934
2935 /* Open the reader and return an internal slot number or -1 on
2936    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
2937    the first USB reader.  For PC/SC the first listed reader). */
2938 int
2939 apdu_open_reader (const char *portstr)
2940 {
2941   static int pcsc_api_loaded, ct_api_loaded;
2942   int slot;
2943
2944   if (DBG_READER)
2945     log_debug ("enter: apdu_open_reader: portstr=%s\n", portstr);
2946
2947 #ifdef HAVE_LIBUSB
2948   if (!opt.disable_ccid)
2949     {
2950       static int once_available;
2951       int i;
2952       const char *s;
2953
2954       slot = open_ccid_reader (portstr);
2955       if (slot != -1)
2956         {
2957           once_available = 1;
2958           if (DBG_READER)
2959             log_debug ("leave: apdu_open_reader => slot=%d [ccid]\n", slot);
2960           return slot; /* got one */
2961         }
2962
2963       /* If we ever loaded successfully loaded a CCID reader we never
2964          want to fallback to another driver.  This solves a problem
2965          where ccid was used, the card unplugged and then scdaemon
2966          tries to find a new reader and will eventually try PC/SC over
2967          and over again.  To reset this flag "gpgconf --kill scdaemon"
2968          can be used.  */
2969       if (once_available)
2970         {
2971           if (DBG_READER)
2972             log_debug ("leave: apdu_open_reader => slot=-1 (once_avail)\n");
2973           return -1;
2974         }
2975
2976       /* If a CCID reader specification has been given, the user does
2977          not want a fallback to other drivers. */
2978       if (portstr)
2979         for (s=portstr, i=0; *s; s++)
2980           if (*s == ':' && (++i == 3))
2981             {
2982               if (DBG_READER)
2983                 log_debug ("leave: apdu_open_reader => slot=-1 (no ccid)\n");
2984               return -1;
2985             }
2986     }
2987
2988 #endif /* HAVE_LIBUSB */
2989
2990   if (opt.ctapi_driver && *opt.ctapi_driver)
2991     {
2992       int port = portstr? atoi (portstr) : 32768;
2993
2994       if (!ct_api_loaded)
2995         {
2996           void *handle;
2997
2998           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
2999           if (!handle)
3000             {
3001               log_error ("apdu_open_reader: failed to open driver: %s\n",
3002                          dlerror ());
3003               return -1;
3004             }
3005           CT_init = dlsym (handle, "CT_init");
3006           CT_data = dlsym (handle, "CT_data");
3007           CT_close = dlsym (handle, "CT_close");
3008           if (!CT_init || !CT_data || !CT_close)
3009             {
3010               log_error ("apdu_open_reader: invalid CT-API driver\n");
3011               dlclose (handle);
3012               return -1;
3013             }
3014           ct_api_loaded = 1;
3015         }
3016       return open_ct_reader (port);
3017     }
3018
3019
3020   /* No ctAPI configured, so lets try the PC/SC API */
3021   if (!pcsc_api_loaded)
3022     {
3023 #ifndef NEED_PCSC_WRAPPER
3024       void *handle;
3025
3026       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
3027       if (!handle)
3028         {
3029           log_error ("apdu_open_reader: failed to open driver '%s': %s\n",
3030                      opt.pcsc_driver, dlerror ());
3031           return -1;
3032         }
3033
3034       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
3035       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
3036       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
3037 #if defined(_WIN32) || defined(__CYGWIN__)
3038       if (!pcsc_list_readers)
3039         pcsc_list_readers    = dlsym (handle, "SCardListReadersA");
3040 #endif
3041       pcsc_get_status_change = dlsym (handle, "SCardGetStatusChange");
3042 #if defined(_WIN32) || defined(__CYGWIN__)
3043       if (!pcsc_get_status_change)
3044         pcsc_get_status_change = dlsym (handle, "SCardGetStatusChangeA");
3045 #endif
3046       pcsc_connect           = dlsym (handle, "SCardConnect");
3047 #if defined(_WIN32) || defined(__CYGWIN__)
3048       if (!pcsc_connect)
3049         pcsc_connect         = dlsym (handle, "SCardConnectA");
3050 #endif
3051       pcsc_reconnect         = dlsym (handle, "SCardReconnect");
3052 #if defined(_WIN32) || defined(__CYGWIN__)
3053       if (!pcsc_reconnect)
3054         pcsc_reconnect       = dlsym (handle, "SCardReconnectA");
3055 #endif
3056       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
3057       pcsc_status            = dlsym (handle, "SCardStatus");
3058 #if defined(_WIN32) || defined(__CYGWIN__)
3059       if (!pcsc_status)
3060         pcsc_status          = dlsym (handle, "SCardStatusA");
3061 #endif
3062       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
3063       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
3064       pcsc_transmit          = dlsym (handle, "SCardTransmit");
3065       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
3066       pcsc_control           = dlsym (handle, "SCardControl");
3067
3068       if (!pcsc_establish_context
3069           || !pcsc_release_context
3070           || !pcsc_list_readers
3071           || !pcsc_get_status_change
3072           || !pcsc_connect
3073           || !pcsc_reconnect
3074           || !pcsc_disconnect
3075           || !pcsc_status
3076           || !pcsc_begin_transaction
3077           || !pcsc_end_transaction
3078           || !pcsc_transmit
3079           || !pcsc_control
3080           /* || !pcsc_set_timeout */)
3081         {
3082           /* Note that set_timeout is currently not used and also not
3083              available under Windows. */
3084           log_error ("apdu_open_reader: invalid PC/SC driver "
3085                      "(%d%d%d%d%d%d%d%d%d%d%d%d%d)\n",
3086                      !!pcsc_establish_context,
3087                      !!pcsc_release_context,
3088                      !!pcsc_list_readers,
3089                      !!pcsc_get_status_change,
3090                      !!pcsc_connect,
3091                      !!pcsc_reconnect,
3092                      !!pcsc_disconnect,
3093                      !!pcsc_status,
3094                      !!pcsc_begin_transaction,
3095                      !!pcsc_end_transaction,
3096                      !!pcsc_transmit,
3097                      !!pcsc_set_timeout,
3098                      !!pcsc_control );
3099           dlclose (handle);
3100           return -1;
3101         }
3102 #endif /*!NEED_PCSC_WRAPPER*/
3103       pcsc_api_loaded = 1;
3104     }
3105
3106   slot = open_pcsc_reader (portstr);
3107
3108   if (DBG_READER)
3109     log_debug ("leave: apdu_open_reader => slot=%d [pc/sc]\n", slot);
3110   return slot;
3111 }
3112
3113
3114 /* Open an remote reader and return an internal slot number or -1 on
3115    error. This function is an alternative to apdu_open_reader and used
3116    with remote readers only.  Note that the supplied CLOSEFNC will
3117    only be called once and the slot will not be valid afther this.
3118
3119    If PORTSTR is NULL we default to the first availabe port.
3120 */
3121 int
3122 apdu_open_remote_reader (const char *portstr,
3123                          const unsigned char *cookie, size_t length,
3124                          int (*readfnc) (void *opaque,
3125                                          void *buffer, size_t size),
3126                          void *readfnc_value,
3127                          int (*writefnc) (void *opaque,
3128                                           const void *buffer, size_t size),
3129                          void *writefnc_value,
3130                          void (*closefnc) (void *opaque),
3131                          void *closefnc_value)
3132 {
3133 #ifdef USE_G10CODE_RAPDU
3134   return open_rapdu_reader (portstr? atoi (portstr) : 0,
3135                             cookie, length,
3136                             readfnc, readfnc_value,
3137                             writefnc, writefnc_value,
3138                             closefnc, closefnc_value);
3139 #else
3140   (void)portstr;
3141   (void)cookie;
3142   (void)length;
3143   (void)readfnc;
3144   (void)readfnc_value;
3145   (void)writefnc;
3146   (void)writefnc_value;
3147   (void)closefnc;
3148   (void)closefnc_value;
3149 #ifdef _WIN32
3150   errno = ENOENT;
3151 #else
3152   errno = ENOSYS;
3153 #endif
3154   return -1;
3155 #endif
3156 }
3157
3158
3159 int
3160 apdu_close_reader (int slot)
3161 {
3162   int sw;
3163
3164   if (DBG_READER)
3165     log_debug ("enter: apdu_close_reader: slot=%d\n", slot);
3166
3167   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3168     {
3169       if (DBG_READER)
3170         log_debug ("leave: apdu_close_reader => SW_HOST_NO_DRIVER\n");
3171       return SW_HOST_NO_DRIVER;
3172     }
3173   sw = apdu_disconnect (slot);
3174   if (sw)
3175     {
3176       if (DBG_READER)
3177         log_debug ("leave: apdu_close_reader => 0x%x (apdu_disconnect)\n", sw);
3178       return sw;
3179     }
3180   if (reader_table[slot].close_reader)
3181     {
3182       sw = reader_table[slot].close_reader (slot);
3183       if (DBG_READER)
3184         log_debug ("leave: apdu_close_reader => 0x%x (close_reader)\n", sw);
3185       return sw;
3186     }
3187   if (DBG_READER)
3188     log_debug ("leave: apdu_close_reader => SW_HOST_NOT_SUPPORTED\n");
3189   return SW_HOST_NOT_SUPPORTED;
3190 }
3191
3192
3193 /* Function suitable for a cleanup function to close all reader.  It
3194    should not be used if the reader will be opened again.  The reason
3195    for implementing this to properly close USB devices so that they
3196    will startup the next time without error. */
3197 void
3198 apdu_prepare_exit (void)
3199 {
3200   static int sentinel;
3201   int slot;
3202
3203   if (!sentinel)
3204     {
3205       sentinel = 1;
3206       for (slot = 0; slot < MAX_READER; slot++)
3207         if (reader_table[slot].used)
3208           {
3209             apdu_disconnect (slot);
3210             if (reader_table[slot].close_reader)
3211               reader_table[slot].close_reader (slot);
3212             reader_table[slot].used = 0;
3213           }
3214       sentinel = 0;
3215     }
3216 }
3217
3218
3219 /* Shutdown a reader; that is basically the same as a close but keeps
3220    the handle ready for later use. A apdu_reset_reader or apdu_connect
3221    should be used to get it active again. */
3222 int
3223 apdu_shutdown_reader (int slot)
3224 {
3225   int sw;
3226
3227   if (DBG_READER)
3228     log_debug ("enter: apdu_shutdown_reader: slot=%d\n", slot);
3229
3230   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3231     {
3232       if (DBG_READER)
3233         log_debug ("leave: apdu_shutdown_reader => SW_HOST_NO_DRIVER\n");
3234       return SW_HOST_NO_DRIVER;
3235     }
3236   sw = apdu_disconnect (slot);
3237   if (sw)
3238     {
3239       if (DBG_READER)
3240         log_debug ("leave: apdu_shutdown_reader => 0x%x (apdu_disconnect)\n",
3241                    sw);
3242       return sw;
3243     }
3244   if (reader_table[slot].shutdown_reader)
3245     {
3246       sw = reader_table[slot].shutdown_reader (slot);
3247       if (DBG_READER)
3248         log_debug ("leave: apdu_shutdown_reader => 0x%x (close_reader)\n", sw);
3249       return sw;
3250     }
3251   if (DBG_READER)
3252     log_debug ("leave: apdu_shutdown_reader => SW_HOST_NOT_SUPPORTED\n");
3253   return SW_HOST_NOT_SUPPORTED;
3254 }
3255
3256 /* Enumerate all readers and return information on whether this reader
3257    is in use.  The caller should start with SLOT set to 0 and
3258    increment it with each call until an error is returned. */
3259 int
3260 apdu_enum_reader (int slot, int *used)
3261 {
3262   if (slot < 0 || slot >= MAX_READER)
3263     return SW_HOST_NO_DRIVER;
3264   *used = reader_table[slot].used;
3265   return 0;
3266 }
3267
3268
3269 /* Connect a card.  This is used to power up the card and make sure
3270    that an ATR is available.  Depending on the reader backend it may
3271    return an error for an inactive card or if no card is
3272    available.  */
3273 int
3274 apdu_connect (int slot)
3275 {
3276   int sw;
3277   unsigned int status;
3278
3279   if (DBG_READER)
3280     log_debug ("enter: apdu_connect: slot=%d\n", slot);
3281
3282   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3283     {
3284       if (DBG_READER)
3285         log_debug ("leave: apdu_connect => SW_HOST_NO_DRIVER\n");
3286       return SW_HOST_NO_DRIVER;
3287     }
3288
3289   /* Only if the access method provides a connect function we use it.
3290      If not, we expect that the card has been implicitly connected by
3291      apdu_open_reader.  */
3292   if (reader_table[slot].connect_card)
3293     {
3294       sw = lock_slot (slot);
3295       if (!sw)
3296         {
3297           sw = reader_table[slot].connect_card (slot);
3298           unlock_slot (slot);
3299         }
3300     }
3301   else
3302     sw = 0;
3303
3304   /* We need to call apdu_get_status_internal, so that the last-status
3305      machinery gets setup properly even if a card is inserted while
3306      scdaemon is fired up and apdu_get_status has not yet been called.
3307      Without that we would force a reset of the card with the next
3308      call to apdu_get_status.  */
3309   apdu_get_status_internal (slot, 1, 1, &status, NULL);
3310   if (sw)
3311     ;
3312   else if (!(status & APDU_CARD_PRESENT))
3313     sw = SW_HOST_NO_CARD;
3314   else if ((status & APDU_CARD_PRESENT) && !(status & APDU_CARD_ACTIVE))
3315     sw = SW_HOST_CARD_INACTIVE;
3316
3317   if (DBG_READER)
3318     log_debug ("leave: apdu_connect => sw=0x%x\n", sw);
3319
3320   return sw;
3321 }
3322
3323
3324 int
3325 apdu_disconnect (int slot)
3326 {
3327   int sw;
3328
3329   if (DBG_READER)
3330     log_debug ("enter: apdu_disconnect: slot=%d\n", slot);
3331
3332   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3333     {
3334       if (DBG_READER)
3335         log_debug ("leave: apdu_disconnect => SW_HOST_NO_DRIVER\n");
3336       return SW_HOST_NO_DRIVER;
3337     }
3338
3339   if (reader_table[slot].disconnect_card)
3340     {
3341       sw = lock_slot (slot);
3342       if (!sw)
3343         {
3344           sw = reader_table[slot].disconnect_card (slot);
3345           unlock_slot (slot);
3346         }
3347     }
3348   else
3349     sw = 0;
3350
3351   if (DBG_READER)
3352     log_debug ("leave: apdu_disconnect => sw=0x%x\n", sw);
3353   return sw;
3354 }
3355
3356
3357 /* Set the progress callback of SLOT to CB and its args to CB_ARG.  If
3358    CB is NULL the progress callback is removed.  */
3359 int
3360 apdu_set_progress_cb (int slot, gcry_handler_progress_t cb, void *cb_arg)
3361 {
3362   int sw;
3363
3364   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3365     return SW_HOST_NO_DRIVER;
3366
3367   if (reader_table[slot].set_progress_cb)
3368     {
3369       sw = lock_slot (slot);
3370       if (!sw)
3371         {
3372           sw = reader_table[slot].set_progress_cb (slot, cb, cb_arg);
3373           unlock_slot (slot);
3374         }
3375     }
3376   else
3377     sw = 0;
3378   return sw;
3379 }
3380
3381
3382 /* Do a reset for the card in reader at SLOT. */
3383 int
3384 apdu_reset (int slot)
3385 {
3386   int sw;
3387
3388   if (DBG_READER)
3389     log_debug ("enter: apdu_reset: slot=%d\n", slot);
3390
3391   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3392     {
3393       if (DBG_READER)
3394         log_debug ("leave: apdu_reset => SW_HOST_NO_DRIVER\n");
3395       return SW_HOST_NO_DRIVER;
3396     }
3397
3398   if ((sw = lock_slot (slot)))
3399     {
3400       if (DBG_READER)
3401         log_debug ("leave: apdu_reset => sw=0x%x (lock_slot)\n", sw);
3402       return sw;
3403     }
3404
3405   reader_table[slot].last_status = 0;
3406   if (reader_table[slot].reset_reader)
3407     sw = reader_table[slot].reset_reader (slot);
3408
3409   if (!sw)
3410     {
3411       /* If we got to here we know that a card is present
3412          and usable.  Thus remember this.  */
3413       reader_table[slot].last_status = (APDU_CARD_USABLE
3414                                         | APDU_CARD_PRESENT
3415                                         | APDU_CARD_ACTIVE);
3416     }
3417
3418   unlock_slot (slot);
3419   if (DBG_READER)
3420     log_debug ("leave: apdu_reset => sw=0x%x\n", sw);
3421   return sw;
3422 }
3423
3424
3425 /* Return the ATR or NULL if none is available.  On success the length
3426    of the ATR is stored at ATRLEN.  The caller must free the returned
3427    value.  */
3428 unsigned char *
3429 apdu_get_atr (int slot, size_t *atrlen)
3430 {
3431   unsigned char *buf;
3432
3433   if (DBG_READER)
3434     log_debug ("enter: apdu_get_atr: slot=%d\n", slot);
3435
3436   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3437     {
3438       if (DBG_READER)
3439         log_debug ("leave: apdu_get_atr => NULL (bad slot)\n");
3440       return NULL;
3441     }
3442   if (!reader_table[slot].atrlen)
3443     {
3444       if (DBG_READER)
3445         log_debug ("leave: apdu_get_atr => NULL (no ATR)\n");
3446       return NULL;
3447     }
3448
3449   buf = xtrymalloc (reader_table[slot].atrlen);
3450   if (!buf)
3451     {
3452       if (DBG_READER)
3453         log_debug ("leave: apdu_get_atr => NULL (out of core)\n");
3454       return NULL;
3455     }
3456   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
3457   *atrlen = reader_table[slot].atrlen;
3458   if (DBG_READER)
3459     log_debug ("leave: apdu_get_atr => atrlen=%zu\n", *atrlen);
3460   return buf;
3461 }
3462
3463
3464
3465 /* Retrieve the status for SLOT. The function does only wait for the
3466    card to become available if HANG is set to true. On success the
3467    bits in STATUS will be set to
3468
3469      APDU_CARD_USABLE  (bit 0) = card present and usable
3470      APDU_CARD_PRESENT (bit 1) = card present
3471      APDU_CARD_ACTIVE  (bit 2) = card active
3472                        (bit 3) = card access locked [not yet implemented]
3473
3474    For must applications, testing bit 0 is sufficient.
3475
3476    CHANGED will receive the value of the counter tracking the number
3477    of card insertions.  This value may be used to detect a card
3478    change.
3479 */
3480 static int
3481 apdu_get_status_internal (int slot, int hang, int no_atr_reset,
3482                           unsigned int *status, unsigned int *changed)
3483 {
3484   int sw;
3485   unsigned int s;
3486
3487   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3488     return SW_HOST_NO_DRIVER;
3489
3490   if ((sw = hang? lock_slot (slot) : trylock_slot (slot)))
3491     return sw;
3492
3493   if (reader_table[slot].get_status_reader)
3494     sw = reader_table[slot].get_status_reader (slot, &s);
3495
3496   unlock_slot (slot);
3497
3498   if (sw)
3499     {
3500       reader_table[slot].last_status = 0;
3501       return sw;
3502     }
3503
3504   /* Keep track of changes.  */
3505   if (s != reader_table[slot].last_status
3506       || !reader_table[slot].any_status )
3507     {
3508       reader_table[slot].change_counter++;
3509       /* Make sure that the ATR is invalid so that a reset will be
3510          triggered by apdu_activate.  */
3511       if (!no_atr_reset)
3512         reader_table[slot].atrlen = 0;
3513     }
3514   reader_table[slot].any_status = 1;
3515   reader_table[slot].last_status = s;
3516
3517   if (status)
3518     *status = s;
3519   if (changed)
3520     *changed = reader_table[slot].change_counter;
3521   return 0;
3522 }
3523
3524
3525 /* See above for a description.  */
3526 int
3527 apdu_get_status (int slot, int hang,
3528                  unsigned int *status, unsigned int *changed)
3529 {
3530   int sw;
3531
3532   if (DBG_READER)
3533     log_debug ("enter: apdu_get_status: slot=%d hang=%d\n", slot, hang);
3534   sw = apdu_get_status_internal (slot, hang, 0, status, changed);
3535   if (DBG_READER)
3536     {
3537       if (status && changed)
3538         log_debug ("leave: apdu_get_status => sw=0x%x status=%u changecnt=%u\n",
3539                    sw, *status, *changed);
3540       else if (status)
3541         log_debug ("leave: apdu_get_status => sw=0x%x status=%u\n",
3542                    sw, *status);
3543       else if (changed)
3544         log_debug ("leave: apdu_get_status => sw=0x%x changed=%u\n",
3545                    sw, *changed);
3546       else
3547         log_debug ("leave: apdu_get_status => sw=0x%x\n", sw);
3548     }
3549   return sw;
3550 }
3551
3552
3553 /* Check whether the reader supports the ISO command code COMMAND on
3554    the pinpad.  Return 0 on success.  For a description of the pin
3555    parameters, see ccid-driver.c */
3556 int
3557 apdu_check_pinpad (int slot, int command, pininfo_t *pininfo)
3558 {
3559   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3560     return SW_HOST_NO_DRIVER;
3561
3562   if (opt.enable_pinpad_varlen)
3563     pininfo->fixedlen = 0;
3564
3565   if (reader_table[slot].check_pinpad)
3566     {
3567       int sw;
3568
3569       if ((sw = lock_slot (slot)))
3570         return sw;
3571
3572       sw = reader_table[slot].check_pinpad (slot, command, pininfo);
3573       unlock_slot (slot);
3574       return sw;
3575     }
3576   else
3577     return SW_HOST_NOT_SUPPORTED;
3578 }
3579
3580
3581 int
3582 apdu_pinpad_verify (int slot, int class, int ins, int p0, int p1,
3583                     pininfo_t *pininfo)
3584 {
3585   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3586     return SW_HOST_NO_DRIVER;
3587
3588   if (reader_table[slot].pinpad_verify)
3589     {
3590       int sw;
3591
3592       if ((sw = lock_slot (slot)))
3593         return sw;
3594
3595       sw = reader_table[slot].pinpad_verify (slot, class, ins, p0, p1,
3596                                              pininfo);
3597       unlock_slot (slot);
3598       return sw;
3599     }
3600   else
3601     return SW_HOST_NOT_SUPPORTED;
3602 }
3603
3604
3605 int
3606 apdu_pinpad_modify (int slot, int class, int ins, int p0, int p1,
3607                     pininfo_t *pininfo)
3608 {
3609   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3610     return SW_HOST_NO_DRIVER;
3611
3612   if (reader_table[slot].pinpad_modify)
3613     {
3614       int sw;
3615
3616       if ((sw = lock_slot (slot)))
3617         return sw;
3618
3619       sw = reader_table[slot].pinpad_modify (slot, class, ins, p0, p1,
3620                                              pininfo);
3621       unlock_slot (slot);
3622       return sw;
3623     }
3624   else
3625     return SW_HOST_NOT_SUPPORTED;
3626 }
3627
3628
3629 /* Dispatcher for the actual send_apdu function. Note, that this
3630    function should be called in locked state. */
3631 static int
3632 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
3633            unsigned char *buffer, size_t *buflen, pininfo_t *pininfo)
3634 {
3635   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3636     return SW_HOST_NO_DRIVER;
3637
3638   if (reader_table[slot].send_apdu_reader)
3639     return reader_table[slot].send_apdu_reader (slot,
3640                                                 apdu, apdulen,
3641                                                 buffer, buflen,
3642                                                 pininfo);
3643   else
3644     return SW_HOST_NOT_SUPPORTED;
3645 }
3646
3647
3648 /* Core APDU tranceiver function. Parameters are described at
3649    apdu_send_le with the exception of PININFO which indicates pinpad
3650    related operations if not NULL.  If EXTENDED_MODE is not 0
3651    command chaining or extended length will be used according to these
3652    values:
3653        n < 0 := Use command chaining with the data part limited to -n
3654                 in each chunk.  If -1 is used a default value is used.
3655       n == 0 := No extended mode or command chaining.
3656       n == 1 := Use extended length for input and output without a
3657                 length limit.
3658        n > 1 := Use extended length with up to N bytes.
3659
3660 */
3661 static int
3662 send_le (int slot, int class, int ins, int p0, int p1,
3663          int lc, const char *data, int le,
3664          unsigned char **retbuf, size_t *retbuflen,
3665          pininfo_t *pininfo, int extended_mode)
3666 {
3667 #define SHORT_RESULT_BUFFER_SIZE 258
3668   /* We allocate 8 extra bytes as a safety margin towards a driver bug.  */
3669   unsigned char short_result_buffer[SHORT_RESULT_BUFFER_SIZE+10];
3670   unsigned char *result_buffer = NULL;
3671   size_t result_buffer_size;
3672   unsigned char *result;
3673   size_t resultlen;
3674   unsigned char short_apdu_buffer[5+256+1];
3675   unsigned char *apdu_buffer = NULL;
3676   size_t apdu_buffer_size;
3677   unsigned char *apdu;
3678   size_t apdulen;
3679   int sw;
3680   long rc; /* We need a long here due to PC/SC. */
3681   int did_exact_length_hack = 0;
3682   int use_chaining = 0;
3683   int use_extended_length = 0;
3684   int lc_chunk;
3685
3686   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3687     return SW_HOST_NO_DRIVER;
3688
3689   if (DBG_CARD_IO)
3690     log_debug ("send apdu: c=%02X i=%02X p1=%02X p2=%02X lc=%d le=%d em=%d\n",
3691                class, ins, p0, p1, lc, le, extended_mode);
3692
3693   if (lc != -1 && (lc > 255 || lc < 0))
3694     {
3695       /* Data does not fit into an APDU.  What we do now depends on
3696          the EXTENDED_MODE parameter.  */
3697       if (!extended_mode)
3698         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
3699       else if (extended_mode > 0)
3700         use_extended_length = 1;
3701       else if (extended_mode < 0)
3702         {
3703           /* Send APDU using chaining mode.  */
3704           if (lc > 16384)
3705             return SW_WRONG_LENGTH;   /* Sanity check.  */
3706           if ((class&0xf0) != 0)
3707             return SW_HOST_INV_VALUE; /* Upper 4 bits need to be 0.  */
3708           use_chaining = extended_mode == -1? 255 : -extended_mode;
3709           use_chaining &= 0xff;
3710         }
3711       else
3712         return SW_HOST_INV_VALUE;
3713     }
3714   else if (lc == -1 && extended_mode > 0)
3715     use_extended_length = 1;
3716
3717   if (le != -1 && (le > (extended_mode > 0? 255:256) || le < 0))
3718     {
3719       /* Expected Data does not fit into an APDU.  What we do now
3720          depends on the EXTENDED_MODE parameter.  Note that a check
3721          for command chaining does not make sense because we are
3722          looking at Le.  */
3723       if (!extended_mode)
3724         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
3725       else if (use_extended_length)
3726         ; /* We are already using extended length.  */
3727       else if (extended_mode > 0)
3728         use_extended_length = 1;
3729       else
3730         return SW_HOST_INV_VALUE;
3731     }
3732
3733   if ((!data && lc != -1) || (data && lc == -1))
3734     return SW_HOST_INV_VALUE;
3735
3736   if (use_extended_length)
3737     {
3738       if (reader_table[slot].is_t0)
3739         return SW_HOST_NOT_SUPPORTED;
3740
3741       /* Space for: cls/ins/p1/p2+Z+2_byte_Lc+Lc+2_byte_Le.  */
3742       apdu_buffer_size = 4 + 1 + (lc >= 0? (2+lc):0) + 2;
3743       apdu_buffer = xtrymalloc (apdu_buffer_size + 10);
3744       if (!apdu_buffer)
3745         return SW_HOST_OUT_OF_CORE;
3746       apdu = apdu_buffer;
3747     }
3748   else
3749     {
3750       apdu_buffer_size = sizeof short_apdu_buffer;
3751       apdu = short_apdu_buffer;
3752     }
3753
3754   if (use_extended_length && (le > 256 || le < 0))
3755     {