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