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