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