scd: pinpad fix for PC/SC on Windows.
[gnupg.git] / scd / apdu.c
1 /* apdu.c - ISO 7816 APDU functions and low level I/O
2  * Copyright (C) 2003, 2004, 2008, 2009 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   pininfo->minlen = reader_table[slot].pcsc.pinmin;
2210   pininfo->maxlen = reader_table[slot].pcsc.pinmax;
2211
2212   if ((command == ISO7816_VERIFY && reader_table[slot].pcsc.verify_ioctl != 0)
2213       || (command == ISO7816_CHANGE_REFERENCE_DATA
2214           && reader_table[slot].pcsc.modify_ioctl != 0))
2215     r = 0;                       /* Success */
2216   else
2217     r = SW_NOT_SUPPORTED;
2218
2219   if (DBG_CARD_IO)
2220     log_debug ("check_pcsc_pinpad: command=%02X, r=%d\n",
2221                (unsigned int)command, r);
2222
2223   if (reader_table[slot].pinpad_varlen_supported)
2224     pininfo->fixedlen = 0;
2225
2226   return r;
2227 }
2228
2229 #define PIN_VERIFY_STRUCTURE_SIZE 24
2230 static int
2231 pcsc_pinpad_verify (int slot, int class, int ins, int p0, int p1,
2232                     pininfo_t *pininfo)
2233 {
2234   int sw;
2235   unsigned char *pin_verify;
2236   int len = PIN_VERIFY_STRUCTURE_SIZE + pininfo->fixedlen;
2237   unsigned char result[2];
2238   pcsc_dword_t resultlen = 2;
2239   int no_lc;
2240
2241   if (!reader_table[slot].atrlen
2242       && (sw = reset_pcsc_reader (slot)))
2243     return sw;
2244
2245   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2246     return SW_NOT_SUPPORTED;
2247
2248   if (!pininfo->minlen)
2249     pininfo->minlen = 1;
2250   if (!pininfo->maxlen)
2251     pininfo->maxlen = 15;
2252
2253   pin_verify = xtrymalloc (len);
2254   if (!pin_verify)
2255     return SW_HOST_OUT_OF_CORE;
2256
2257   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2258
2259   pin_verify[0] = 0x00; /* bTimeOut */
2260   pin_verify[1] = 0x00; /* bTimeOut2 */
2261   pin_verify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2262   pin_verify[3] = pininfo->fixedlen; /* bmPINBlockString */
2263   pin_verify[4] = 0x00; /* bmPINLengthFormat */
2264   pin_verify[5] = pininfo->maxlen; /* wPINMaxExtraDigit */
2265   pin_verify[6] = pininfo->minlen; /* wPINMaxExtraDigit */
2266   pin_verify[7] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2267   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2268     pin_verify[7] |= 0x01; /* Max size reached.  */
2269   pin_verify[8] = 0x01; /* bNumberMessage: One message */
2270   pin_verify[9] =  0x09; /* wLangId: 0x0409: US English */
2271   pin_verify[10] = 0x04; /* wLangId: 0x0409: US English */
2272   pin_verify[11] = 0x00; /* bMsgIndex */
2273   pin_verify[12] = 0x00; /* bTeoPrologue[0] */
2274   pin_verify[13] = 0x00; /* bTeoPrologue[1] */
2275   pin_verify[14] = pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2276   pin_verify[15] = pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2277   pin_verify[16] = 0x00; /* ulDataLength */
2278   pin_verify[17] = 0x00; /* ulDataLength */
2279   pin_verify[18] = 0x00; /* ulDataLength */
2280   pin_verify[19] = class; /* abData[0] */
2281   pin_verify[20] = ins; /* abData[1] */
2282   pin_verify[21] = p0; /* abData[2] */
2283   pin_verify[22] = p1; /* abData[3] */
2284   pin_verify[23] = pininfo->fixedlen; /* abData[4] */
2285   if (pininfo->fixedlen)
2286     memset (&pin_verify[24], 0xff, pininfo->fixedlen);
2287   else if (no_lc)
2288     len--;
2289
2290   if (DBG_CARD_IO)
2291     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2292                class, ins, p0, p1, len, pininfo->maxlen);
2293
2294   sw = control_pcsc (slot, reader_table[slot].pcsc.verify_ioctl,
2295                      pin_verify, len, result, &resultlen);
2296   xfree (pin_verify);
2297   if (sw || resultlen < 2)
2298     {
2299       log_error ("control_pcsc failed: %d\n", sw);
2300       return sw? sw: SW_HOST_INCOMPLETE_CARD_RESPONSE;
2301     }
2302   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2303   if (DBG_CARD_IO)
2304     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2305   return sw;
2306 }
2307
2308
2309 #define PIN_MODIFY_STRUCTURE_SIZE 29
2310 static int
2311 pcsc_pinpad_modify (int slot, int class, int ins, int p0, int p1,
2312                     pininfo_t *pininfo)
2313 {
2314   int sw;
2315   unsigned char *pin_modify;
2316   int len = PIN_MODIFY_STRUCTURE_SIZE + 2 * pininfo->fixedlen;
2317   unsigned char result[2];
2318   pcsc_dword_t resultlen = 2;
2319   int no_lc;
2320
2321   if (!reader_table[slot].atrlen
2322       && (sw = reset_pcsc_reader (slot)))
2323     return sw;
2324
2325   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2326     return SW_NOT_SUPPORTED;
2327
2328   if (!pininfo->minlen)
2329     pininfo->minlen = 1;
2330   if (!pininfo->maxlen)
2331     pininfo->maxlen = 15;
2332
2333   /* Note that the 25 is the maximum value the SPR532 allows.  */
2334   if (pininfo->minlen < 1 || pininfo->minlen > 25
2335       || pininfo->maxlen < 1 || pininfo->maxlen > 25
2336       || pininfo->minlen > pininfo->maxlen)
2337     return SW_HOST_INV_VALUE;
2338
2339   pin_modify = xtrymalloc (len);
2340   if (!pin_modify)
2341     return SW_HOST_OUT_OF_CORE;
2342
2343   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2344
2345   pin_modify[0] = 0x00; /* bTimeOut */
2346   pin_modify[1] = 0x00; /* bTimeOut2 */
2347   pin_modify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2348   pin_modify[3] = pininfo->fixedlen; /* bmPINBlockString */
2349   pin_modify[4] = 0x00; /* bmPINLengthFormat */
2350   pin_modify[5] = 0x00; /* bInsertionOffsetOld */
2351   pin_modify[6] = pininfo->fixedlen; /* bInsertionOffsetNew */
2352   pin_modify[7] = pininfo->maxlen; /* wPINMaxExtraDigit */
2353   pin_modify[8] = pininfo->minlen; /* wPINMaxExtraDigit */
2354   pin_modify[9] = (p0 == 0 ? 0x03 : 0x01);
2355                   /* bConfirmPIN
2356                    *    0x00: new PIN once
2357                    *    0x01: new PIN twice (confirmation)
2358                    *    0x02: old PIN and new PIN once
2359                    *    0x03: old PIN and new PIN twice (confirmation)
2360                    */
2361   pin_modify[10] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2362   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2363     pin_modify[10] |= 0x01; /* Max size reached.  */
2364   pin_modify[11] = 0x03; /* bNumberMessage: Three messages */
2365   pin_modify[12] = 0x09; /* wLangId: 0x0409: US English */
2366   pin_modify[13] = 0x04; /* wLangId: 0x0409: US English */
2367   pin_modify[14] = 0x00; /* bMsgIndex1 */
2368   pin_modify[15] = 0x01; /* bMsgIndex2 */
2369   pin_modify[16] = 0x02; /* bMsgIndex3 */
2370   pin_modify[17] = 0x00; /* bTeoPrologue[0] */
2371   pin_modify[18] = 0x00; /* bTeoPrologue[1] */
2372   pin_modify[19] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2373   pin_modify[20] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2374   pin_modify[21] = 0x00; /* ulDataLength */
2375   pin_modify[22] = 0x00; /* ulDataLength */
2376   pin_modify[23] = 0x00; /* ulDataLength */
2377   pin_modify[24] = class; /* abData[0] */
2378   pin_modify[25] = ins; /* abData[1] */
2379   pin_modify[26] = p0; /* abData[2] */
2380   pin_modify[27] = p1; /* abData[3] */
2381   pin_modify[28] = 2 * pininfo->fixedlen; /* abData[4] */
2382   if (pininfo->fixedlen)
2383     memset (&pin_modify[29], 0xff, 2 * pininfo->fixedlen);
2384   else if (no_lc)
2385     len--;
2386
2387   if (DBG_CARD_IO)
2388     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2389                class, ins, p0, p1, len, (int)pininfo->maxlen);
2390
2391   sw = control_pcsc (slot, reader_table[slot].pcsc.modify_ioctl,
2392                      pin_modify, len, result, &resultlen);
2393   xfree (pin_modify);
2394   if (sw || resultlen < 2)
2395     {
2396       log_error ("control_pcsc failed: %d\n", sw);
2397       return sw? sw : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2398     }
2399   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2400   if (DBG_CARD_IO)
2401     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2402   return sw;
2403 }
2404 \f
2405 #ifdef HAVE_LIBUSB
2406 /*
2407      Internal CCID driver interface.
2408  */
2409
2410
2411 static void
2412 dump_ccid_reader_status (int slot)
2413 {
2414   log_info ("reader slot %d: using ccid driver\n", slot);
2415 }
2416
2417 static int
2418 close_ccid_reader (int slot)
2419 {
2420   ccid_close_reader (reader_table[slot].ccid.handle);
2421   reader_table[slot].used = 0;
2422   return 0;
2423 }
2424
2425
2426 static int
2427 shutdown_ccid_reader (int slot)
2428 {
2429   ccid_shutdown_reader (reader_table[slot].ccid.handle);
2430   return 0;
2431 }
2432
2433
2434 static int
2435 reset_ccid_reader (int slot)
2436 {
2437   int err;
2438   reader_table_t slotp = reader_table + slot;
2439   unsigned char atr[33];
2440   size_t atrlen;
2441
2442   err = ccid_get_atr (slotp->ccid.handle, atr, sizeof atr, &atrlen);
2443   if (err)
2444     return err;
2445   /* If the reset was successful, update the ATR. */
2446   assert (sizeof slotp->atr >= sizeof atr);
2447   slotp->atrlen = atrlen;
2448   memcpy (slotp->atr, atr, atrlen);
2449   dump_reader_status (slot);
2450   return 0;
2451 }
2452
2453
2454 static int
2455 set_progress_cb_ccid_reader (int slot, gcry_handler_progress_t cb, void *cb_arg)
2456 {
2457   reader_table_t slotp = reader_table + slot;
2458
2459   return ccid_set_progress_cb (slotp->ccid.handle, cb, cb_arg);
2460 }
2461
2462
2463 static int
2464 get_status_ccid (int slot, unsigned int *status)
2465 {
2466   int rc;
2467   int bits;
2468
2469   rc = ccid_slot_status (reader_table[slot].ccid.handle, &bits);
2470   if (rc)
2471     return rc;
2472
2473   if (bits == 0)
2474     *status = (APDU_CARD_USABLE|APDU_CARD_PRESENT|APDU_CARD_ACTIVE);
2475   else if (bits == 1)
2476     *status = APDU_CARD_PRESENT;
2477   else
2478     *status = 0;
2479
2480   return 0;
2481 }
2482
2483
2484 /* Actually send the APDU of length APDULEN to SLOT and return a
2485    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2486    set to BUFLEN.  Returns: Internal CCID driver error code. */
2487 static int
2488 send_apdu_ccid (int slot, unsigned char *apdu, size_t apdulen,
2489                 unsigned char *buffer, size_t *buflen,
2490                 pininfo_t *pininfo)
2491 {
2492   long err;
2493   size_t maxbuflen;
2494
2495   /* If we don't have an ATR, we need to reset the reader first. */
2496   if (!reader_table[slot].atrlen
2497       && (err = reset_ccid_reader (slot)))
2498     return err;
2499
2500   if (DBG_CARD_IO)
2501     log_printhex (" raw apdu:", apdu, apdulen);
2502
2503   maxbuflen = *buflen;
2504   if (pininfo)
2505     err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2506                                   apdu, apdulen, pininfo,
2507                                   buffer, maxbuflen, buflen);
2508   else
2509     err = ccid_transceive (reader_table[slot].ccid.handle,
2510                            apdu, apdulen,
2511                            buffer, maxbuflen, buflen);
2512   if (err)
2513     log_error ("ccid_transceive failed: (0x%lx)\n",
2514                err);
2515
2516   return err;
2517 }
2518
2519
2520 /* Check whether the CCID reader supports the ISO command code COMMAND
2521    on the pinpad.  Return 0 on success.  For a description of the pin
2522    parameters, see ccid-driver.c */
2523 static int
2524 check_ccid_pinpad (int slot, int command, pininfo_t *pininfo)
2525 {
2526   unsigned char apdu[] = { 0, 0, 0, 0x81 };
2527
2528   apdu[1] = command;
2529   return ccid_transceive_secure (reader_table[slot].ccid.handle, apdu,
2530                                  sizeof apdu, pininfo, NULL, 0, NULL);
2531 }
2532
2533
2534 static int
2535 ccid_pinpad_operation (int slot, int class, int ins, int p0, int p1,
2536                        pininfo_t *pininfo)
2537 {
2538   unsigned char apdu[4];
2539   int err, sw;
2540   unsigned char result[2];
2541   size_t resultlen = 2;
2542
2543   apdu[0] = class;
2544   apdu[1] = ins;
2545   apdu[2] = p0;
2546   apdu[3] = p1;
2547   err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2548                                 apdu, sizeof apdu, pininfo,
2549                                 result, 2, &resultlen);
2550   if (err)
2551     return err;
2552
2553   if (resultlen < 2)
2554     return SW_HOST_INCOMPLETE_CARD_RESPONSE;
2555
2556   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2557   return sw;
2558 }
2559
2560
2561 /* Open the reader and try to read an ATR.  */
2562 static int
2563 open_ccid_reader (const char *portstr)
2564 {
2565   int err;
2566   int slot;
2567   reader_table_t slotp;
2568
2569   slot = new_reader_slot ();
2570   if (slot == -1)
2571     return -1;
2572   slotp = reader_table + slot;
2573
2574   err = ccid_open_reader (&slotp->ccid.handle, portstr);
2575   if (err)
2576     {
2577       slotp->used = 0;
2578       unlock_slot (slot);
2579       return -1;
2580     }
2581
2582   err = ccid_get_atr (slotp->ccid.handle,
2583                       slotp->atr, sizeof slotp->atr, &slotp->atrlen);
2584   if (err)
2585     {
2586       slotp->atrlen = 0;
2587       err = 0;
2588     }
2589   else
2590     {
2591       /* If we got to here we know that a card is present
2592          and usable.  Thus remember this.  */
2593       reader_table[slot].last_status = (APDU_CARD_USABLE
2594                                         | APDU_CARD_PRESENT
2595                                         | APDU_CARD_ACTIVE);
2596     }
2597
2598   reader_table[slot].close_reader = close_ccid_reader;
2599   reader_table[slot].shutdown_reader = shutdown_ccid_reader;
2600   reader_table[slot].reset_reader = reset_ccid_reader;
2601   reader_table[slot].get_status_reader = get_status_ccid;
2602   reader_table[slot].send_apdu_reader = send_apdu_ccid;
2603   reader_table[slot].check_pinpad = check_ccid_pinpad;
2604   reader_table[slot].dump_status_reader = dump_ccid_reader_status;
2605   reader_table[slot].set_progress_cb = set_progress_cb_ccid_reader;
2606   reader_table[slot].pinpad_verify = ccid_pinpad_operation;
2607   reader_table[slot].pinpad_modify = ccid_pinpad_operation;
2608   /* Our CCID reader code does not support T=0 at all, thus reset the
2609      flag.  */
2610   reader_table[slot].is_t0 = 0;
2611
2612   dump_reader_status (slot);
2613   unlock_slot (slot);
2614   return slot;
2615 }
2616
2617
2618
2619 #endif /* HAVE_LIBUSB */
2620
2621
2622 \f
2623 #ifdef USE_G10CODE_RAPDU
2624 /*
2625      The Remote APDU Interface.
2626
2627      This uses the Remote APDU protocol to contact a reader.
2628
2629      The port number is actually an index into the list of ports as
2630      returned via the protocol.
2631  */
2632
2633
2634 static int
2635 rapdu_status_to_sw (int status)
2636 {
2637   int rc;
2638
2639   switch (status)
2640     {
2641     case RAPDU_STATUS_SUCCESS:  rc = 0; break;
2642
2643     case RAPDU_STATUS_INVCMD:
2644     case RAPDU_STATUS_INVPROT:
2645     case RAPDU_STATUS_INVSEQ:
2646     case RAPDU_STATUS_INVCOOKIE:
2647     case RAPDU_STATUS_INVREADER:  rc = SW_HOST_INV_VALUE;  break;
2648
2649     case RAPDU_STATUS_TIMEOUT:  rc = SW_HOST_CARD_IO_ERROR; break;
2650     case RAPDU_STATUS_CARDIO:   rc = SW_HOST_CARD_IO_ERROR; break;
2651     case RAPDU_STATUS_NOCARD:   rc = SW_HOST_NO_CARD; break;
2652     case RAPDU_STATUS_CARDCHG:  rc = SW_HOST_NO_CARD; break;
2653     case RAPDU_STATUS_BUSY:     rc = SW_HOST_BUSY; break;
2654     case RAPDU_STATUS_NEEDRESET: rc = SW_HOST_CARD_INACTIVE; break;
2655
2656     default: rc = SW_HOST_GENERAL_ERROR; break;
2657     }
2658
2659   return rc;
2660 }
2661
2662
2663
2664 static int
2665 close_rapdu_reader (int slot)
2666 {
2667   rapdu_release (reader_table[slot].rapdu.handle);
2668   reader_table[slot].used = 0;
2669   return 0;
2670 }
2671
2672
2673 static int
2674 reset_rapdu_reader (int slot)
2675 {
2676   int err;
2677   reader_table_t slotp;
2678   rapdu_msg_t msg = NULL;
2679
2680   slotp = reader_table + slot;
2681
2682   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2683   if (err)
2684     {
2685       log_error ("sending rapdu command RESET failed: %s\n",
2686                 err < 0 ? strerror (errno): rapdu_strerror (err));
2687       rapdu_msg_release (msg);
2688       return rapdu_status_to_sw (err);
2689     }
2690   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2691   if (err)
2692     {
2693       log_error ("receiving rapdu message failed: %s\n",
2694                 err < 0 ? strerror (errno): rapdu_strerror (err));
2695       rapdu_msg_release (msg);
2696       return rapdu_status_to_sw (err);
2697     }
2698   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2699     {
2700       int sw = rapdu_status_to_sw (msg->cmd);
2701       log_error ("rapdu command RESET failed: %s\n",
2702                  rapdu_strerror (msg->cmd));
2703       rapdu_msg_release (msg);
2704       return sw;
2705     }
2706   if (msg->datalen > DIM (slotp->atr))
2707     {
2708       log_error ("ATR returned by the RAPDU layer is too large\n");
2709       rapdu_msg_release (msg);
2710       return SW_HOST_INV_VALUE;
2711     }
2712   slotp->atrlen = msg->datalen;
2713   memcpy (slotp->atr, msg->data, msg->datalen);
2714
2715   rapdu_msg_release (msg);
2716   return 0;
2717 }
2718
2719
2720 static int
2721 my_rapdu_get_status (int slot, unsigned int *status)
2722 {
2723   int err;
2724   reader_table_t slotp;
2725   rapdu_msg_t msg = NULL;
2726   int oldslot;
2727
2728   slotp = reader_table + slot;
2729
2730   oldslot = rapdu_set_reader (slotp->rapdu.handle, slot);
2731   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_STATUS);
2732   rapdu_set_reader (slotp->rapdu.handle, oldslot);
2733   if (err)
2734     {
2735       log_error ("sending rapdu command GET_STATUS failed: %s\n",
2736                 err < 0 ? strerror (errno): rapdu_strerror (err));
2737       return rapdu_status_to_sw (err);
2738     }
2739   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2740   if (err)
2741     {
2742       log_error ("receiving rapdu message failed: %s\n",
2743                 err < 0 ? strerror (errno): rapdu_strerror (err));
2744       rapdu_msg_release (msg);
2745       return rapdu_status_to_sw (err);
2746     }
2747   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2748     {
2749       int sw = rapdu_status_to_sw (msg->cmd);
2750       log_error ("rapdu command GET_STATUS failed: %s\n",
2751                  rapdu_strerror (msg->cmd));
2752       rapdu_msg_release (msg);
2753       return sw;
2754     }
2755   *status = msg->data[0];
2756
2757   rapdu_msg_release (msg);
2758   return 0;
2759 }
2760
2761
2762 /* Actually send the APDU of length APDULEN to SLOT and return a
2763    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2764    set to BUFLEN.  Returns: APDU error code. */
2765 static int
2766 my_rapdu_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
2767                     unsigned char *buffer, size_t *buflen,
2768                     pininfo_t *pininfo)
2769 {
2770   int err;
2771   reader_table_t slotp;
2772   rapdu_msg_t msg = NULL;
2773   size_t maxlen = *buflen;
2774
2775   slotp = reader_table + slot;
2776
2777   *buflen = 0;
2778   if (DBG_CARD_IO)
2779     log_printhex ("  APDU_data:", apdu, apdulen);
2780
2781   if (apdulen < 4)
2782     {
2783       log_error ("rapdu_send_apdu: APDU is too short\n");
2784       return SW_HOST_INV_VALUE;
2785     }
2786
2787   err = rapdu_send_apdu (slotp->rapdu.handle, apdu, apdulen);
2788   if (err)
2789     {
2790       log_error ("sending rapdu command APDU failed: %s\n",
2791                 err < 0 ? strerror (errno): rapdu_strerror (err));
2792       rapdu_msg_release (msg);
2793       return rapdu_status_to_sw (err);
2794     }
2795   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2796   if (err)
2797     {
2798       log_error ("receiving rapdu message failed: %s\n",
2799                 err < 0 ? strerror (errno): rapdu_strerror (err));
2800       rapdu_msg_release (msg);
2801       return rapdu_status_to_sw (err);
2802     }
2803   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2804     {
2805       int sw = rapdu_status_to_sw (msg->cmd);
2806       log_error ("rapdu command APDU failed: %s\n",
2807                  rapdu_strerror (msg->cmd));
2808       rapdu_msg_release (msg);
2809       return sw;
2810     }
2811
2812   if (msg->datalen > maxlen)
2813     {
2814       log_error ("rapdu response apdu too large\n");
2815       rapdu_msg_release (msg);
2816       return SW_HOST_INV_VALUE;
2817     }
2818
2819   *buflen = msg->datalen;
2820   memcpy (buffer, msg->data, msg->datalen);
2821
2822   rapdu_msg_release (msg);
2823   return 0;
2824 }
2825
2826 static int
2827 open_rapdu_reader (int portno,
2828                    const unsigned char *cookie, size_t length,
2829                    int (*readfnc) (void *opaque,
2830                                    void *buffer, size_t size),
2831                    void *readfnc_value,
2832                    int (*writefnc) (void *opaque,
2833                                     const void *buffer, size_t size),
2834                    void *writefnc_value,
2835                    void (*closefnc) (void *opaque),
2836                    void *closefnc_value)
2837 {
2838   int err;
2839   int slot;
2840   reader_table_t slotp;
2841   rapdu_msg_t msg = NULL;
2842
2843   slot = new_reader_slot ();
2844   if (slot == -1)
2845     return -1;
2846   slotp = reader_table + slot;
2847
2848   slotp->rapdu.handle = rapdu_new ();
2849   if (!slotp->rapdu.handle)
2850     {
2851       slotp->used = 0;
2852       unlock_slot (slot);
2853       return -1;
2854     }
2855
2856   rapdu_set_reader (slotp->rapdu.handle, portno);
2857
2858   rapdu_set_iofunc (slotp->rapdu.handle,
2859                     readfnc, readfnc_value,
2860                     writefnc, writefnc_value,
2861                     closefnc, closefnc_value);
2862   rapdu_set_cookie (slotp->rapdu.handle, cookie, length);
2863
2864   /* First try to get the current ATR, but if the card is inactive
2865      issue a reset instead.  */
2866   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_ATR);
2867   if (err == RAPDU_STATUS_NEEDRESET)
2868     err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2869   if (err)
2870     {
2871       log_info ("sending rapdu command GET_ATR/RESET failed: %s\n",
2872                 err < 0 ? strerror (errno): rapdu_strerror (err));
2873       goto failure;
2874     }
2875   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2876   if (err)
2877     {
2878       log_info ("receiving rapdu message failed: %s\n",
2879                 err < 0 ? strerror (errno): rapdu_strerror (err));
2880       goto failure;
2881     }
2882   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2883     {
2884       log_info ("rapdu command GET ATR failed: %s\n",
2885                  rapdu_strerror (msg->cmd));
2886       goto failure;
2887     }
2888   if (msg->datalen > DIM (slotp->atr))
2889     {
2890       log_error ("ATR returned by the RAPDU layer is too large\n");
2891       goto failure;
2892     }
2893   slotp->atrlen = msg->datalen;
2894   memcpy (slotp->atr, msg->data, msg->datalen);
2895
2896   reader_table[slot].close_reader = close_rapdu_reader;
2897   reader_table[slot].reset_reader = reset_rapdu_reader;
2898   reader_table[slot].get_status_reader = my_rapdu_get_status;
2899   reader_table[slot].send_apdu_reader = my_rapdu_send_apdu;
2900   reader_table[slot].check_pinpad = NULL;
2901   reader_table[slot].dump_status_reader = NULL;
2902   reader_table[slot].pinpad_verify = NULL;
2903   reader_table[slot].pinpad_modify = NULL;
2904
2905   dump_reader_status (slot);
2906   rapdu_msg_release (msg);
2907   unlock_slot (slot);
2908   return slot;
2909
2910  failure:
2911   rapdu_msg_release (msg);
2912   rapdu_release (slotp->rapdu.handle);
2913   slotp->used = 0;
2914   unlock_slot (slot);
2915   return -1;
2916 }
2917
2918 #endif /*USE_G10CODE_RAPDU*/
2919
2920
2921 \f
2922 /*
2923        Driver Access
2924  */
2925
2926
2927 /* Open the reader and return an internal slot number or -1 on
2928    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
2929    the first USB reader.  For PC/SC the first listed reader). */
2930 int
2931 apdu_open_reader (const char *portstr)
2932 {
2933   static int pcsc_api_loaded, ct_api_loaded;
2934
2935 #ifdef HAVE_LIBUSB
2936   if (!opt.disable_ccid)
2937     {
2938       int slot, i;
2939       const char *s;
2940
2941       slot = open_ccid_reader (portstr);
2942       if (slot != -1)
2943         return slot; /* got one */
2944
2945       /* If a CCID reader specification has been given, the user does
2946          not want a fallback to other drivers. */
2947       if (portstr)
2948         for (s=portstr, i=0; *s; s++)
2949           if (*s == ':' && (++i == 3))
2950             return -1;
2951     }
2952
2953 #endif /* HAVE_LIBUSB */
2954
2955   if (opt.ctapi_driver && *opt.ctapi_driver)
2956     {
2957       int port = portstr? atoi (portstr) : 32768;
2958
2959       if (!ct_api_loaded)
2960         {
2961           void *handle;
2962
2963           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
2964           if (!handle)
2965             {
2966               log_error ("apdu_open_reader: failed to open driver: %s\n",
2967                          dlerror ());
2968               return -1;
2969             }
2970           CT_init = dlsym (handle, "CT_init");
2971           CT_data = dlsym (handle, "CT_data");
2972           CT_close = dlsym (handle, "CT_close");
2973           if (!CT_init || !CT_data || !CT_close)
2974             {
2975               log_error ("apdu_open_reader: invalid CT-API driver\n");
2976               dlclose (handle);
2977               return -1;
2978             }
2979           ct_api_loaded = 1;
2980         }
2981       return open_ct_reader (port);
2982     }
2983
2984
2985   /* No ctAPI configured, so lets try the PC/SC API */
2986   if (!pcsc_api_loaded)
2987     {
2988 #ifndef NEED_PCSC_WRAPPER
2989       void *handle;
2990
2991       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
2992       if (!handle)
2993         {
2994           log_error ("apdu_open_reader: failed to open driver `%s': %s\n",
2995                      opt.pcsc_driver, dlerror ());
2996           return -1;
2997         }
2998
2999       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
3000       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
3001       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
3002 #if defined(_WIN32) || defined(__CYGWIN__)
3003       if (!pcsc_list_readers)
3004         pcsc_list_readers    = dlsym (handle, "SCardListReadersA");
3005 #endif
3006       pcsc_get_status_change = dlsym (handle, "SCardGetStatusChange");
3007 #if defined(_WIN32) || defined(__CYGWIN__)
3008       if (!pcsc_get_status_change)
3009         pcsc_get_status_change = dlsym (handle, "SCardGetStatusChangeA");
3010 #endif
3011       pcsc_connect           = dlsym (handle, "SCardConnect");
3012 #if defined(_WIN32) || defined(__CYGWIN__)
3013       if (!pcsc_connect)
3014         pcsc_connect         = dlsym (handle, "SCardConnectA");
3015 #endif
3016       pcsc_reconnect         = dlsym (handle, "SCardReconnect");
3017 #if defined(_WIN32) || defined(__CYGWIN__)
3018       if (!pcsc_reconnect)
3019         pcsc_reconnect       = dlsym (handle, "SCardReconnectA");
3020 #endif
3021       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
3022       pcsc_status            = dlsym (handle, "SCardStatus");
3023 #if defined(_WIN32) || defined(__CYGWIN__)
3024       if (!pcsc_status)
3025         pcsc_status          = dlsym (handle, "SCardStatusA");
3026 #endif
3027       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
3028       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
3029       pcsc_transmit          = dlsym (handle, "SCardTransmit");
3030       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
3031       pcsc_control           = dlsym (handle, "SCardControl");
3032
3033       if (!pcsc_establish_context
3034           || !pcsc_release_context
3035           || !pcsc_list_readers
3036           || !pcsc_get_status_change
3037           || !pcsc_connect
3038           || !pcsc_reconnect
3039           || !pcsc_disconnect
3040           || !pcsc_status
3041           || !pcsc_begin_transaction
3042           || !pcsc_end_transaction
3043           || !pcsc_transmit
3044           || !pcsc_control
3045           /* || !pcsc_set_timeout */)
3046         {
3047           /* Note that set_timeout is currently not used and also not
3048              available under Windows. */
3049           log_error ("apdu_open_reader: invalid PC/SC driver "
3050                      "(%d%d%d%d%d%d%d%d%d%d%d%d%d)\n",
3051                      !!pcsc_establish_context,
3052                      !!pcsc_release_context,
3053                      !!pcsc_list_readers,
3054                      !!pcsc_get_status_change,
3055                      !!pcsc_connect,
3056                      !!pcsc_reconnect,
3057                      !!pcsc_disconnect,
3058                      !!pcsc_status,
3059                      !!pcsc_begin_transaction,
3060                      !!pcsc_end_transaction,
3061                      !!pcsc_transmit,
3062                      !!pcsc_set_timeout,
3063                      !!pcsc_control );
3064           dlclose (handle);
3065           return -1;
3066         }
3067 #endif /*!NEED_PCSC_WRAPPER*/
3068       pcsc_api_loaded = 1;
3069     }
3070
3071   return open_pcsc_reader (portstr);
3072 }
3073
3074
3075 /* Open an remote reader and return an internal slot number or -1 on
3076    error. This function is an alternative to apdu_open_reader and used
3077    with remote readers only.  Note that the supplied CLOSEFNC will
3078    only be called once and the slot will not be valid afther this.
3079
3080    If PORTSTR is NULL we default to the first availabe port.
3081 */
3082 int
3083 apdu_open_remote_reader (const char *portstr,
3084                          const unsigned char *cookie, size_t length,
3085                          int (*readfnc) (void *opaque,
3086                                          void *buffer, size_t size),
3087                          void *readfnc_value,
3088                          int (*writefnc) (void *opaque,
3089                                           const void *buffer, size_t size),
3090                          void *writefnc_value,
3091                          void (*closefnc) (void *opaque),
3092                          void *closefnc_value)
3093 {
3094 #ifdef USE_G10CODE_RAPDU
3095   return open_rapdu_reader (portstr? atoi (portstr) : 0,
3096                             cookie, length,
3097                             readfnc, readfnc_value,
3098                             writefnc, writefnc_value,
3099                             closefnc, closefnc_value);
3100 #else
3101   (void)portstr;
3102   (void)cookie;
3103   (void)length;
3104   (void)readfnc;
3105   (void)readfnc_value;
3106   (void)writefnc;
3107   (void)writefnc_value;
3108   (void)closefnc;
3109   (void)closefnc_value;
3110 #ifdef _WIN32
3111   errno = ENOENT;
3112 #else
3113   errno = ENOSYS;
3114 #endif
3115   return -1;
3116 #endif
3117 }
3118
3119
3120 int
3121 apdu_close_reader (int slot)
3122 {
3123   int sw;
3124
3125   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3126     return SW_HOST_NO_DRIVER;
3127   sw = apdu_disconnect (slot);
3128   if (sw)
3129     return sw;
3130   if (reader_table[slot].close_reader)
3131     return reader_table[slot].close_reader (slot);
3132   return SW_HOST_NOT_SUPPORTED;
3133 }
3134
3135
3136 /* Function suitable for a cleanup function to close all reader.  It
3137    should not be used if the reader will be opened again.  The reason
3138    for implementing this to properly close USB devices so that they
3139    will startup the next time without error. */
3140 void
3141 apdu_prepare_exit (void)
3142 {
3143   static int sentinel;
3144   int slot;
3145
3146   if (!sentinel)
3147     {
3148       sentinel = 1;
3149       for (slot = 0; slot < MAX_READER; slot++)
3150         if (reader_table[slot].used)
3151           {
3152             apdu_disconnect (slot);
3153             if (reader_table[slot].close_reader)
3154               reader_table[slot].close_reader (slot);
3155             reader_table[slot].used = 0;
3156           }
3157       sentinel = 0;
3158     }
3159 }
3160
3161
3162 /* Shutdown a reader; that is basically the same as a close but keeps
3163    the handle ready for later use. A apdu_reset_reader or apdu_connect
3164    should be used to get it active again. */
3165 int
3166 apdu_shutdown_reader (int slot)
3167 {
3168   int sw;
3169
3170   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3171     return SW_HOST_NO_DRIVER;
3172   sw = apdu_disconnect (slot);
3173   if (sw)
3174     return sw;
3175   if (reader_table[slot].shutdown_reader)
3176     return reader_table[slot].shutdown_reader (slot);
3177   return SW_HOST_NOT_SUPPORTED;
3178 }
3179
3180 /* Enumerate all readers and return information on whether this reader
3181    is in use.  The caller should start with SLOT set to 0 and
3182    increment it with each call until an error is returned. */
3183 int
3184 apdu_enum_reader (int slot, int *used)
3185 {
3186   if (slot < 0 || slot >= MAX_READER)
3187     return SW_HOST_NO_DRIVER;
3188   *used = reader_table[slot].used;
3189   return 0;
3190 }
3191
3192
3193 /* Connect a card.  This is used to power up the card and make sure
3194    that an ATR is available.  Depending on the reader backend it may
3195    return an error for an inactive card or if no card is
3196    available.  */
3197 int
3198 apdu_connect (int slot)
3199 {
3200   int sw;
3201   unsigned int status;
3202
3203   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3204     return SW_HOST_NO_DRIVER;
3205
3206   /* Only if the access method provides a connect function we use it.
3207      If not, we expect that the card has been implicitly connected by
3208      apdu_open_reader.  */
3209   if (reader_table[slot].connect_card)
3210     {
3211       sw = lock_slot (slot);
3212       if (!sw)
3213         {
3214           sw = reader_table[slot].connect_card (slot);
3215           unlock_slot (slot);
3216         }
3217     }
3218   else
3219     sw = 0;
3220
3221   /* We need to call apdu_get_status_internal, so that the last-status
3222      machinery gets setup properly even if a card is inserted while
3223      scdaemon is fired up and apdu_get_status has not yet been called.
3224      Without that we would force a reset of the card with the next
3225      call to apdu_get_status.  */
3226   apdu_get_status_internal (slot, 1, 1, &status, NULL);
3227   if (sw)
3228     ;
3229   else if (!(status & APDU_CARD_PRESENT))
3230     sw = SW_HOST_NO_CARD;
3231   else if ((status & APDU_CARD_PRESENT) && !(status & APDU_CARD_ACTIVE))
3232     sw = SW_HOST_CARD_INACTIVE;
3233
3234
3235   return sw;
3236 }
3237
3238
3239 int
3240 apdu_disconnect (int slot)
3241 {
3242   int sw;
3243
3244   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3245     return SW_HOST_NO_DRIVER;
3246
3247   if (reader_table[slot].disconnect_card)
3248     {
3249       sw = lock_slot (slot);
3250       if (!sw)
3251         {
3252           sw = reader_table[slot].disconnect_card (slot);
3253           unlock_slot (slot);
3254         }
3255     }
3256   else
3257     sw = 0;
3258   return sw;
3259 }
3260
3261
3262 /* Set the progress callback of SLOT to CB and its args to CB_ARG.  If
3263    CB is NULL the progress callback is removed.  */
3264 int
3265 apdu_set_progress_cb (int slot, gcry_handler_progress_t cb, void *cb_arg)
3266 {
3267   int sw;
3268
3269   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3270     return SW_HOST_NO_DRIVER;
3271
3272   if (reader_table[slot].set_progress_cb)
3273     {
3274       sw = lock_slot (slot);
3275       if (!sw)
3276         {
3277           sw = reader_table[slot].set_progress_cb (slot, cb, cb_arg);
3278           unlock_slot (slot);
3279         }
3280     }
3281   else
3282     sw = 0;
3283   return sw;
3284 }
3285
3286
3287 /* Do a reset for the card in reader at SLOT. */
3288 int
3289 apdu_reset (int slot)
3290 {
3291   int sw;
3292
3293   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3294     return SW_HOST_NO_DRIVER;
3295
3296   if ((sw = lock_slot (slot)))
3297     return sw;
3298
3299   reader_table[slot].last_status = 0;
3300   if (reader_table[slot].reset_reader)
3301     sw = reader_table[slot].reset_reader (slot);
3302
3303   if (!sw)
3304     {
3305       /* If we got to here we know that a card is present
3306          and usable.  Thus remember this.  */
3307       reader_table[slot].last_status = (APDU_CARD_USABLE
3308                                         | APDU_CARD_PRESENT
3309                                         | APDU_CARD_ACTIVE);
3310     }
3311
3312   unlock_slot (slot);
3313   return sw;
3314 }
3315
3316
3317 /* Activate a card if it has not yet been done.  This is a kind of
3318    reset-if-required.  It is useful to test for presence of a card
3319    before issuing a bunch of apdu commands.  It does not wait on a
3320    locked card. */
3321 int
3322 apdu_activate (int slot)
3323 {
3324   int sw;
3325   unsigned int s;
3326
3327   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3328     return SW_HOST_NO_DRIVER;
3329
3330   if ((sw = trylock_slot (slot)))
3331     return sw;
3332
3333   if (reader_table[slot].get_status_reader)
3334     sw = reader_table[slot].get_status_reader (slot, &s);
3335
3336   if (!sw)
3337     {
3338       if (!(s & 2))  /* Card not present.  */
3339         sw = SW_HOST_NO_CARD;
3340       else if ( ((s & 2) && !(s & 4))
3341                 || !reader_table[slot].atrlen )
3342         {
3343           /* We don't have an ATR or a card is present though inactive:
3344              do a reset now. */
3345           if (reader_table[slot].reset_reader)
3346             {
3347               reader_table[slot].last_status = 0;
3348               sw = reader_table[slot].reset_reader (slot);
3349               if (!sw)
3350                 {
3351                   /* If we got to here we know that a card is present
3352                      and usable.  Thus remember this.  */
3353                   reader_table[slot].last_status = (APDU_CARD_USABLE
3354                                                     | APDU_CARD_PRESENT
3355                                                     | APDU_CARD_ACTIVE);
3356                 }
3357             }
3358         }
3359     }
3360
3361   unlock_slot (slot);
3362   return sw;
3363 }
3364
3365
3366 unsigned char *
3367 apdu_get_atr (int slot, size_t *atrlen)
3368 {
3369   unsigned char *buf;
3370
3371   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3372     return NULL;
3373   if (!reader_table[slot].atrlen)
3374     return NULL;
3375   buf = xtrymalloc (reader_table[slot].atrlen);
3376   if (!buf)
3377     return NULL;
3378   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
3379   *atrlen = reader_table[slot].atrlen;
3380   return buf;
3381 }
3382
3383
3384
3385 /* Retrieve the status for SLOT. The function does only wait for the
3386    card to become available if HANG is set to true. On success the
3387    bits in STATUS will be set to
3388
3389      APDU_CARD_USABLE  (bit 0) = card present and usable
3390      APDU_CARD_PRESENT (bit 1) = card present
3391      APDU_CARD_ACTIVE  (bit 2) = card active
3392                        (bit 3) = card access locked [not yet implemented]
3393
3394    For must applications, testing bit 0 is sufficient.
3395
3396    CHANGED will receive the value of the counter tracking the number
3397    of card insertions.  This value may be used to detect a card
3398    change.
3399 */
3400 static int
3401 apdu_get_status_internal (int slot, int hang, int no_atr_reset,
3402                           unsigned int *status, unsigned int *changed)
3403 {
3404   int sw;
3405   unsigned int s;
3406
3407   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3408     return SW_HOST_NO_DRIVER;
3409
3410   if ((sw = hang? lock_slot (slot) : trylock_slot (slot)))
3411     return sw;
3412
3413   if (reader_table[slot].get_status_reader)
3414     sw = reader_table[slot].get_status_reader (slot, &s);
3415
3416   unlock_slot (slot);
3417
3418   if (sw)
3419     {
3420       reader_table[slot].last_status = 0;
3421       return sw;
3422     }
3423
3424   /* Keep track of changes.  */
3425   if (s != reader_table[slot].last_status
3426       || !reader_table[slot].any_status )
3427     {
3428       reader_table[slot].change_counter++;
3429       /* Make sure that the ATR is invalid so that a reset will be
3430          triggered by apdu_activate.  */
3431       if (!no_atr_reset)
3432         reader_table[slot].atrlen = 0;
3433     }
3434   reader_table[slot].any_status = 1;
3435   reader_table[slot].last_status = s;
3436
3437   if (status)
3438     *status = s;
3439   if (changed)
3440     *changed = reader_table[slot].change_counter;
3441   return 0;
3442 }
3443
3444
3445 /* See above for a description.  */
3446 int
3447 apdu_get_status (int slot, int hang,
3448                  unsigned int *status, unsigned int *changed)
3449 {
3450   return apdu_get_status_internal (slot, hang, 0, status, changed);
3451 }
3452
3453
3454 /* Check whether the reader supports the ISO command code COMMAND on
3455    the pinpad.  Return 0 on success.  For a description of the pin
3456    parameters, see ccid-driver.c */
3457 int
3458 apdu_check_pinpad (int slot, int command, pininfo_t *pininfo)
3459 {
3460   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3461     return SW_HOST_NO_DRIVER;
3462
3463   if (opt.enable_pinpad_varlen)
3464     pininfo->fixedlen = 0;
3465
3466   if (reader_table[slot].check_pinpad)
3467     {
3468       int sw;
3469
3470       if ((sw = lock_slot (slot)))
3471         return sw;
3472
3473       sw = reader_table[slot].check_pinpad (slot, command, pininfo);
3474       unlock_slot (slot);
3475       return sw;
3476     }
3477   else
3478     return SW_HOST_NOT_SUPPORTED;
3479 }
3480
3481
3482 int
3483 apdu_pinpad_verify (int slot, int class, int ins, int p0, int p1,
3484                     pininfo_t *pininfo)
3485 {
3486   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3487     return SW_HOST_NO_DRIVER;
3488
3489   if (reader_table[slot].pinpad_verify)
3490     {
3491       int sw;
3492
3493       if ((sw = lock_slot (slot)))
3494         return sw;
3495
3496       sw = reader_table[slot].pinpad_verify (slot, class, ins, p0, p1,
3497                                              pininfo);
3498       unlock_slot (slot);
3499       return sw;
3500     }
3501   else
3502     return SW_HOST_NOT_SUPPORTED;
3503 }
3504
3505
3506 int
3507 apdu_pinpad_modify (int slot, int class, int ins, int p0, int p1,
3508                     pininfo_t *pininfo)
3509 {
3510   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3511     return SW_HOST_NO_DRIVER;
3512
3513   if (reader_table[slot].pinpad_modify)
3514     {
3515       int sw;
3516
3517       if ((sw = lock_slot (slot)))
3518         return sw;
3519
3520       sw = reader_table[slot].pinpad_modify (slot, class, ins, p0, p1,
3521                                              pininfo);
3522       unlock_slot (slot);
3523       return sw;
3524     }
3525   else
3526     return SW_HOST_NOT_SUPPORTED;
3527 }
3528
3529
3530 /* Dispatcher for the actual send_apdu function. Note, that this
3531    function should be called in locked state. */
3532 static int
3533 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
3534            unsigned char *buffer, size_t *buflen, pininfo_t *pininfo)
3535 {
3536   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3537     return SW_HOST_NO_DRIVER;
3538
3539   if (reader_table[slot].send_apdu_reader)
3540     return reader_table[slot].send_apdu_reader (slot,
3541                                                 apdu, apdulen,
3542                                                 buffer, buflen,
3543                                                 pininfo);
3544   else
3545     return SW_HOST_NOT_SUPPORTED;
3546 }
3547
3548
3549 /* Core APDU tranceiver function. Parameters are described at
3550    apdu_send_le with the exception of PININFO which indicates pinpad
3551    related operations if not NULL.  If EXTENDED_MODE is not 0
3552    command chaining or extended length will be used according to these
3553    values:
3554        n < 0 := Use command chaining with the data part limited to -n
3555                 in each chunk.  If -1 is used a default value is used.
3556       n == 0 := No extended mode or command chaining.
3557       n == 1 := Use extended length for input and output without a
3558                 length limit.
3559        n > 1 := Use extended length with up to N bytes.
3560
3561 */
3562 static int
3563 send_le (int slot, int class, int ins, int p0, int p1,
3564          int lc, const char *data, int le,
3565          unsigned char **retbuf, size_t *retbuflen,
3566          pininfo_t *pininfo, int extended_mode)
3567 {
3568 #define SHORT_RESULT_BUFFER_SIZE 258
3569   /* We allocate 8 extra bytes as a safety margin towards a driver bug.  */
3570   unsigned char short_result_buffer[SHORT_RESULT_BUFFER_SIZE+10];
3571   unsigned char *result_buffer = NULL;
3572   size_t result_buffer_size;
3573   unsigned char *result;
3574   size_t resultlen;
3575   unsigned char short_apdu_buffer[5+256+1];
3576   unsigned char *apdu_buffer = NULL;
3577   size_t apdu_buffer_size;
3578   unsigned char *apdu;
3579   size_t apdulen;
3580   int sw;
3581   long rc; /* We need a long here due to PC/SC. */
3582   int did_exact_length_hack = 0;
3583   int use_chaining = 0;
3584   int use_extended_length = 0;
3585   int lc_chunk;
3586
3587   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3588     return SW_HOST_NO_DRIVER;
3589
3590   if (DBG_CARD_IO)
3591     log_debug ("send apdu: c=%02X i=%02X p1=%02X p2=%02X lc=%d le=%d em=%d\n",
3592                class, ins, p0, p1, lc, le, extended_mode);
3593
3594   if (lc != -1 && (lc > 255 || lc < 0))
3595     {
3596       /* Data does not fit into an APDU.  What we do now depends on
3597          the EXTENDED_MODE parameter.  */
3598       if (!extended_mode)
3599         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
3600       else if (extended_mode > 0)
3601         use_extended_length = 1;
3602       else if (extended_mode < 0)
3603         {
3604           /* Send APDU using chaining mode.  */
3605           if (lc > 16384)
3606             return SW_WRONG_LENGTH;   /* Sanity check.  */
3607           if ((class&0xf0) != 0)
3608             return SW_HOST_INV_VALUE; /* Upper 4 bits need to be 0.  */
3609           use_chaining = extended_mode == -1? 255 : -extended_mode;
3610           use_chaining &= 0xff;
3611         }
3612       else
3613         return SW_HOST_INV_VALUE;
3614     }
3615   else if (lc == -1 && extended_mode > 0)
3616     use_extended_length = 1;
3617
3618   if (le != -1 && (le > (extended_mode > 0? 255:256) || le < 0))
3619     {
3620       /* Expected Data does not fit into an APDU.  What we do now
3621          depends on the EXTENDED_MODE parameter.  Note that a check
3622          for command chaining does not make sense because we are
3623          looking at Le.  */
3624       if (!extended_mode)
3625         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
3626       else if (use_extended_length)
3627         ; /* We are already using extended length.  */
3628       else if (extended_mode > 0)
3629         use_extended_length = 1;
3630       else
3631         return SW_HOST_INV_VALUE;
3632     }
3633
3634   if ((!data && lc != -1) || (data && lc == -1))
3635     return SW_HOST_INV_VALUE;
3636
3637   if (use_extended_length)
3638     {
3639       if (reader_table[slot].is_t0)
3640         return SW_HOST_NOT_SUPPORTED;
3641
3642       /* Space for: cls/ins/p1/p2+Z+2_byte_Lc+Lc+2_byte_Le.  */
3643       apdu_buffer_size = 4 + 1 + (lc >= 0? (2+lc):0) + 2;
3644       apdu_buffer = xtrymalloc (apdu_buffer_size + 10);
3645       if (!apdu_buffer)
3646         return SW_HOST_OUT_OF_CORE;
3647       apdu = apdu_buffer;
3648     }
3649   else
3650     {
3651       apdu_buffer_size = sizeof short_apdu_buffer;
3652       apdu = short_apdu_buffer;
3653     }
3654
3655   if (use_extended_length && (le > 256 || le < 0))
3656     {
3657       result_buffer_size = le < 0? 4096 : le;
3658       result_buffer = xtrymalloc (result_buffer_size + 10);
3659       if (!result_buffer)
3660         {
3661           xfree (apdu_buffer);
3662           return SW_HOST_OUT_OF_CORE;
3663         }
3664       result = result_buffer;
3665     }
3666   else
3667     {
3668       result_buffer_size = SHORT_RESULT_BUFFER_SIZE;
3669       result = short_result_buffer;
3670     }
3671 #undef SHORT_RESULT_BUFFER_SIZE
3672
3673   if ((sw = lock_slot (slot)))
3674     {
3675       xfree (apdu_buffer);
3676       xfree (result_buffer);
3677       return sw;
3678     }
3679
3680   do
3681     {
3682       if (use_extended_length)
3683         {
3684           use_chaining = 0;
3685           apdulen = 0;
3686           apdu[apdulen++] = class;
3687           apdu[apdulen++] = ins;
3688           apdu[apdulen++] = p0;
3689           apdu[apdulen++] = p1;
3690           apdu[apdulen++] = 0;  /* Z byte: Extended length marker.  */
3691           if (lc >= 0)
3692             {
3693               apdu[apdulen++] = ((lc >> 8) & 0xff);
3694               apdu[apdulen++] = (lc & 0xff);
3695               memcpy (apdu+apdulen, data, lc);
3696               data += lc;
3697               apdulen += lc;
3698             }
3699           if (le != -1)
3700             {
3701               apdu[apdulen++] = ((le >> 8) & 0xff);
3702               apdu[apdulen++] = (le & 0xff);
3703             }
3704         }
3705       else
3706         {
3707           apdulen = 0;
3708           apdu[apdulen] = class;
3709           if (use_chaining && lc > 255)
3710             {
3711               apdu[apdulen] |= 0x10;
3712               assert (use_chaining < 256);
3713               lc_chunk = use_chaining;
3714               lc -= use_chaining;
3715             }
3716           else
3717             {
3718               use_chaining = 0;
3719               lc_chunk = lc;
3720             }
3721           apdulen++;
3722           apdu[apdulen++] = ins;
3723           apdu[apdulen++] = p0;
3724           apdu[apdulen++] = p1;
3725           if (lc_chunk != -1)
3726             {
3727               apdu[apdulen++] = lc_chunk;
3728               memcpy (apdu+apdulen, data, lc_chunk);
3729               data += lc_chunk;
3730               apdulen += lc_chunk;
3731               /* T=0 does not allow the use of Lc together with Le;
3732                  thus disable Le in this case.  */
3733               if (reader_table[slot].is_t0)
3734                 le = -1;
3735             }
3736           if (le != -1 && !use_chaining)
3737             apdu[apdulen++] = le; /* Truncation is okay (0 means 256). */
3738         }
3739
3740     exact_length_hack:
3741       /* As a safeguard don't pass any garbage to the driver.  */
3742       assert (apdulen <= apdu_buffer_size);
3743       memset (apdu+apdulen, 0, apdu_buffer_size - apdulen);
3744       resultlen = result_buffer_size;
3745       rc = send_apdu (slot, apdu, apdulen, result, &resultlen, pininfo);
3746       if (rc || resultlen < 2)
3747         {
3748           log_info ("apdu_send_simple(%d) failed: %s\n",
3749  &nbs