scd: PC/SC reader selection by partial string match.
[gnupg.git] / scd / apdu.c
1 /* apdu.c - ISO 7816 APDU functions and low level I/O
2  * Copyright (C) 2003, 2004, 2008, 2009, 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   char *rdrname = NULL;
1915   pcsc_dword_t nreader;
1916   char *p;
1917
1918   slot = new_reader_slot ();
1919   if (slot == -1)
1920     return -1;
1921
1922   /* Fixme: Allocating a context for each slot is not required.  One
1923      global context should be sufficient.  */
1924   err = pcsc_establish_context (PCSC_SCOPE_SYSTEM, NULL, NULL,
1925                                 &reader_table[slot].pcsc.context);
1926   if (err)
1927     {
1928       log_error ("pcsc_establish_context failed: %s (0x%lx)\n",
1929                  pcsc_error_string (err), err);
1930       reader_table[slot].used = 0;
1931       unlock_slot (slot);
1932       return -1;
1933     }
1934
1935   err = pcsc_list_readers (reader_table[slot].pcsc.context,
1936                            NULL, NULL, &nreader);
1937   if (!err)
1938     {
1939       list = xtrymalloc (nreader+1); /* Better add 1 for safety reasons. */
1940       if (!list)
1941         {
1942           log_error ("error allocating memory for reader list\n");
1943           pcsc_release_context (reader_table[slot].pcsc.context);
1944           reader_table[slot].used = 0;
1945           unlock_slot (slot);
1946           return -1 /*SW_HOST_OUT_OF_CORE*/;
1947         }
1948       err = pcsc_list_readers (reader_table[slot].pcsc.context,
1949                                NULL, list, &nreader);
1950     }
1951   if (err)
1952     {
1953       log_error ("pcsc_list_readers failed: %s (0x%lx)\n",
1954                  pcsc_error_string (err), err);
1955       pcsc_release_context (reader_table[slot].pcsc.context);
1956       reader_table[slot].used = 0;
1957       xfree (list);
1958       unlock_slot (slot);
1959       return -1;
1960     }
1961
1962   p = list;
1963   while (nreader)
1964     {
1965       if (!*p && !p[1])
1966         break;
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       if (!rdrname && portstr && !strncmp (p, portstr, strlen (portstr)))
1974         rdrname = p;
1975       nreader -= strlen (p)+1;
1976       p += strlen (p) + 1;
1977     }
1978
1979   if (!rdrname)
1980     rdrname = list;
1981
1982   reader_table[slot].rdrname = xtrystrdup (rdrname);
1983   if (!reader_table[slot].rdrname)
1984     {
1985       log_error ("error allocating memory for reader name\n");
1986       pcsc_release_context (reader_table[slot].pcsc.context);
1987       reader_table[slot].used = 0;
1988       unlock_slot (slot);
1989       return -1;
1990     }
1991   xfree (list);
1992   list = NULL;
1993
1994   reader_table[slot].pcsc.card = 0;
1995   reader_table[slot].atrlen = 0;
1996   reader_table[slot].last_status = 0;
1997
1998   reader_table[slot].connect_card = connect_pcsc_card;
1999   reader_table[slot].disconnect_card = disconnect_pcsc_card;
2000   reader_table[slot].close_reader = close_pcsc_reader;
2001   reader_table[slot].reset_reader = reset_pcsc_reader;
2002   reader_table[slot].get_status_reader = pcsc_get_status;
2003   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
2004   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
2005
2006   dump_reader_status (slot);
2007   unlock_slot (slot);
2008   return slot;
2009 }
2010 #endif /*!NEED_PCSC_WRAPPER */
2011
2012
2013 /* Open the PC/SC reader using the pcsc_wrapper program.  This is
2014    needed to cope with different thread models and other peculiarities
2015    of libpcsclite. */
2016 #ifdef NEED_PCSC_WRAPPER
2017 static int
2018 open_pcsc_reader_wrapped (const char *portstr)
2019 {
2020   int slot;
2021   reader_table_t slotp;
2022   int fd, rp[2], wp[2];
2023   int n, i;
2024   pid_t pid;
2025   size_t len;
2026   unsigned char msgbuf[9];
2027   int err;
2028   unsigned int dummy_status;
2029
2030   /* Note that we use the constant and not the fucntion because this
2031      code won't be be used under Windows.  */
2032   const char *wrapperpgm = GNUPG_LIBEXECDIR "/gnupg-pcsc-wrapper";
2033
2034   if (access (wrapperpgm, X_OK))
2035     {
2036       log_error ("can't run PC/SC access module '%s': %s\n",
2037                  wrapperpgm, strerror (errno));
2038       return -1;
2039     }
2040
2041   slot = new_reader_slot ();
2042   if (slot == -1)
2043     return -1;
2044   slotp = reader_table + slot;
2045
2046   /* Fire up the PC/SCc wrapper.  We don't use any fork/exec code from
2047      the common directy but implement it directly so that this file
2048      may still be source copied. */
2049
2050   if (pipe (rp) == -1)
2051     {
2052       log_error ("error creating a pipe: %s\n", strerror (errno));
2053       slotp->used = 0;
2054       unlock_slot (slot);
2055       return -1;
2056     }
2057   if (pipe (wp) == -1)
2058     {
2059       log_error ("error creating a pipe: %s\n", strerror (errno));
2060       close (rp[0]);
2061       close (rp[1]);
2062       slotp->used = 0;
2063       unlock_slot (slot);
2064       return -1;
2065     }
2066
2067   pid = fork ();
2068   if (pid == -1)
2069     {
2070       log_error ("error forking process: %s\n", strerror (errno));
2071       close (rp[0]);
2072       close (rp[1]);
2073       close (wp[0]);
2074       close (wp[1]);
2075       slotp->used = 0;
2076       unlock_slot (slot);
2077       return -1;
2078     }
2079   slotp->pcsc.pid = pid;
2080
2081   if (!pid)
2082     { /*
2083          === Child ===
2084        */
2085
2086       /* Double fork. */
2087       pid = fork ();
2088       if (pid == -1)
2089         _exit (31);
2090       if (pid)
2091         _exit (0); /* Immediate exit this parent, so that the child
2092                       gets cleaned up by the init process. */
2093
2094       /* Connect our pipes. */
2095       if (wp[0] != 0 && dup2 (wp[0], 0) == -1)
2096         log_fatal ("dup2 stdin failed: %s\n", strerror (errno));
2097       if (rp[1] != 1 && dup2 (rp[1], 1) == -1)
2098         log_fatal ("dup2 stdout failed: %s\n", strerror (errno));
2099
2100       /* Send stderr to the bit bucket. */
2101       fd = open ("/dev/null", O_WRONLY);
2102       if (fd == -1)
2103         log_fatal ("can't open '/dev/null': %s", strerror (errno));
2104       if (fd != 2 && dup2 (fd, 2) == -1)
2105         log_fatal ("dup2 stderr failed: %s\n", strerror (errno));
2106
2107       /* Close all other files. */
2108       close_all_fds (3, NULL);
2109
2110       execl (wrapperpgm,
2111              "pcsc-wrapper",
2112              "--",
2113              "1", /* API version */
2114              opt.pcsc_driver, /* Name of the PC/SC library. */
2115               NULL);
2116       _exit (31);
2117     }
2118
2119   /*
2120      === Parent ===
2121    */
2122   close (wp[0]);
2123   close (rp[1]);
2124   slotp->pcsc.req_fd = wp[1];
2125   slotp->pcsc.rsp_fd = rp[0];
2126
2127   /* Wait for the intermediate child to terminate. */
2128 #ifdef USE_NPTH
2129 #define WAIT npth_waitpid
2130 #else
2131 #define WAIT waitpid
2132 #endif
2133   while ( (i=WAIT (pid, NULL, 0)) == -1 && errno == EINTR)
2134     ;
2135 #undef WAIT
2136
2137   /* Now send the open request. */
2138   msgbuf[0] = 0x01; /* OPEN command. */
2139   len = portstr? strlen (portstr):0;
2140   msgbuf[1] = (len >> 24);
2141   msgbuf[2] = (len >> 16);
2142   msgbuf[3] = (len >>  8);
2143   msgbuf[4] = (len      );
2144   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
2145        || (portstr && writen (slotp->pcsc.req_fd, portstr, len)))
2146     {
2147       log_error ("error sending PC/SC OPEN request: %s\n",
2148                  strerror (errno));
2149       goto command_failed;
2150     }
2151   /* Read the response. */
2152   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
2153     {
2154       log_error ("error receiving PC/SC OPEN response: %s\n",
2155                  i? strerror (errno) : "premature EOF");
2156       goto command_failed;
2157     }
2158   len = buf32_to_size_t (msgbuf+1);
2159   if (msgbuf[0] != 0x81 || len < 4)
2160     {
2161       log_error ("invalid response header from PC/SC received\n");
2162       goto command_failed;
2163     }
2164   len -= 4; /* Already read the error code. */
2165   if (len > DIM (slotp->atr))
2166     {
2167       log_error ("PC/SC returned a too large ATR (len=%lx)\n",
2168                  (unsigned long)len);
2169       goto command_failed;
2170     }
2171   err = PCSC_ERR_MASK (buf32_to_ulong (msgbuf+5));
2172   if (err)
2173     {
2174       log_error ("PC/SC OPEN failed: %s\n", pcsc_error_string (err));
2175       goto command_failed;
2176     }
2177
2178   slotp->last_status = 0;
2179
2180   /* The open request may return a zero for the ATR length to
2181      indicate that no card is present.  */
2182   n = len;
2183   if (n)
2184     {
2185       if ((i=readn (slotp->pcsc.rsp_fd, slotp->atr, n, &len)) || len != n)
2186         {
2187           log_error ("error receiving PC/SC OPEN response: %s\n",
2188                      i? strerror (errno) : "premature EOF");
2189           goto command_failed;
2190         }
2191       /* If we got to here we know that a card is present
2192          and usable.  Thus remember this.  */
2193       slotp->last_status = (  APDU_CARD_USABLE
2194                             | APDU_CARD_PRESENT
2195                             | APDU_CARD_ACTIVE);
2196     }
2197   slotp->atrlen = len;
2198
2199   reader_table[slot].close_reader = close_pcsc_reader;
2200   reader_table[slot].reset_reader = reset_pcsc_reader;
2201   reader_table[slot].get_status_reader = pcsc_get_status;
2202   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
2203   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
2204
2205   pcsc_vendor_specific_init (slot);
2206
2207   /* Read the status so that IS_T0 will be set. */
2208   pcsc_get_status (slot, &dummy_status);
2209
2210   dump_reader_status (slot);
2211   unlock_slot (slot);
2212   return slot;
2213
2214  command_failed:
2215   close (slotp->pcsc.req_fd);
2216   close (slotp->pcsc.rsp_fd);
2217   slotp->pcsc.req_fd = -1;
2218   slotp->pcsc.rsp_fd = -1;
2219   if (slotp->pcsc.pid != -1)
2220     kill (slotp->pcsc.pid, SIGTERM);
2221   slotp->pcsc.pid = (pid_t)(-1);
2222   slotp->used = 0;
2223   unlock_slot (slot);
2224   /* There is no way to return SW. */
2225   return -1;
2226
2227 }
2228 #endif /*NEED_PCSC_WRAPPER*/
2229
2230
2231 static int
2232 open_pcsc_reader (const char *portstr)
2233 {
2234 #ifdef NEED_PCSC_WRAPPER
2235   return open_pcsc_reader_wrapped (portstr);
2236 #else
2237   return open_pcsc_reader_direct (portstr);
2238 #endif
2239 }
2240
2241
2242 /* Check whether the reader supports the ISO command code COMMAND
2243    on the pinpad.  Return 0 on success.  */
2244 static int
2245 check_pcsc_pinpad (int slot, int command, pininfo_t *pininfo)
2246 {
2247   int r;
2248
2249   if (reader_table[slot].pcsc.pinmin >= 0)
2250     pininfo->minlen = reader_table[slot].pcsc.pinmin;
2251
2252   if (reader_table[slot].pcsc.pinmax >= 0)
2253     pininfo->maxlen = reader_table[slot].pcsc.pinmax;
2254
2255   if (!pininfo->minlen)
2256     pininfo->minlen = 1;
2257   if (!pininfo->maxlen)
2258     pininfo->maxlen = 15;
2259
2260   if ((command == ISO7816_VERIFY && reader_table[slot].pcsc.verify_ioctl != 0)
2261       || (command == ISO7816_CHANGE_REFERENCE_DATA
2262           && reader_table[slot].pcsc.modify_ioctl != 0))
2263     r = 0;                       /* Success */
2264   else
2265     r = SW_NOT_SUPPORTED;
2266
2267   if (DBG_CARD_IO)
2268     log_debug ("check_pcsc_pinpad: command=%02X, r=%d\n",
2269                (unsigned int)command, r);
2270
2271   if (reader_table[slot].pinpad_varlen_supported)
2272     pininfo->fixedlen = 0;
2273
2274   return r;
2275 }
2276
2277 #define PIN_VERIFY_STRUCTURE_SIZE 24
2278 static int
2279 pcsc_pinpad_verify (int slot, int class, int ins, int p0, int p1,
2280                     pininfo_t *pininfo)
2281 {
2282   int sw;
2283   unsigned char *pin_verify;
2284   int len = PIN_VERIFY_STRUCTURE_SIZE + pininfo->fixedlen;
2285   unsigned char result[2];
2286   pcsc_dword_t resultlen = 2;
2287   int no_lc;
2288
2289   if (!reader_table[slot].atrlen
2290       && (sw = reset_pcsc_reader (slot)))
2291     return sw;
2292
2293   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2294     return SW_NOT_SUPPORTED;
2295
2296   pin_verify = xtrymalloc (len);
2297   if (!pin_verify)
2298     return SW_HOST_OUT_OF_CORE;
2299
2300   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2301
2302   pin_verify[0] = 0x00; /* bTimeOut */
2303   pin_verify[1] = 0x00; /* bTimeOut2 */
2304   pin_verify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2305   pin_verify[3] = pininfo->fixedlen; /* bmPINBlockString */
2306   pin_verify[4] = 0x00; /* bmPINLengthFormat */
2307   pin_verify[5] = pininfo->maxlen; /* wPINMaxExtraDigit */
2308   pin_verify[6] = pininfo->minlen; /* wPINMaxExtraDigit */
2309   pin_verify[7] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2310   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2311     pin_verify[7] |= 0x01; /* Max size reached.  */
2312   pin_verify[8] = 0x01; /* bNumberMessage: One message */
2313   pin_verify[9] =  0x09; /* wLangId: 0x0409: US English */
2314   pin_verify[10] = 0x04; /* wLangId: 0x0409: US English */
2315   pin_verify[11] = 0x00; /* bMsgIndex */
2316   pin_verify[12] = 0x00; /* bTeoPrologue[0] */
2317   pin_verify[13] = 0x00; /* bTeoPrologue[1] */
2318   pin_verify[14] = pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2319   pin_verify[15] = pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2320   pin_verify[16] = 0x00; /* ulDataLength */
2321   pin_verify[17] = 0x00; /* ulDataLength */
2322   pin_verify[18] = 0x00; /* ulDataLength */
2323   pin_verify[19] = class; /* abData[0] */
2324   pin_verify[20] = ins; /* abData[1] */
2325   pin_verify[21] = p0; /* abData[2] */
2326   pin_verify[22] = p1; /* abData[3] */
2327   pin_verify[23] = pininfo->fixedlen; /* abData[4] */
2328   if (pininfo->fixedlen)
2329     memset (&pin_verify[24], 0xff, pininfo->fixedlen);
2330   else if (no_lc)
2331     len--;
2332
2333   if (DBG_CARD_IO)
2334     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2335                class, ins, p0, p1, len, pininfo->maxlen);
2336
2337   sw = control_pcsc (slot, reader_table[slot].pcsc.verify_ioctl,
2338                      pin_verify, len, result, &resultlen);
2339   xfree (pin_verify);
2340   if (sw || resultlen < 2)
2341     {
2342       log_error ("control_pcsc failed: %d\n", sw);
2343       return sw? sw: SW_HOST_INCOMPLETE_CARD_RESPONSE;
2344     }
2345   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2346   if (DBG_CARD_IO)
2347     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2348   return sw;
2349 }
2350
2351
2352 #define PIN_MODIFY_STRUCTURE_SIZE 29
2353 static int
2354 pcsc_pinpad_modify (int slot, int class, int ins, int p0, int p1,
2355                     pininfo_t *pininfo)
2356 {
2357   int sw;
2358   unsigned char *pin_modify;
2359   int len = PIN_MODIFY_STRUCTURE_SIZE + 2 * pininfo->fixedlen;
2360   unsigned char result[2];
2361   pcsc_dword_t resultlen = 2;
2362   int no_lc;
2363
2364   if (!reader_table[slot].atrlen
2365       && (sw = reset_pcsc_reader (slot)))
2366     return sw;
2367
2368   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2369     return SW_NOT_SUPPORTED;
2370
2371   pin_modify = xtrymalloc (len);
2372   if (!pin_modify)
2373     return SW_HOST_OUT_OF_CORE;
2374
2375   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2376
2377   pin_modify[0] = 0x00; /* bTimeOut */
2378   pin_modify[1] = 0x00; /* bTimeOut2 */
2379   pin_modify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2380   pin_modify[3] = pininfo->fixedlen; /* bmPINBlockString */
2381   pin_modify[4] = 0x00; /* bmPINLengthFormat */
2382   pin_modify[5] = 0x00; /* bInsertionOffsetOld */
2383   pin_modify[6] = pininfo->fixedlen; /* bInsertionOffsetNew */
2384   pin_modify[7] = pininfo->maxlen; /* wPINMaxExtraDigit */
2385   pin_modify[8] = pininfo->minlen; /* wPINMaxExtraDigit */
2386   pin_modify[9] = (p0 == 0 ? 0x03 : 0x01);
2387                   /* bConfirmPIN
2388                    *    0x00: new PIN once
2389                    *    0x01: new PIN twice (confirmation)
2390                    *    0x02: old PIN and new PIN once
2391                    *    0x03: old PIN and new PIN twice (confirmation)
2392                    */
2393   pin_modify[10] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2394   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2395     pin_modify[10] |= 0x01; /* Max size reached.  */
2396   pin_modify[11] = 0x03; /* bNumberMessage: Three messages */
2397   pin_modify[12] = 0x09; /* wLangId: 0x0409: US English */
2398   pin_modify[13] = 0x04; /* wLangId: 0x0409: US English */
2399   pin_modify[14] = 0x00; /* bMsgIndex1 */
2400   pin_modify[15] = 0x01; /* bMsgIndex2 */
2401   pin_modify[16] = 0x02; /* bMsgIndex3 */
2402   pin_modify[17] = 0x00; /* bTeoPrologue[0] */
2403   pin_modify[18] = 0x00; /* bTeoPrologue[1] */
2404   pin_modify[19] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2405   pin_modify[20] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2406   pin_modify[21] = 0x00; /* ulDataLength */
2407   pin_modify[22] = 0x00; /* ulDataLength */
2408   pin_modify[23] = 0x00; /* ulDataLength */
2409   pin_modify[24] = class; /* abData[0] */
2410   pin_modify[25] = ins; /* abData[1] */
2411   pin_modify[26] = p0; /* abData[2] */
2412   pin_modify[27] = p1; /* abData[3] */
2413   pin_modify[28] = 2 * pininfo->fixedlen; /* abData[4] */
2414   if (pininfo->fixedlen)
2415     memset (&pin_modify[29], 0xff, 2 * pininfo->fixedlen);
2416   else if (no_lc)
2417     len--;
2418
2419   if (DBG_CARD_IO)
2420     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2421                class, ins, p0, p1, len, (int)pininfo->maxlen);
2422
2423   sw = control_pcsc (slot, reader_table[slot].pcsc.modify_ioctl,
2424                      pin_modify, len, result, &resultlen);
2425   xfree (pin_modify);
2426   if (sw || resultlen < 2)
2427     {
2428       log_error ("control_pcsc failed: %d\n", sw);
2429       return sw? sw : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2430     }
2431   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2432   if (DBG_CARD_IO)
2433     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2434   return sw;
2435 }
2436 \f
2437 #ifdef HAVE_LIBUSB
2438 /*
2439      Internal CCID driver interface.
2440  */
2441
2442
2443 static void
2444 dump_ccid_reader_status (int slot)
2445 {
2446   log_info ("reader slot %d: using ccid driver\n", slot);
2447 }
2448
2449 static int
2450 close_ccid_reader (int slot)
2451 {
2452   ccid_close_reader (reader_table[slot].ccid.handle);
2453   reader_table[slot].used = 0;
2454   return 0;
2455 }
2456
2457
2458 static int
2459 shutdown_ccid_reader (int slot)
2460 {
2461   ccid_shutdown_reader (reader_table[slot].ccid.handle);
2462   return 0;
2463 }
2464
2465
2466 static int
2467 reset_ccid_reader (int slot)
2468 {
2469   int err;
2470   reader_table_t slotp = reader_table + slot;
2471   unsigned char atr[33];
2472   size_t atrlen;
2473
2474   err = ccid_get_atr (slotp->ccid.handle, atr, sizeof atr, &atrlen);
2475   if (err)
2476     return err;
2477   /* If the reset was successful, update the ATR. */
2478   assert (sizeof slotp->atr >= sizeof atr);
2479   slotp->atrlen = atrlen;
2480   memcpy (slotp->atr, atr, atrlen);
2481   dump_reader_status (slot);
2482   return 0;
2483 }
2484
2485
2486 static int
2487 set_progress_cb_ccid_reader (int slot, gcry_handler_progress_t cb, void *cb_arg)
2488 {
2489   reader_table_t slotp = reader_table + slot;
2490
2491   return ccid_set_progress_cb (slotp->ccid.handle, cb, cb_arg);
2492 }
2493
2494
2495 static int
2496 get_status_ccid (int slot, unsigned int *status)
2497 {
2498   int rc;
2499   int bits;
2500
2501   rc = ccid_slot_status (reader_table[slot].ccid.handle, &bits);
2502   if (rc)
2503     return rc;
2504
2505   if (bits == 0)
2506     *status = (APDU_CARD_USABLE|APDU_CARD_PRESENT|APDU_CARD_ACTIVE);
2507   else if (bits == 1)
2508     *status = APDU_CARD_PRESENT;
2509   else
2510     *status = 0;
2511
2512   return 0;
2513 }
2514
2515
2516 /* Actually send the APDU of length APDULEN to SLOT and return a
2517    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2518    set to BUFLEN.  Returns: Internal CCID driver error code. */
2519 static int
2520 send_apdu_ccid (int slot, unsigned char *apdu, size_t apdulen,
2521                 unsigned char *buffer, size_t *buflen,
2522                 pininfo_t *pininfo)
2523 {
2524   long err;
2525   size_t maxbuflen;
2526
2527   /* If we don't have an ATR, we need to reset the reader first. */
2528   if (!reader_table[slot].atrlen
2529       && (err = reset_ccid_reader (slot)))
2530     return err;
2531
2532   if (DBG_CARD_IO)
2533     log_printhex (" raw apdu:", apdu, apdulen);
2534
2535   maxbuflen = *buflen;
2536   if (pininfo)
2537     err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2538                                   apdu, apdulen, pininfo,
2539                                   buffer, maxbuflen, buflen);
2540   else
2541     err = ccid_transceive (reader_table[slot].ccid.handle,
2542                            apdu, apdulen,
2543                            buffer, maxbuflen, buflen);
2544   if (err)
2545     log_error ("ccid_transceive failed: (0x%lx)\n",
2546                err);
2547
2548   return err;
2549 }
2550
2551
2552 /* Check whether the CCID reader supports the ISO command code COMMAND
2553    on the pinpad.  Return 0 on success.  For a description of the pin
2554    parameters, see ccid-driver.c */
2555 static int
2556 check_ccid_pinpad (int slot, int command, pininfo_t *pininfo)
2557 {
2558   unsigned char apdu[] = { 0, 0, 0, 0x81 };
2559
2560   apdu[1] = command;
2561   return ccid_transceive_secure (reader_table[slot].ccid.handle, apdu,
2562                                  sizeof apdu, pininfo, NULL, 0, NULL);
2563 }
2564
2565
2566 static int
2567 ccid_pinpad_operation (int slot, int class, int ins, int p0, int p1,
2568                        pininfo_t *pininfo)
2569 {
2570   unsigned char apdu[4];
2571   int err, sw;
2572   unsigned char result[2];
2573   size_t resultlen = 2;
2574
2575   apdu[0] = class;
2576   apdu[1] = ins;
2577   apdu[2] = p0;
2578   apdu[3] = p1;
2579   err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2580                                 apdu, sizeof apdu, pininfo,
2581                                 result, 2, &resultlen);
2582   if (err)
2583     return err;
2584
2585   if (resultlen < 2)
2586     return SW_HOST_INCOMPLETE_CARD_RESPONSE;
2587
2588   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2589   return sw;
2590 }
2591
2592
2593 /* Open the reader and try to read an ATR.  */
2594 static int
2595 open_ccid_reader (const char *portstr)
2596 {
2597   int err;
2598   int slot;
2599   reader_table_t slotp;
2600
2601   slot = new_reader_slot ();
2602   if (slot == -1)
2603     return -1;
2604   slotp = reader_table + slot;
2605
2606   err = ccid_open_reader (&slotp->ccid.handle, portstr);
2607   if (err)
2608     {
2609       slotp->used = 0;
2610       unlock_slot (slot);
2611       return -1;
2612     }
2613
2614   err = ccid_get_atr (slotp->ccid.handle,
2615                       slotp->atr, sizeof slotp->atr, &slotp->atrlen);
2616   if (err)
2617     {
2618       slotp->atrlen = 0;
2619       err = 0;
2620     }
2621   else
2622     {
2623       /* If we got to here we know that a card is present
2624          and usable.  Thus remember this.  */
2625       reader_table[slot].last_status = (APDU_CARD_USABLE
2626                                         | APDU_CARD_PRESENT
2627                                         | APDU_CARD_ACTIVE);
2628     }
2629
2630   reader_table[slot].close_reader = close_ccid_reader;
2631   reader_table[slot].shutdown_reader = shutdown_ccid_reader;
2632   reader_table[slot].reset_reader = reset_ccid_reader;
2633   reader_table[slot].get_status_reader = get_status_ccid;
2634   reader_table[slot].send_apdu_reader = send_apdu_ccid;
2635   reader_table[slot].check_pinpad = check_ccid_pinpad;
2636   reader_table[slot].dump_status_reader = dump_ccid_reader_status;
2637   reader_table[slot].set_progress_cb = set_progress_cb_ccid_reader;
2638   reader_table[slot].pinpad_verify = ccid_pinpad_operation;
2639   reader_table[slot].pinpad_modify = ccid_pinpad_operation;
2640   /* Our CCID reader code does not support T=0 at all, thus reset the
2641      flag.  */
2642   reader_table[slot].is_t0 = 0;
2643
2644   dump_reader_status (slot);
2645   unlock_slot (slot);
2646   return slot;
2647 }
2648
2649
2650
2651 #endif /* HAVE_LIBUSB */
2652
2653
2654 \f
2655 #ifdef USE_G10CODE_RAPDU
2656 /*
2657      The Remote APDU Interface.
2658
2659      This uses the Remote APDU protocol to contact a reader.
2660
2661      The port number is actually an index into the list of ports as
2662      returned via the protocol.
2663  */
2664
2665
2666 static int
2667 rapdu_status_to_sw (int status)
2668 {
2669   int rc;
2670
2671   switch (status)
2672     {
2673     case RAPDU_STATUS_SUCCESS:  rc = 0; break;
2674
2675     case RAPDU_STATUS_INVCMD:
2676     case RAPDU_STATUS_INVPROT:
2677     case RAPDU_STATUS_INVSEQ:
2678     case RAPDU_STATUS_INVCOOKIE:
2679     case RAPDU_STATUS_INVREADER:  rc = SW_HOST_INV_VALUE;  break;
2680
2681     case RAPDU_STATUS_TIMEOUT:  rc = SW_HOST_CARD_IO_ERROR; break;
2682     case RAPDU_STATUS_CARDIO:   rc = SW_HOST_CARD_IO_ERROR; break;
2683     case RAPDU_STATUS_NOCARD:   rc = SW_HOST_NO_CARD; break;
2684     case RAPDU_STATUS_CARDCHG:  rc = SW_HOST_NO_CARD; break;
2685     case RAPDU_STATUS_BUSY:     rc = SW_HOST_BUSY; break;
2686     case RAPDU_STATUS_NEEDRESET: rc = SW_HOST_CARD_INACTIVE; break;
2687
2688     default: rc = SW_HOST_GENERAL_ERROR; break;
2689     }
2690
2691   return rc;
2692 }
2693
2694
2695
2696 static int
2697 close_rapdu_reader (int slot)
2698 {
2699   rapdu_release (reader_table[slot].rapdu.handle);
2700   reader_table[slot].used = 0;
2701   return 0;
2702 }
2703
2704
2705 static int
2706 reset_rapdu_reader (int slot)
2707 {
2708   int err;
2709   reader_table_t slotp;
2710   rapdu_msg_t msg = NULL;
2711
2712   slotp = reader_table + slot;
2713
2714   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2715   if (err)
2716     {
2717       log_error ("sending rapdu command RESET failed: %s\n",
2718                 err < 0 ? strerror (errno): rapdu_strerror (err));
2719       rapdu_msg_release (msg);
2720       return rapdu_status_to_sw (err);
2721     }
2722   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2723   if (err)
2724     {
2725       log_error ("receiving rapdu message failed: %s\n",
2726                 err < 0 ? strerror (errno): rapdu_strerror (err));
2727       rapdu_msg_release (msg);
2728       return rapdu_status_to_sw (err);
2729     }
2730   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2731     {
2732       int sw = rapdu_status_to_sw (msg->cmd);
2733       log_error ("rapdu command RESET failed: %s\n",
2734                  rapdu_strerror (msg->cmd));
2735       rapdu_msg_release (msg);
2736       return sw;
2737     }
2738   if (msg->datalen > DIM (slotp->atr))
2739     {
2740       log_error ("ATR returned by the RAPDU layer is too large\n");
2741       rapdu_msg_release (msg);
2742       return SW_HOST_INV_VALUE;
2743     }
2744   slotp->atrlen = msg->datalen;
2745   memcpy (slotp->atr, msg->data, msg->datalen);
2746
2747   rapdu_msg_release (msg);
2748   return 0;
2749 }
2750
2751
2752 static int
2753 my_rapdu_get_status (int slot, unsigned int *status)
2754 {
2755   int err;
2756   reader_table_t slotp;
2757   rapdu_msg_t msg = NULL;
2758   int oldslot;
2759
2760   slotp = reader_table + slot;
2761
2762   oldslot = rapdu_set_reader (slotp->rapdu.handle, slot);
2763   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_STATUS);
2764   rapdu_set_reader (slotp->rapdu.handle, oldslot);
2765   if (err)
2766     {
2767       log_error ("sending rapdu command GET_STATUS failed: %s\n",
2768                 err < 0 ? strerror (errno): rapdu_strerror (err));
2769       return rapdu_status_to_sw (err);
2770     }
2771   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2772   if (err)
2773     {
2774       log_error ("receiving rapdu message failed: %s\n",
2775                 err < 0 ? strerror (errno): rapdu_strerror (err));
2776       rapdu_msg_release (msg);
2777       return rapdu_status_to_sw (err);
2778     }
2779   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2780     {
2781       int sw = rapdu_status_to_sw (msg->cmd);
2782       log_error ("rapdu command GET_STATUS failed: %s\n",
2783                  rapdu_strerror (msg->cmd));
2784       rapdu_msg_release (msg);
2785       return sw;
2786     }
2787   *status = msg->data[0];
2788
2789   rapdu_msg_release (msg);
2790   return 0;
2791 }
2792
2793
2794 /* Actually send the APDU of length APDULEN to SLOT and return a
2795    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2796    set to BUFLEN.  Returns: APDU error code. */
2797 static int
2798 my_rapdu_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
2799                     unsigned char *buffer, size_t *buflen,
2800                     pininfo_t *pininfo)
2801 {
2802   int err;
2803   reader_table_t slotp;
2804   rapdu_msg_t msg = NULL;
2805   size_t maxlen = *buflen;
2806
2807   slotp = reader_table + slot;
2808
2809   *buflen = 0;
2810   if (DBG_CARD_IO)
2811     log_printhex ("  APDU_data:", apdu, apdulen);
2812
2813   if (apdulen < 4)
2814     {
2815       log_error ("rapdu_send_apdu: APDU is too short\n");
2816       return SW_HOST_INV_VALUE;
2817     }
2818
2819   err = rapdu_send_apdu (slotp->rapdu.handle, apdu, apdulen);
2820   if (err)
2821     {
2822       log_error ("sending rapdu command APDU failed: %s\n",
2823                 err < 0 ? strerror (errno): rapdu_strerror (err));
2824       rapdu_msg_release (msg);
2825       return rapdu_status_to_sw (err);
2826     }
2827   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2828   if (err)
2829     {
2830       log_error ("receiving rapdu message failed: %s\n",
2831                 err < 0 ? strerror (errno): rapdu_strerror (err));
2832       rapdu_msg_release (msg);
2833       return rapdu_status_to_sw (err);
2834     }
2835   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2836     {
2837       int sw = rapdu_status_to_sw (msg->cmd);
2838       log_error ("rapdu command APDU failed: %s\n",
2839                  rapdu_strerror (msg->cmd));
2840       rapdu_msg_release (msg);
2841       return sw;
2842     }
2843
2844   if (msg->datalen > maxlen)
2845     {
2846       log_error ("rapdu response apdu too large\n");
2847       rapdu_msg_release (msg);
2848       return SW_HOST_INV_VALUE;
2849     }
2850
2851   *buflen = msg->datalen;
2852   memcpy (buffer, msg->data, msg->datalen);
2853
2854   rapdu_msg_release (msg);
2855   return 0;
2856 }
2857
2858 static int
2859 open_rapdu_reader (int portno,
2860                    const unsigned char *cookie, size_t length,
2861                    int (*readfnc) (void *opaque,
2862                                    void *buffer, size_t size),
2863                    void *readfnc_value,
2864                    int (*writefnc) (void *opaque,
2865                                     const void *buffer, size_t size),
2866                    void *writefnc_value,
2867                    void (*closefnc) (void *opaque),
2868                    void *closefnc_value)
2869 {
2870   int err;
2871   int slot;
2872   reader_table_t slotp;
2873   rapdu_msg_t msg = NULL;
2874
2875   slot = new_reader_slot ();
2876   if (slot == -1)
2877     return -1;
2878   slotp = reader_table + slot;
2879
2880   slotp->rapdu.handle = rapdu_new ();
2881   if (!slotp->rapdu.handle)
2882     {
2883       slotp->used = 0;
2884       unlock_slot (slot);
2885       return -1;
2886     }
2887
2888   rapdu_set_reader (slotp->rapdu.handle, portno);
2889
2890   rapdu_set_iofunc (slotp->rapdu.handle,
2891                     readfnc, readfnc_value,
2892                     writefnc, writefnc_value,
2893                     closefnc, closefnc_value);
2894   rapdu_set_cookie (slotp->rapdu.handle, cookie, length);
2895
2896   /* First try to get the current ATR, but if the card is inactive
2897      issue a reset instead.  */
2898   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_ATR);
2899   if (err == RAPDU_STATUS_NEEDRESET)
2900     err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2901   if (err)
2902     {
2903       log_info ("sending rapdu command GET_ATR/RESET failed: %s\n",
2904                 err < 0 ? strerror (errno): rapdu_strerror (err));
2905       goto failure;
2906     }
2907   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2908   if (err)
2909     {
2910       log_info ("receiving rapdu message failed: %s\n",
2911                 err < 0 ? strerror (errno): rapdu_strerror (err));
2912       goto failure;
2913     }
2914   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2915     {
2916       log_info ("rapdu command GET ATR failed: %s\n",
2917                  rapdu_strerror (msg->cmd));
2918       goto failure;
2919     }
2920   if (msg->datalen > DIM (slotp->atr))
2921     {
2922       log_error ("ATR returned by the RAPDU layer is too large\n");
2923       goto failure;
2924     }
2925   slotp->atrlen = msg->datalen;
2926   memcpy (slotp->atr, msg->data, msg->datalen);
2927
2928   reader_table[slot].close_reader = close_rapdu_reader;
2929   reader_table[slot].reset_reader = reset_rapdu_reader;
2930   reader_table[slot].get_status_reader = my_rapdu_get_status;
2931   reader_table[slot].send_apdu_reader = my_rapdu_send_apdu;
2932   reader_table[slot].check_pinpad = NULL;
2933   reader_table[slot].dump_status_reader = NULL;
2934   reader_table[slot].pinpad_verify = NULL;
2935   reader_table[slot].pinpad_modify = NULL;
2936
2937   dump_reader_status (slot);
2938   rapdu_msg_release (msg);
2939   unlock_slot (slot);
2940   return slot;
2941
2942  failure:
2943   rapdu_msg_release (msg);
2944   rapdu_release (slotp->rapdu.handle);
2945   slotp->used = 0;
2946   unlock_slot (slot);
2947   return -1;
2948 }
2949
2950 #endif /*USE_G10CODE_RAPDU*/
2951
2952
2953 \f
2954 /*
2955        Driver Access
2956  */
2957
2958
2959 /* Open the reader and return an internal slot number or -1 on
2960    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
2961    the first USB reader.  For PC/SC the first listed reader). */
2962 int
2963 apdu_open_reader (const char *portstr)
2964 {
2965   static int pcsc_api_loaded, ct_api_loaded;
2966   int slot;
2967
2968   if (DBG_READER)
2969     log_debug ("enter: apdu_open_reader: portstr=%s\n", portstr);
2970
2971 #ifdef HAVE_LIBUSB
2972   if (!opt.disable_ccid)
2973     {
2974       static int once_available;
2975       int i;
2976       const char *s;
2977
2978       slot = open_ccid_reader (portstr);
2979       if (slot != -1)
2980         {
2981           once_available = 1;
2982           if (DBG_READER)
2983             log_debug ("leave: apdu_open_reader => slot=%d [ccid]\n", slot);
2984           return slot; /* got one */
2985         }
2986
2987       /* If we ever loaded successfully loaded a CCID reader we never
2988          want to fallback to another driver.  This solves a problem
2989          where ccid was used, the card unplugged and then scdaemon
2990          tries to find a new reader and will eventually try PC/SC over
2991          and over again.  To reset this flag "gpgconf --kill scdaemon"
2992          can be used.  */
2993       if (once_available)
2994         {
2995           if (DBG_READER)
2996             log_debug ("leave: apdu_open_reader => slot=-1 (once_avail)\n");
2997           return -1;
2998         }
2999
3000       /* If a CCID reader specification has been given, the user does
3001          not want a fallback to other drivers. */
3002       if (portstr)
3003         for (s=portstr, i=0; *s; s++)
3004           if (*s == ':' && (++i == 3))
3005             {
3006               if (DBG_READER)
3007                 log_debug ("leave: apdu_open_reader => slot=-1 (no ccid)\n");
3008               return -1;
3009             }
3010     }
3011
3012 #endif /* HAVE_LIBUSB */
3013
3014   if (opt.ctapi_driver && *opt.ctapi_driver)
3015     {
3016       int port = portstr? atoi (portstr) : 32768;
3017
3018       if (!ct_api_loaded)
3019         {
3020           void *handle;
3021
3022           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
3023           if (!handle)
3024             {
3025               log_error ("apdu_open_reader: failed to open driver: %s\n",
3026                          dlerror ());
3027               return -1;
3028             }
3029           CT_init = dlsym (handle, "CT_init");
3030           CT_data = dlsym (handle, "CT_data");
3031           CT_close = dlsym (handle, "CT_close");
3032           if (!CT_init || !CT_data || !CT_close)
3033             {
3034               log_error ("apdu_open_reader: invalid CT-API driver\n");
3035               dlclose (handle);
3036               return -1;
3037             }
3038           ct_api_loaded = 1;
3039         }
3040       return open_ct_reader (port);
3041     }
3042
3043
3044   /* No ctAPI configured, so lets try the PC/SC API */
3045   if (!pcsc_api_loaded)
3046     {
3047 #ifndef NEED_PCSC_WRAPPER
3048       void *handle;
3049
3050       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
3051       if (!handle)
3052         {
3053           log_error ("apdu_open_reader: failed to open driver '%s': %s\n",
3054                      opt.pcsc_driver, dlerror ());
3055           return -1;
3056         }
3057
3058       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
3059       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
3060       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
3061 #if defined(_WIN32) || defined(__CYGWIN__)
3062       if (!pcsc_list_readers)
3063         pcsc_list_readers    = dlsym (handle, "SCardListReadersA");
3064 #endif
3065       pcsc_get_status_change = dlsym (handle, "SCardGetStatusChange");
3066 #if defined(_WIN32) || defined(__CYGWIN__)
3067       if (!pcsc_get_status_change)
3068         pcsc_get_status_change = dlsym (handle, "SCardGetStatusChangeA");
3069 #endif
3070       pcsc_connect           = dlsym (handle, "SCardConnect");
3071 #if defined(_WIN32) || defined(__CYGWIN__)
3072       if (!pcsc_connect)
3073         pcsc_connect         = dlsym (handle, "SCardConnectA");
3074 #endif
3075       pcsc_reconnect         = dlsym (handle, "SCardReconnect");
3076 #if defined(_WIN32) || defined(__CYGWIN__)
3077       if (!pcsc_reconnect)
3078         pcsc_reconnect       = dlsym (handle, "SCardReconnectA");
3079 #endif
3080       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
3081       pcsc_status            = dlsym (handle, "SCardStatus");
3082 #if defined(_WIN32) || defined(__CYGWIN__)
3083       if (!pcsc_status)
3084         pcsc_status          = dlsym (handle, "SCardStatusA");
3085 #endif
3086       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
3087       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
3088       pcsc_transmit          = dlsym (handle, "SCardTransmit");
3089       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
3090       pcsc_control           = dlsym (handle, "SCardControl");
3091
3092       if (!pcsc_establish_context
3093           || !pcsc_release_context
3094           || !pcsc_list_readers
3095           || !pcsc_get_status_change
3096           || !pcsc_connect
3097           || !pcsc_reconnect
3098           || !pcsc_disconnect
3099           || !pcsc_status
3100           || !pcsc_begin_transaction
3101           || !pcsc_end_transaction
3102           || !pcsc_transmit
3103           || !pcsc_control
3104           /* || !pcsc_set_timeout */)
3105         {
3106           /* Note that set_timeout is currently not used and also not
3107              available under Windows. */
3108           log_error ("apdu_open_reader: invalid PC/SC driver "
3109                      "(%d%d%d%d%d%d%d%d%d%d%d%d%d)\n",
3110                      !!pcsc_establish_context,
3111                      !!pcsc_release_context,
3112                      !!pcsc_list_readers,
3113                      !!pcsc_get_status_change,
3114                      !!pcsc_connect,
3115                      !!pcsc_reconnect,
3116                      !!pcsc_disconnect,
3117                      !!pcsc_status,
3118                      !!pcsc_begin_transaction,
3119                      !!pcsc_end_transaction,
3120                      !!pcsc_transmit,
3121                      !!pcsc_set_timeout,
3122                      !!pcsc_control );
3123           dlclose (handle);
3124           return -1;
3125         }
3126 #endif /*!NEED_PCSC_WRAPPER*/
3127       pcsc_api_loaded = 1;
3128     }
3129
3130   slot = open_pcsc_reader (portstr);
3131
3132   if (DBG_READER)
3133     log_debug ("leave: apdu_open_reader => slot=%d [pc/sc]\n", slot);
3134   return slot;
3135 }
3136
3137
3138 /* Open an remote reader and return an internal slot number or -1 on
3139    error. This function is an alternative to apdu_open_reader and used
3140    with remote readers only.  Note that the supplied CLOSEFNC will
3141    only be called once and the slot will not be valid afther this.
3142
3143    If PORTSTR is NULL we default to the first availabe port.
3144 */
3145 int
3146 apdu_open_remote_reader (const char *portstr,
3147                          const unsigned char *cookie, size_t length,
3148                          int (*readfnc) (void *opaque,
3149                                          void *buffer, size_t size),
3150                          void *readfnc_value,
3151                          int (*writefnc) (void *opaque,
3152                                           const void *buffer, size_t size),
3153                          void *writefnc_value,
3154                          void (*closefnc) (void *opaque),
3155                          void *closefnc_value)
3156 {
3157 #ifdef USE_G10CODE_RAPDU
3158   return open_rapdu_reader (portstr? atoi (portstr) : 0,
3159                             cookie, length,
3160                             readfnc, readfnc_value,
3161                             writefnc, writefnc_value,
3162                             closefnc, closefnc_value);
3163 #else
3164   (void)portstr;
3165   (void)cookie;
3166   (void)length;
3167   (void)readfnc;
3168   (void)readfnc_value;
3169   (void)writefnc;
3170   (void)writefnc_value;
3171   (void)closefnc;
3172   (void)closefnc_value;
3173 #ifdef _WIN32
3174   errno = ENOENT;
3175 #else
3176   errno = ENOSYS;
3177 #endif
3178   return -1;
3179 #endif
3180 }
3181
3182
3183 int
3184 apdu_close_reader (int slot)
3185 {
3186   int sw;
3187
3188   if (DBG_READER)
3189     log_debug ("enter: apdu_close_reader: slot=%d\n", slot);
3190
3191   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3192     {
3193       if (DBG_READER)
3194         log_debug ("leave: apdu_close_reader => SW_HOST_NO_DRIVER\n");
3195       return SW_HOST_NO_DRIVER;
3196     }
3197   sw = apdu_disconnect (slot);
3198   if (sw)
3199     {
3200       if (DBG_READER)
3201         log_debug ("leave: apdu_close_reader => 0x%x (apdu_disconnect)\n", sw);
3202       return sw;
3203     }
3204   if (reader_table[slot].close_reader)
3205     {
3206       sw = reader_table[slot].close_reader (slot);
3207       if (DBG_READER)
3208         log_debug ("leave: apdu_close_reader => 0x%x (close_reader)\n", sw);
3209       return sw;
3210     }
3211   if (DBG_READER)
3212     log_debug ("leave: apdu_close_reader => SW_HOST_NOT_SUPPORTED\n");
3213   return SW_HOST_NOT_SUPPORTED;
3214 }
3215
3216
3217 /* Function suitable for a cleanup function to close all reader.  It
3218    should not be used if the reader will be opened again.  The reason
3219    for implementing this to properly close USB devices so that they
3220    will startup the next time without error. */
3221 void
3222 apdu_prepare_exit (void)
3223 {
3224   static int sentinel;
3225   int slot;
3226
3227   if (!sentinel)
3228     {
3229       sentinel = 1;
3230       for (slot = 0; slot < MAX_READER; slot++)
3231         if (reader_table[slot].used)
3232           {
3233             apdu_disconnect (slot);
3234             if (reader_table[slot].close_reader)
3235               reader_table[slot].close_reader (slot);
3236             reader_table[slot].used = 0;
3237           }
3238       sentinel = 0;
3239     }
3240 }
3241
3242
3243 /* Shutdown a reader; that is basically the same as a close but keeps
3244    the handle ready for later use. A apdu_reset_reader or apdu_connect
3245    should be used to get it active again. */
3246 int
3247 apdu_shutdown_reader (int slot)
3248 {
3249   int sw;
3250
3251   if (DBG_READER)
3252     log_debug ("enter: apdu_shutdown_reader: slot=%d\n", slot);
3253
3254   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3255     {
3256       if (DBG_READER)
3257         log_debug ("leave: apdu_shutdown_reader => SW_HOST_NO_DRIVER\n");
3258       return SW_HOST_NO_DRIVER;
3259     }
3260   sw = apdu_disconnect (slot);
3261   if (sw)
3262     {
3263       if (DBG_READER)
3264         log_debug ("leave: apdu_shutdown_reader => 0x%x (apdu_disconnect)\n",
3265                    sw);
3266       return sw;
3267     }
3268   if (reader_table[slot].shutdown_reader)
3269     {
3270       sw = reader_table[slot].shutdown_reader (slot);
3271       if (DBG_READER)
3272         log_debug ("leave: apdu_shutdown_reader => 0x%x (close_reader)\n", sw);
3273       return sw;
3274     }
3275   if (DBG_READER)
3276     log_debug ("leave: apdu_shutdown_reader => SW_HOST_NOT_SUPPORTED\n");
3277   return SW_HOST_NOT_SUPPORTED;
3278 }
3279
3280 /* Enumerate all readers and return information on whether this reader
3281    is in use.  The caller should start with SLOT set to 0 and
3282    increment it with each call until an error is returned. */
3283 int
3284 apdu_enum_reader (int slot, int *used)
3285 {
3286   if (slot < 0 || slot >= MAX_READER)
3287     return SW_HOST_NO_DRIVER;
3288   *used = reader_table[slot].used;
3289   return 0;
3290 }
3291
3292
3293 /* Connect a card.  This is used to power up the card and make sure
3294    that an ATR is available.  Depending on the reader backend it may
3295    return an error for an inactive card or if no card is
3296    available.  */
3297 int
3298 apdu_connect (int slot)
3299 {
3300   int sw;
3301   unsigned int status;
3302
3303   if (DBG_READER)
3304     log_debug ("enter: apdu_connect: slot=%d\n", slot);
3305
3306   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3307     {
3308       if (DBG_READER)
3309         log_debug ("leave: apdu_connect => SW_HOST_NO_DRIVER\n");
3310       return SW_HOST_NO_DRIVER;
3311     }
3312
3313   /* Only if the access method provides a connect function we use it.
3314      If not, we expect that the card has been implicitly connected by
3315      apdu_open_reader.  */
3316   if (reader_table[slot].connect_card)
3317     {
3318       sw = lock_slot (slot);
3319       if (!sw)
3320         {
3321           sw = reader_table[slot].connect_card (slot);
3322           unlock_slot (slot);
3323         }
3324     }
3325   else
3326     sw = 0;
3327
3328   /* We need to call apdu_get_status_internal, so that the last-status
3329      machinery gets setup properly even if a card is inserted while
3330      scdaemon is fired up and apdu_get_status has not yet been called.
3331      Without that we would force a reset of the card with the next
3332      call to apdu_get_status.  */
3333   apdu_get_status_internal (slot, 1, 1, &status, NULL);
3334   if (sw)
3335     ;
3336   else if (!(status & APDU_CARD_PRESENT))
3337     sw = SW_HOST_NO_CARD;
3338   else if ((status & APDU_CARD_PRESENT) && !(status & APDU_CARD_ACTIVE))
3339     sw = SW_HOST_CARD_INACTIVE;
3340
3341   if (DBG_READER)
3342     log_debug ("leave: apdu_connect => sw=0x%x\n", sw);
3343
3344   return sw;
3345 }
3346
3347
3348 int
3349 apdu_disconnect (int slot)
3350 {
3351   int sw;
3352
3353   if (DBG_READER)
3354     log_debug ("enter: apdu_disconnect: slot=%d\n", slot);
3355
3356   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3357     {
3358       if (DBG_READER)
3359         log_debug ("leave: apdu_disconnect => SW_HOST_NO_DRIVER\n");
3360       return SW_HOST_NO_DRIVER;
3361     }
3362
3363   if (reader_table[slot].disconnect_card)
3364     {
3365       sw = lock_slot (slot);
3366       if (!sw)
3367         {
3368           sw = reader_table[slot].disconnect_card (slot);
3369           unlock_slot (slot);
3370         }
3371     }
3372   else
3373     sw = 0;
3374
3375   if (DBG_READER)
3376     log_debug ("leave: apdu_disconnect => sw=0x%x\n", sw);
3377   return sw;
3378 }
3379
3380
3381 /* Set the progress callback of SLOT to CB and its args to CB_ARG.  If
3382    CB is NULL the progress callback is removed.  */
3383 int
3384 apdu_set_progress_cb (int slot, gcry_handler_progress_t cb, void *cb_arg)
3385 {
3386   int sw;
3387
3388   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3389     return SW_HOST_NO_DRIVER;
3390
3391   if (reader_table[slot].set_progress_cb)
3392     {
3393       sw = lock_slot (slot);
3394       if (!sw)
3395         {
3396           sw = reader_table[slot].set_progress_cb (slot, cb, cb_arg);
3397           unlock_slot (slot);
3398         }
3399     }
3400   else
3401     sw = 0;
3402   return sw;
3403 }
3404
3405
3406 /* Do a reset for the card in reader at SLOT. */
3407 int
3408 apdu_reset (int slot)
3409 {
3410   int sw;
3411
3412   if (DBG_READER)
3413     log_debug ("enter: apdu_reset: slot=%d\n", slot);
3414
3415   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3416     {
3417       if (DBG_READER)
3418         log_debug ("leave: apdu_reset => SW_HOST_NO_DRIVER\n");
3419       return SW_HOST_NO_DRIVER;
3420     }
3421
3422   if ((sw = lock_slot (slot)))
3423     {
3424       if (DBG_READER)
3425         log_debug ("leave: apdu_reset => sw=0x%x (lock_slot)\n", sw);
3426       return sw;
3427     }
3428
3429   reader_table[slot].last_status = 0;
3430   if (reader_table[slot].reset_reader)
3431     sw = reader_table[slot].reset_reader (slot);
3432
3433   if (!sw)
3434     {
3435       /* If we got to here we know that a card is present
3436          and usable.  Thus remember this.  */
3437       reader_table[slot].last_status = (APDU_CARD_USABLE
3438                                         | APDU_CARD_PRESENT
3439                                         | APDU_CARD_ACTIVE);
3440     }
3441
3442   unlock_slot (slot);
3443   if (DBG_READER)
3444     log_debug ("leave: apdu_reset => sw=0x%x\n", sw);
3445   return sw;
3446 }
3447
3448
3449 /* Return the ATR or NULL if none is available.  On success the length
3450    of the ATR is stored at ATRLEN.  The caller must free the returned
3451    value.  */
3452 unsigned char *
3453 apdu_get_atr (int slot, size_t *atrlen)
3454 {
3455   unsigned char *buf;
3456
3457   if (DBG_READER)
3458     log_debug ("enter: apdu_get_atr: slot=%d\n", slot);
3459
3460   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3461     {
3462       if (DBG_READER)
3463         log_debug ("leave: apdu_get_atr => NULL (bad slot)\n");
3464       return NULL;
3465     }
3466   if (!reader_table[slot].atrlen)
3467     {
3468       if (DBG_READER)
3469         log_debug ("leave: apdu_get_atr => NULL (no ATR)\n");
3470       return NULL;
3471     }
3472
3473   buf = xtrymalloc (reader_table[slot].atrlen);
3474   if (!buf)
3475     {
3476       if (DBG_READER)
3477         log_debug ("leave: apdu_get_atr => NULL (out of core)\n");
3478       return NULL;
3479     }
3480   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
3481   *atrlen = reader_table[slot].atrlen;
3482   if (DBG_READER)
3483     log_debug ("leave: apdu_get_atr => atrlen=%zu\n", *atrlen);
3484   return buf;
3485 }
3486
3487
3488
3489 /* Retrieve the status for SLOT. The function does only wait for the
3490    card to become available if HANG is set to true. On success the
3491    bits in STATUS will be set to
3492
3493      APDU_CARD_USABLE  (bit 0) = card present and usable
3494      APDU_CARD_PRESENT (bit 1) = card present
3495      APDU_CARD_ACTIVE  (bit 2) = card active
3496                        (bit 3) = card access locked [not yet implemented]
3497
3498    For must applications, testing bit 0 is sufficient.
3499
3500    CHANGED will receive the value of the counter tracking the number
3501    of card insertions.  This value may be used to detect a card
3502    change.
3503 */
3504 static int
3505 apdu_get_status_internal (int slot, int hang, int no_atr_reset,
3506                           unsigned int *status, unsigned int *changed)
3507 {
3508   int sw;
3509   unsigned int s;
3510
3511   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3512     return SW_HOST_NO_DRIVER;
3513
3514   if ((sw = hang? lock_slot (slot) : trylock_slot (slot)))
3515     return sw;
3516
3517   if (reader_table[slot].get_status_reader)
3518     sw = reader_table[slot].get_status_reader (slot, &s);
3519
3520   unlock_slot (slot);
3521
3522   if (sw)
3523     {
3524       reader_table[slot].last_status = 0;
3525       return sw;
3526     }
3527
3528   /* Keep track of changes.  */
3529   if (s != reader_table[slot].last_status
3530       || !reader_table[slot].any_status )
3531     {
3532       reader_table[slot].change_counter++;
3533       /* Make sure that the ATR is invalid so that a reset will be
3534          triggered by apdu_activate.  */
3535       if (!no_atr_reset)
3536         reader_table[slot].atrlen = 0;
3537     }
3538   reader_table[slot].any_status = 1;
3539   reader_table[slot].last_status = s;
3540
3541   if (status)
3542     *status = s;
3543   if (changed)
3544     *changed = reader_table[slot].change_counter;
3545   return 0;
3546 }
3547
3548
3549 /* See above for a description.  */
3550 int
3551 apdu_get_status (int slot, int hang,
3552                  unsigned int *status, unsigned int *changed)
3553 {
3554   int sw;
3555
3556   if (DBG_READER)
3557     log_debug ("enter: apdu_get_status: slot=%d hang=%d\n", slot, hang);
3558   sw = apdu_get_status_internal (slot, hang, 0, status, changed);
3559   if (DBG_READER)
3560     {
3561       if (status && changed)
3562         log_debug ("leave: apdu_get_status => sw=0x%x status=%u changecnt=%u\n",
3563                    sw, *status, *changed);
3564       else if (status)
3565         log_debug ("leave: apdu_get_status => sw=0x%x status=%u\n",
3566                    sw, *status);
3567       else if (changed)
3568         log_debug ("leave: apdu_get_status => sw=0x%x changed=%u\n",
3569                    sw, *changed);
3570       else
3571         log_debug ("leave: apdu_get_status => sw=0x%x\n", sw);
3572     }
3573   return sw;
3574 }
3575
3576
3577 /* Check whether the reader supports the ISO command code COMMAND on
3578    the pinpad.  Return 0 on success.  For a description of the pin
3579    parameters, see ccid-driver.c */
3580 int
3581 apdu_check_pinpad (int slot, int command, pininfo_t *pininfo)
3582 {
3583   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3584     return SW_HOST_NO_DRIVER;
3585
3586   if (opt.enable_pinpad_varlen)
3587     pininfo->fixedlen = 0;
3588
3589   if (reader_table[slot].check_pinpad)
3590     {
3591       int sw;
3592
3593       if ((sw = lock_slot (slot)))
3594         return sw;
3595
3596       sw = reader_table[slot].check_pinpad (slot, command, pininfo);
3597       unlock_slot (slot);
3598       return sw;
3599     }
3600   else
3601     return SW_HOST_NOT_SUPPORTED;
3602 }
3603
3604
3605 int
3606 apdu_pinpad_verify (int slot, int class, int ins, int p0, int p1,
3607                     pininfo_t *pininfo)
3608 {
3609   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3610     return SW_HOST_NO_DRIVER;
3611
3612   if (reader_table[slot].pinpad_verify)
3613     {
3614       int sw;
3615
3616       if ((sw = lock_slot (slot)))
3617         return sw;
3618
3619       sw = reader_table[slot].pinpad_verify (slot, class, ins, p0, p1,
3620                                              pininfo);
3621       unlock_slot (slot);
3622       return sw;
3623     }
3624   else
3625     return SW_HOST_NOT_SUPPORTED;
3626 }
3627
3628
3629 int
3630 apdu_pinpad_modify (int slot, int class, int ins, int p0, int p1,
3631                     pininfo_t *pininfo)
3632 {
3633   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3634     return SW_HOST_NO_DRIVER;
3635
3636   if (reader_table[slot].pinpad_modify)
3637     {
3638       int sw;
3639
3640       if ((sw = lock_slot (slot)))
3641         return sw;
3642
3643       sw = reader_table[slot].pinpad_modify (slot, class, ins, p0, p1,
3644                                              pininfo);
3645       unlock_slot (slot);
3646       return sw;
3647     }
3648   else
3649     return SW_HOST_NOT_SUPPORTED;
3650 }
3651
3652
3653 /* Dispatcher for the actual send_apdu function. Note, that this
3654    function should be called in locked state. */
3655 static int
3656 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
3657            unsigned char *buffer, size_t *buflen, pininfo_t *pininfo)
3658 {
3659   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3660     return SW_HOST_NO_DRIVER;
3661
3662   if (reader_table[slot].send_apdu_reader)
3663     return reader_table[slot].send_apdu_reader (slot,
3664                                                 apdu, apdulen,
3665                                                 buffer, buflen,
3666                                                 pininfo);
3667   else
3668     return SW_HOST_NOT_SUPPORTED;
3669 }
3670
3671
3672 /* Core APDU tranceiver function. Parameters are described at
3673    apdu_send_le with the exception of PININFO which indicates pinpad
3674    related operations if not NULL.  If EXTENDED_MODE is not 0
3675    command chaining or extended length will be used according to these
3676    values:
3677        n < 0 := Use command chaining with the data part limited to -n
3678                 in each chunk.  If -1 is used a default value is used.
3679       n == 0 := No extended mode or command chaining.
3680       n == 1 := Use extended length for input and output without a
3681                 length limit.
3682        n > 1 := Use extended length with up to N bytes.
3683
3684 */
3685 static int
3686 send_le (int slot, int class, int ins, int p0, int p1,
3687          int lc, const char *data, int le,
3688          unsigned char **retbuf, size_t *retbuflen,
3689          pininfo_t *pininfo, int extended_mode)
3690 {
3691 #define SHORT_RESULT_BUFFER_SIZE 258
3692   /* We allocate 8 extra bytes as a safety margin towards a driver bug.  */
3693   unsigned char short_result_buffer[SHORT_RESULT_BUFFER_SIZE+10];
3694   unsigned char *result_buffer = NULL;
3695   size_t result_buffer_size;
3696   unsigned char *result;
3697   size_t resultlen;
3698   unsigned char short_apdu_buffer[5+256+1];
3699   unsigned char *apdu_buffer = NULL;
3700   size_t apdu_buffer_size;
3701   unsigned char *apdu;
3702   size_t apdulen;
3703   int sw;
3704   long rc; /* We need a long here due to PC/SC. */
3705   int did_exact_length_hack = 0;
3706   int use_chaining = 0;
3707   int use_extended_length = 0;
3708   int lc_chunk;
3709
3710   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3711     return SW_HOST_NO_DRIVER;
3712
3713   if (DBG_CARD_IO)
3714     log_debug ("send apdu: c=%02X i=%02X p1=%02X p2=%02X lc=%d le=%d em=%d\n",
3715                class, ins, p0, p1, lc, le, extended_mode);
3716
3717   if (lc != -1 && (lc > 255 || lc < 0))
3718     {
3719       /* Data does not fit into an APDU.  What we do now depends on
3720          the EXTENDED_MODE parameter.  */
3721       if (!extended_mode)
3722         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
3723       else if (extended_mode > 0)
3724         use_extended_length = 1;
3725       else if (extended_mode < 0)
3726         {
3727           /* Send APDU using chaining mode.  */
3728           if (lc > 16384)
3729             return SW_WRONG_LENGTH;   /* Sanity check.  */
3730           if ((class&0xf0) != 0)
3731             return SW_HOST_INV_VALUE; /* Upper 4 bits need to be 0.  */
3732           use_chaining = extended_mode == -1? 255 : -extended_mode;
3733           use_chaining &= 0xff;
3734         }
3735       else
3736         return SW_HOST_INV_VALUE;
3737     }
3738   else if (lc == -1 && extended_mode > 0)
3739     use_extended_length = 1;
3740
3741   if (le != -1 && (le > (extended_mode > 0? 255:256) || le < 0))
3742     {
3743       /* Expected Data does not fit into an APDU.  What we do now
3744          depends on the EXTENDED_MODE parameter.  Note that a check
3745          for command chaining does not make sense because we are
3746          looking at Le.  */
3747       if (!extended_mode)
3748         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
3749       else if (use_extended_length)
3750         ; /* We are already using extended length.  */
3751       else if (extended_mode > 0)
3752         use_extended_length = 1;
3753       else
3754         return SW_HOST_INV_VALUE;
3755     }
3756
3757   if ((!data && lc != -1) || (data && lc == -1))
3758     return SW_HOST_INV_VALUE;
3759
3760   if (use_extended_length)
3761     {
3762       if (reader_table[slot].is_t0)
3763         return SW_HOST_NOT_SUPPORTED;
3764
3765       /* Space for: cls/ins/p1/p2+Z+2_byte_Lc+Lc+2_byte_Le.  */
3766       apdu_buffer_size = 4 + 1 + (lc >= 0? (2+lc):0) + 2;
3767       apdu_buffer = xtrymalloc (apdu_buffer_size + 10);
3768       if (!apdu_buffer)
3769         return SW_HOST_OUT_OF_CORE;
3770       apdu = apdu_buffer;
3771     }
3772   else
3773     {
3774       apdu_buffer_size = sizeof short_apdu_buffer;
3775       apdu = short_apdu_buffer;
3776     }
3777
3778   if (use_extended_length && (le > 256 || le < 0))
3779     {
3780       result_buffer_size = le < 0? 4096 : le;
3781       result_buffer = xtrymalloc (result_buffer_size + 10);
3782       if (!result_buffer)
3783         {
3784           xfree (apdu_buffer);
3785           return SW_HOST_OUT_OF_CORE;
3786         }
3787       result = result_buffer;
3788     }
3789   else
3790     {
3791       result_buffer_size = SHORT_RESULT_BUFFER_SIZE;
3792       result = short_result_buffer;
3793     }
3794 #undef SHORT_RESULT_BUFFER_SIZE
3795
3796   if ((sw = lock_slot (slot)))
3797     {
3798       xfree (apdu_buffer);
3799       xfree (result_buffer);
3800       return sw;
3801     }
3802
3803   do
3804     {
3805       if (use_extended_length)
3806         {
3807           use_chaining = 0;
3808           apdulen = 0;
3809           apdu[apdulen++] = class;
3810           apdu[apdulen++] = ins;
3811           apdu[apdulen++] = p0;
3812           apdu[apdulen++] = p1;
3813           if (lc > 0)
3814             {
3815               apdu[apdulen++] = 0;  /* Z byte: Extended length marker.  */
3816               apdu[apdulen++] = ((lc >> 8) & 0xff);
3817               apdu[apdulen++] = (lc & 0xff);
3818               memcpy (apdu+apdulen, data, lc);
3819               data += lc;
3820               apdulen += lc;
3821             }
3822           if (le != -1)
3823             {
3824               if (lc <= 0)
3825                 apdu[apdulen++] = 0;  /* Z byte: Extended length marker.  */
3826               apdu[apdulen++] = ((le >> 8) & 0xff);
3827               apdu[apdulen++] = (le & 0xff);
3828             }
3829         }
3830       else
3831         {
3832           apdulen = 0;
3833           apdu[apdulen] = class;
3834           if (use_chaining && lc > 255)
3835             {
3836               apdu[apdulen] |= 0x10;
3837               assert (use_chaining < 256);
3838               lc_chunk = use_chaining;
3839               lc -= use_chaining;
3840             }
3841           else
3842             {
3843               use_chaining = 0;
3844               lc_chunk = lc;
3845             }
3846           apdulen++;
3847           apdu[apdulen++] = ins;
3848           apdu[apdulen++] = p0;
3849           apdu[apdulen++] = p1;
3850           if (lc_chunk != -1)
3851             {
3852               apdu[apdulen++] = lc_chunk;
3853               memcpy (apdu+apdulen, data, lc_chunk);
3854               data += lc_chunk;
3855               apdulen += lc_chunk;
3856               /* T=0 does not allow the use of Lc together with Le;
3857                  thus disable Le in this case.  */
3858               if (reader_table[slot].is_t0)
3859                 le = -1;
3860             }
3861           if (le != -1 && !use_chaining)
3862             apdu[apdulen++] = le; /* Truncation is okay (0 means 256). */
3863         }
3864
3865     exact_length_hack:
3866       /* As a safeguard don't pass any garbage to the driver.  */
3867       assert (apdulen <= apdu_buffer_size);
3868       memset (apdu+apdulen, 0, apdu_buffer_size - apdulen);
3869       resultlen = result_buffer_size;
3870       rc = send_apdu (slot, apdu, apdulen, result, &resultlen, pininfo);
3871       if (rc || resultlen < 2)
3872         {
3873           log_info ("apdu_send_simple(%d) failed: %s\n",
3874                     slot, apdu_strerror (rc));
3875           unlock_slot (slot);
3876           xfree (apdu_buffer);
3877           xfree (result_buffer);
3878           return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
3879         }
3880       sw = (result[resultlen-2] << 8) | result[resultlen-1];
3881       if (!use_extended_length
3882           && !did_exact_length_hack && SW_EXACT_LENGTH_P (sw))
3883         {
3884           apdu[apdulen-1] = (sw & 0x00ff);
3885           did_exact_length_hack = 1;
3886           goto exact_length_hack;
3887         }
3888     }
3889   while (use_chaining && sw == SW_SUCCESS);
3890
3891   if (apdu_buffer)
3892     {
3893       xfree (apdu_buffer);
3894       apdu_buffer = NULL;
3895       apdu_buffer_size = 0;
3896     }
3897
3898   /* Store away the returned data but strip the statusword. */
3899   resultlen -= 2;
3900   if (DBG_CARD_IO)
3901     {
3902       log_debug (" response: sw=%04X  datalen=%d\n",
3903                  sw, (unsigned int)resultlen);
3904       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
3905         log_printhex ("    dump: ", result, resultlen);
3906     }
3907
3908   if (sw == SW_SUCCESS || sw == SW_EOF_REACHED)
3909     {
3910       if (retbuf)
3911         {
3912           *retbuf = xtrymalloc (resultlen? resultlen : 1);
3913           if (!*retbuf)
3914             {
3915               unlock_slot (slot);
3916               xfree (result_buffer);
3917               return SW_HOST_OUT_OF_CORE;
3918             }
3919           *retbuflen = resultlen;
3920           memcpy (*retbuf, result, resultlen);
3921         }
3922     }
3923   else if ((sw & 0xff00) == SW_MORE_DATA)
3924     {
3925       unsigned char *p = NULL, *tmp;
3926       size_t bufsize = 4096;
3927
3928       /* It is likely that we need to return much more data, so we
3929          start off with a large buffer. */
3930       if (retbuf)
3931         {
3932           *retbuf = p = xtrymalloc (bufsize);
3933           if (!*retbuf)
3934             {
3935               unlock_slot (slot);
3936               xfree (result_buffer);
3937               return SW_HOST_OUT_OF_CORE;
3938             }
3939           assert (resultlen < bufsize);
3940           memcpy (p, result, resultlen);
3941           p += resultlen;
3942         }
3943
3944       do
3945         {
3946           int len = (sw & 0x00ff);
3947
3948           if (DBG_CARD_IO)
3949             log_debug ("apdu_send_simple(%d): %d more bytes available\n",
3950                        slot, len);
3951           apdu_buffer_size = sizeof short_apdu_buffer;
3952           apdu = short_apdu_buffer;
3953           apdulen = 0;
3954           apdu[apdulen++] = class;
3955           apdu[apdulen++] = 0xC0;
3956           apdu[apdulen++] = 0;
3957           apdu[apdulen++] = 0;
3958           apdu[apdulen++] = len;
3959           assert (apdulen <= apdu_buffer_size);
3960           memset (apdu+apdulen, 0, apdu_buffer_size - apdulen);
3961           resultlen = result_buffer_size;
3962           rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
3963           if (rc || resultlen < 2)
3964             {
3965               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
3966                          slot, apdu_strerror (rc));
3967               unlock_slot (slot);
3968               xfree (result_buffer);
3969               return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
3970             }
3971           sw = (result[resultlen-2] << 8) | result[resultlen-1];
3972           resultlen -= 2;
3973           if (DBG_CARD_IO)
3974             {
3975               log_debug ("     more: sw=%04X  datalen=%d\n",
3976                          sw, (unsigned int)resultlen);
3977               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
3978                 log_printhex ("     dump: ", result, resultlen);
3979             }
3980
3981           if ((sw & 0xff00) == SW_MORE_DATA
3982               || sw == SW_SUCCESS
3983               || sw == SW_EOF_REACHED )
3984             {
3985               if (retbuf && resultlen)
3986                 {
3987                   if (p - *retbuf + resultlen > bufsize)
3988                     {
3989                       bufsize += resultlen > 4096? resultlen: 4096;
3990                       tmp = xtryrealloc (*retbuf, bufsize);
3991                       if (!tmp)
3992                         {
3993                           unlock_slot (slot);
3994                           xfree (result_buffer);
3995                           return SW_HOST_OUT_OF_CORE;
3996                         }
3997                       p = tmp + (p - *retbuf);
3998                       *retbuf = tmp;
3999                     }
4000                   memcpy (p, result, resultlen);
4001                   p += resultlen;
4002                 }
4003             }
4004           else
4005             log_info ("apdu_send_simple(%d) "
4006                       "got unexpected status %04X from get response\n",
4007                       slot, sw);
4008         }
4009       while ((sw & 0xff00) == SW_MORE_DATA);
4010
4011       if (retbuf)
4012         {
4013           *retbuflen = p - *retbuf;
4014           tmp = xtryrealloc (*retbuf, *retbuflen);
4015           if (tmp)
4016             *retbuf = tmp;
4017         }
4018     }
4019
4020   unlock_slot (slot);
4021   xfree (result_buffer);
4022
4023   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
4024     log_printhex ("      dump: ", *retbuf, *retbuflen);
4025
4026   return sw;
4027 }
4028
4029 /* Send an APDU to the card in SLOT.  The APDU is created from all
4030    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
4031    for LC won't sent this field and the data field; in this case DATA
4032    must also be passed as NULL.  If EXTENDED_MODE is not 0 command
4033    chaining or extended length will be used; see send_le for details.
4034    The return value is the status word or -1 for an invalid SLOT or
4035    other non card related error.  If RETBUF is not NULL, it will
4036    receive an allocated buffer with the returned data.  The length of
4037    that data will be put into *RETBUFLEN.  The caller is reponsible
4038    for releasing the buffer even in case of errors.  */
4039 int
4040 apdu_send_le(int slot, int extended_mode,
4041              int class, int ins, int p0, int p1,
4042              int lc, const char *data, int le,
4043              unsigned char **retbuf, size_t *retbuflen)
4044 {
4045   return send_le (slot, class, ins, p0, p1,
4046                   lc, data, le,
4047                   retbuf, retbuflen,
4048                   NULL, extended_mode);
4049 }
4050
4051
4052 /* Send an APDU to the card in SLOT.  The APDU is created from all
4053    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
4054    LC won't sent this field and the data field; in this case DATA must
4055    also be passed as NULL.  If EXTENDED_MODE is not 0 command chaining
4056    or extended length will be used; see send_le for details.  The
4057    return value is the status word or -1 for an invalid SLOT or other
4058    non card related error.  If RETBUF is not NULL, it will receive an
4059    allocated buffer with the returned data.  The length of that data
4060    will be put into *RETBUFLEN.  The caller is reponsible for
4061    releasing the buffer even in case of errors.  */
4062 int
4063 apdu_send (int slot, int extended_mode,
4064            int class, int ins, int p0, int p1,
4065            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
4066 {
4067   return send_le (slot, class, ins, p0, p1, lc, data, 256,
4068                   retbuf, retbuflen, NULL, extended_mode);
4069 }
4070
4071 /* Send an APDU to the card in SLOT.  The APDU is created from all
4072    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
4073    LC won't sent this field and the data field; in this case DATA must
4074    also be passed as NULL.  If EXTENDED_MODE is not 0 command chaining
4075    or extended length will be used; see send_le for details.  The
4076    return value is the status word or -1 for an invalid SLOT or other
4077    non card related error.  No data will be returned.  */
4078 int
4079 apdu_send_simple (int slot, int extended_mode,
4080                   int class, int ins, int p0, int p1,
4081                   int lc, const char *data)
4082 {
4083   return send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL, NULL,
4084                   extended_mode);
4085 }
4086
4087
4088 /* This is a more generic version of the apdu sending routine.  It
4089    takes an already formatted APDU in APDUDATA or length APDUDATALEN
4090    and returns with an APDU including the status word.  With
4091    HANDLE_MORE set to true this function will handle the MORE DATA
4092    status and return all APDUs concatenated with one status word at
4093    the end.  If EXTENDED_LENGTH is != 0 extended lengths are allowed
4094    with a max. result data length of EXTENDED_LENGTH bytes.  The
4095    function does not return a regular status word but 0 on success.
4096    If the slot is locked, the function returns immediately with an
4097    error.  */
4098 int
4099 apdu_send_direct (int slot, size_t extended_length,
4100                   const unsigned char *apdudata, size_t apdudatalen,
4101                   int handle_more,
4102                   unsigned char **retbuf, size_t *retbuflen)
4103 {
4104 #define SHORT_RESULT_BUFFER_SIZE 258
4105   unsigned char short_result_buffer[SHORT_RESULT_BUFFER_SIZE+10];
4106   unsigned char *result_buffer = NULL;
4107   size_t result_buffer_size;
4108   unsigned char *result;
4109   size_t resultlen;
4110   unsigned char short_apdu_buffer[5+256+10];
4111   unsigned char *apdu_buffer = NULL;
4112   unsigned char *apdu;
4113   size_t apdulen;
4114   int sw;
4115   long rc; /* we need a long here due to PC/SC. */
4116   int class;
4117
4118   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
4119     return SW_HOST_NO_DRIVER;
4120
4121   if (apdudatalen > 65535)
4122     return SW_HOST_INV_VALUE;
4123
4124   if (apdudatalen > sizeof short_apdu_buffer - 5)
4125     {
4126       apdu_buffer = xtrymalloc (apdudatalen + 5);
4127       if (!apdu_buffer)
4128         return SW_HOST_OUT_OF_CORE;
4129       apdu = apdu_buffer;
4130     }
4131   else
4132     {
4133       apdu = short_apdu_buffer;
4134     }
4135   apdulen = apdudatalen;
4136   memcpy (apdu, apdudata, apdudatalen);
4137   class = apdulen? *apdu : 0;
4138
4139   if (extended_length >= 256 && extended_length <= 65536)
4140     {
4141       result_buffer_size = extended_length;
4142       result_buffer = xtrymalloc (result_buffer_size + 10);
4143       if (!result_buffer)
4144         {
4145           xfree (apdu_buffer);
4146           return SW_HOST_OUT_OF_CORE;
4147         }
4148       result = result_buffer;
4149     }
4150   else
4151     {
4152       result_buffer_size = SHORT_RESULT_BUFFER_SIZE;
4153       result = short_result_buffer;
4154     }
4155 #undef SHORT_RESULT_BUFFER_SIZE
4156
4157   if ((sw = trylock_slot (slot)))
4158     {
4159       xfree (apdu_buffer);
4160       xfree (result_buffer);
4161       return sw;
4162     }
4163
4164   resultlen = result_buffer_size;
4165   rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
4166   xfree (apdu_buffer);
4167   apdu_buffer = NULL;
4168   if (rc || resultlen < 2)
4169     {
4170       log_error ("apdu_send_direct(%d) failed: %s\n",
4171                  slot, apdu_strerror (rc));
4172       unlock_slot (slot);
4173       xfree (result_buffer);
4174       return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
4175     }
4176   sw = (result[resultlen-2] << 8) | result[resultlen-1];
4177   /* Store away the returned data but strip the statusword. */
4178   resultlen -= 2;
4179   if (DBG_CARD_IO)
4180     {
4181       log_debug (" response: sw=%04X  datalen=%d\n",
4182                  sw, (unsigned int)resultlen);
4183       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
4184         log_printhex ("     dump: ", result, resultlen);
4185     }
4186
4187   if (handle_more && (sw & 0xff00) == SW_MORE_DATA)
4188     {
4189       unsigned char *p = NULL, *tmp;
4190       size_t bufsize = 4096;
4191
4192       /* It is likely that we need to return much more data, so we
4193          start off with a large buffer. */
4194       if (retbuf)
4195         {
4196           *retbuf = p = xtrymalloc (bufsize + 2);
4197           if (!*retbuf)
4198             {
4199               unlock_slot (slot);
4200               xfree (result_buffer);
4201               return SW_HOST_OUT_OF_CORE;
4202             }
4203           assert (resultlen < bufsize);
4204           memcpy (p, result, resultlen);
4205           p += resultlen;
4206         }
4207
4208       do
4209         {
4210           int len = (sw & 0x00ff);
4211
4212           if (DBG_CARD_IO)
4213             log_debug ("apdu_send_direct(%d): %d more bytes available\n",
4214                        slot, len);
4215           apdu = short_apdu_buffer;
4216           apdulen = 0;
4217           apdu[apdulen++] = class;
4218           apdu[apdulen++] = 0xC0;
4219           apdu[apdulen++] = 0;
4220           apdu[apdulen++] = 0;
4221           apdu[apdulen++] = len;
4222           memset (apdu+apdulen, 0, sizeof (short_apdu_buffer) - apdulen);
4223           resultlen = result_buffer_size;
4224           rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
4225           if (rc || resultlen < 2)
4226             {
4227               log_error ("apdu_send_direct(%d) for get response failed: %s\n",
4228                          slot, apdu_strerror (rc));
4229               unlock_slot (slot);
4230               xfree (result_buffer);
4231               return rc ? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
4232             }
4233           sw = (result[resultlen-2] << 8) | result[resultlen-1];
4234           resultlen -= 2;
4235           if (DBG_CARD_IO)
4236             {
4237               log_debug ("     more: sw=%04X  datalen=%d\n",
4238                          sw, (unsigned int)resultlen);
4239               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
4240                 log_printhex ("     dump: ", result, resultlen);
4241             }
4242
4243           if ((sw & 0xff00) == SW_MORE_DATA
4244               || sw == SW_SUCCESS
4245               || sw == SW_EOF_REACHED )
4246             {
4247               if (retbuf && resultlen)
4248                 {
4249                   if (p - *retbuf + resultlen > bufsize)
4250                     {
4251                       bufsize += resultlen > 4096? resultlen: 4096;
4252                       tmp = xtryrealloc (*retbuf, bufsize + 2);
4253                       if (!tmp)
4254                         {
4255                           unlock_slot (slot);
4256                           xfree (result_buffer);
4257                           return SW_HOST_OUT_OF_CORE;
4258                         }
4259                       p = tmp + (p - *retbuf);
4260                       *retbuf = tmp;
4261                     }
4262                   memcpy (p, result, resultlen);
4263                   p += resultlen;
4264                 }
4265             }
4266           else
4267             log_info ("apdu_send_direct(%d) "
4268                       "got unexpected status %04X from get response\n",
4269                       slot, sw);
4270         }
4271       while ((sw & 0xff00) == SW_MORE_DATA);
4272
4273       if (retbuf)
4274         {
4275           *retbuflen = p - *retbuf;
4276           tmp = xtryrealloc (*retbuf, *retbuflen + 2);
4277           if (tmp)
4278             *retbuf = tmp;
4279         }
4280     }
4281   else
4282     {
4283       if (retbuf)
4284         {
4285           *retbuf = xtrymalloc ((resultlen? resultlen : 1)+2);
4286           if (!*retbuf)
4287             {
4288               unlock_slot (slot);
4289               xfree (result_buffer);
4290               return SW_HOST_OUT_OF_CORE;
4291             }
4292           *retbuflen = resultlen;
4293           memcpy (*retbuf, result, resultlen);
4294         }
4295     }
4296
4297   unlock_slot (slot);
4298   xfree (result_buffer);
4299
4300   /* Append the status word.  Note that we reserved the two extra
4301      bytes while allocating the buffer.  */
4302   if (retbuf)
4303     {
4304       (*retbuf)[(*retbuflen)++] = (sw >> 8);
4305       (*retbuf)[(*retbuflen)++] = sw;
4306     }
4307
4308   if (DBG_CARD_IO && retbuf)
4309     log_printhex ("      dump: ", *retbuf, *retbuflen);
4310
4311   return 0;
4312 }