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