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