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