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