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