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