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