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