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