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