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