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