scd: Use vendor and product id macros also in apdu.c
[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 <http://www.gnu.org/licenses/>.
19  */
20
21 /* NOTE: This module is also used by other software, thus the use of
22    the macro USE_NPTH is mandatory.  For GnuPG this macro is
23    guaranteed to be defined true. */
24
25 #include <config.h>
26 #include <errno.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <assert.h>
31 #include <signal.h>
32 #ifdef USE_NPTH
33 # include <unistd.h>
34 # include <fcntl.h>
35 # include <npth.h>
36 #endif
37
38
39 /* If requested include the definitions for the remote APDU protocol
40    code. */
41 #ifdef USE_G10CODE_RAPDU
42 #include "rapdu.h"
43 #endif /*USE_G10CODE_RAPDU*/
44
45 #if defined(GNUPG_SCD_MAIN_HEADER)
46 #include GNUPG_SCD_MAIN_HEADER
47 #elif GNUPG_MAJOR_VERSION == 1
48 /* This is used with GnuPG version < 1.9.  The code has been source
49    copied from the current GnuPG >= 1.9  and is maintained over
50    there. */
51 #include "options.h"
52 #include "errors.h"
53 #include "memory.h"
54 #include "util.h"
55 #include "i18n.h"
56 #include "dynload.h"
57 #include "cardglue.h"
58 #else /* GNUPG_MAJOR_VERSION != 1 */
59 #include "scdaemon.h"
60 #include "exechelp.h"
61 #endif /* GNUPG_MAJOR_VERSION != 1 */
62
63 #include "iso7816.h"
64 #include "apdu.h"
65 #define CCID_DRIVER_INCLUDE_USB_IDS 1
66 #include "ccid-driver.h"
67
68 /* Due to conflicting use of threading libraries we usually can't link
69    against libpcsclite.   Instead we use a wrapper program.  */
70 #ifdef USE_NPTH
71 #if !defined(HAVE_W32_SYSTEM) && !defined(__CYGWIN__)
72 #define NEED_PCSC_WRAPPER 1
73 #endif
74 #endif
75
76
77 #define MAX_READER 4 /* Number of readers we support concurrently. */
78
79
80 #if defined(_WIN32) || defined(__CYGWIN__)
81 #define DLSTDCALL __stdcall
82 #else
83 #define DLSTDCALL
84 #endif
85
86 #if defined(__APPLE__) || defined(_WIN32) || defined(__CYGWIN__)
87 typedef unsigned int pcsc_dword_t;
88 #else
89 typedef unsigned long pcsc_dword_t;
90 #endif
91
92 /* A structure to collect information pertaining to one reader
93    slot. */
94 struct reader_table_s {
95   int used;            /* True if slot is used. */
96   unsigned short port; /* Port number:  0 = unused, 1 - dev/tty */
97
98   /* Function pointers intialized to the various backends.  */
99   int (*connect_card)(int);
100   int (*disconnect_card)(int);
101   int (*close_reader)(int);
102   int (*shutdown_reader)(int);
103   int (*reset_reader)(int);
104   int (*get_status_reader)(int, unsigned int *);
105   int (*send_apdu_reader)(int,unsigned char *,size_t,
106                           unsigned char *, size_t *, pininfo_t *);
107   int (*check_pinpad)(int, int, pininfo_t *);
108   void (*dump_status_reader)(int);
109   int (*set_progress_cb)(int, gcry_handler_progress_t, void*);
110   int (*pinpad_verify)(int, int, int, int, int, pininfo_t *);
111   int (*pinpad_modify)(int, int, int, int, int, pininfo_t *);
112
113   struct {
114     ccid_driver_t handle;
115   } ccid;
116   struct {
117     long context;
118     long card;
119     pcsc_dword_t protocol;
120     pcsc_dword_t verify_ioctl;
121     pcsc_dword_t modify_ioctl;
122     int pinmin;
123     int pinmax;
124 #ifdef NEED_PCSC_WRAPPER
125     int req_fd;
126     int rsp_fd;
127     pid_t pid;
128 #endif /*NEED_PCSC_WRAPPER*/
129   } pcsc;
130 #ifdef USE_G10CODE_RAPDU
131   struct {
132     rapdu_t handle;
133   } rapdu;
134 #endif /*USE_G10CODE_RAPDU*/
135   char *rdrname;     /* Name of the connected reader or NULL if unknown. */
136   int any_status;    /* True if we have seen any status.  */
137   int last_status;
138   int status;
139   int is_t0;         /* True if we know that we are running T=0. */
140   int is_spr532;     /* True if we know that the reader is a SPR532.  */
141   int pinpad_varlen_supported;  /* True if we know that the reader
142                                    supports variable length pinpad
143                                    input.  */
144   unsigned char atr[33];
145   size_t atrlen;           /* A zero length indicates that the ATR has
146                               not yet been read; i.e. the card is not
147                               ready for use. */
148   unsigned int change_counter;
149 #ifdef USE_NPTH
150   int lock_initialized;
151   npth_mutex_t lock;
152 #endif
153 };
154 typedef struct reader_table_s *reader_table_t;
155
156 /* A global table to keep track of active readers. */
157 static struct reader_table_s reader_table[MAX_READER];
158
159
160 /* ct API function pointer. */
161 static char (* DLSTDCALL CT_init) (unsigned short ctn, unsigned short Pn);
162 static char (* DLSTDCALL CT_data) (unsigned short ctn, unsigned char *dad,
163                                    unsigned char *sad, unsigned short lc,
164                                    unsigned char *cmd, unsigned short *lr,
165                                    unsigned char *rsp);
166 static char (* DLSTDCALL CT_close) (unsigned short ctn);
167
168 /* PC/SC constants and function pointer. */
169 #define PCSC_SCOPE_USER      0
170 #define PCSC_SCOPE_TERMINAL  1
171 #define PCSC_SCOPE_SYSTEM    2
172 #define PCSC_SCOPE_GLOBAL    3
173
174 #define PCSC_PROTOCOL_T0     1
175 #define PCSC_PROTOCOL_T1     2
176 #ifdef HAVE_W32_SYSTEM
177 # define PCSC_PROTOCOL_RAW   0x00010000  /* The active protocol.  */
178 #else
179 # define PCSC_PROTOCOL_RAW   4
180 #endif
181
182 #define PCSC_SHARE_EXCLUSIVE 1
183 #define PCSC_SHARE_SHARED    2
184 #define PCSC_SHARE_DIRECT    3
185
186 #define PCSC_LEAVE_CARD      0
187 #define PCSC_RESET_CARD      1
188 #define PCSC_UNPOWER_CARD    2
189 #define PCSC_EJECT_CARD      3
190
191 #ifdef HAVE_W32_SYSTEM
192 # define PCSC_UNKNOWN    0x0000  /* The driver is not aware of the status.  */
193 # define PCSC_ABSENT     0x0001  /* Card is absent.  */
194 # define PCSC_PRESENT    0x0002  /* Card is present.  */
195 # define PCSC_SWALLOWED  0x0003  /* Card is present and electrical connected. */
196 # define PCSC_POWERED    0x0004  /* Card is powered.  */
197 # define PCSC_NEGOTIABLE 0x0005  /* Card is awaiting PTS.  */
198 # define PCSC_SPECIFIC   0x0006  /* Card is ready for use.  */
199 #else
200 # define PCSC_UNKNOWN    0x0001
201 # define PCSC_ABSENT     0x0002  /* Card is absent.  */
202 # define PCSC_PRESENT    0x0004  /* Card is present.  */
203 # define PCSC_SWALLOWED  0x0008  /* Card is present and electrical connected. */
204 # define PCSC_POWERED    0x0010  /* Card is powered.  */
205 # define PCSC_NEGOTIABLE 0x0020  /* Card is awaiting PTS.  */
206 # define PCSC_SPECIFIC   0x0040  /* Card is ready for use.  */
207 #endif
208
209 #define PCSC_STATE_UNAWARE     0x0000  /* Want status.  */
210 #define PCSC_STATE_IGNORE      0x0001  /* Ignore this reader.  */
211 #define PCSC_STATE_CHANGED     0x0002  /* State has changed.  */
212 #define PCSC_STATE_UNKNOWN     0x0004  /* Reader unknown.  */
213 #define PCSC_STATE_UNAVAILABLE 0x0008  /* Status unavailable.  */
214 #define PCSC_STATE_EMPTY       0x0010  /* Card removed.  */
215 #define PCSC_STATE_PRESENT     0x0020  /* Card inserted.  */
216 #define PCSC_STATE_ATRMATCH    0x0040  /* ATR matches card. */
217 #define PCSC_STATE_EXCLUSIVE   0x0080  /* Exclusive Mode.  */
218 #define PCSC_STATE_INUSE       0x0100  /* Shared mode.  */
219 #define PCSC_STATE_MUTE        0x0200  /* Unresponsive card.  */
220 #ifdef HAVE_W32_SYSTEM
221 # define PCSC_STATE_UNPOWERED  0x0400  /* Card not powerred up.  */
222 #endif
223
224 /* Some PC/SC error codes.  */
225 #define PCSC_E_CANCELLED               0x80100002
226 #define PCSC_E_CANT_DISPOSE            0x8010000E
227 #define PCSC_E_INSUFFICIENT_BUFFER     0x80100008
228 #define PCSC_E_INVALID_ATR             0x80100015
229 #define PCSC_E_INVALID_HANDLE          0x80100003
230 #define PCSC_E_INVALID_PARAMETER       0x80100004
231 #define PCSC_E_INVALID_TARGET          0x80100005
232 #define PCSC_E_INVALID_VALUE           0x80100011
233 #define PCSC_E_NO_MEMORY               0x80100006
234 #define PCSC_E_UNKNOWN_READER          0x80100009
235 #define PCSC_E_TIMEOUT                 0x8010000A
236 #define PCSC_E_SHARING_VIOLATION       0x8010000B
237 #define PCSC_E_NO_SMARTCARD            0x8010000C
238 #define PCSC_E_UNKNOWN_CARD            0x8010000D
239 #define PCSC_E_PROTO_MISMATCH          0x8010000F
240 #define PCSC_E_NOT_READY               0x80100010
241 #define PCSC_E_SYSTEM_CANCELLED        0x80100012
242 #define PCSC_E_NOT_TRANSACTED          0x80100016
243 #define PCSC_E_READER_UNAVAILABLE      0x80100017
244 #define PCSC_E_NO_SERVICE              0x8010001D
245 #define PCSC_W_REMOVED_CARD            0x80100069
246
247 /* Fix pcsc-lite ABI incompatibilty.  */
248 #ifndef SCARD_CTL_CODE
249 # define SCARD_CTL_CODE(code) (0x42000000 + (code))
250 #endif
251
252 #define CM_IOCTL_GET_FEATURE_REQUEST     SCARD_CTL_CODE(3400)
253 #define CM_IOCTL_VENDOR_IFD_EXCHANGE     SCARD_CTL_CODE(1)
254 #define FEATURE_VERIFY_PIN_DIRECT        0x06
255 #define FEATURE_MODIFY_PIN_DIRECT        0x07
256 #define FEATURE_GET_TLV_PROPERTIES       0x12
257
258 #define PCSCv2_PART10_PROPERTY_bEntryValidationCondition 2
259 #define PCSCv2_PART10_PROPERTY_bTimeOut2                 3
260 #define PCSCv2_PART10_PROPERTY_bMinPINSize               6
261 #define PCSCv2_PART10_PROPERTY_bMaxPINSize               7
262 #define PCSCv2_PART10_PROPERTY_wIdVendor                11
263 #define PCSCv2_PART10_PROPERTY_wIdProduct               12
264
265
266 /* The PC/SC error is defined as a long as per specs.  Due to left
267    shifts bit 31 will get sign extended.  We use this mask to fix
268    it. */
269 #define PCSC_ERR_MASK(a)  ((a) & 0xffffffff)
270
271
272 struct pcsc_io_request_s
273 {
274   unsigned long protocol;
275   unsigned long pci_len;
276 };
277
278 typedef struct pcsc_io_request_s *pcsc_io_request_t;
279
280 #ifdef __APPLE__
281 #pragma pack(1)
282 #endif
283
284 struct pcsc_readerstate_s
285 {
286   const char *reader;
287   void *user_data;
288   pcsc_dword_t current_state;
289   pcsc_dword_t event_state;
290   pcsc_dword_t atrlen;
291   unsigned char atr[33];
292 };
293
294 #ifdef __APPLE__
295 #pragma pack()
296 #endif
297
298 typedef struct pcsc_readerstate_s *pcsc_readerstate_t;
299
300 long (* DLSTDCALL pcsc_establish_context) (pcsc_dword_t scope,
301                                            const void *reserved1,
302                                            const void *reserved2,
303                                            long *r_context);
304 long (* DLSTDCALL pcsc_release_context) (long context);
305 long (* DLSTDCALL pcsc_list_readers) (long context,
306                                       const char *groups,
307                                       char *readers, pcsc_dword_t*readerslen);
308 long (* DLSTDCALL pcsc_get_status_change) (long context,
309                                            pcsc_dword_t timeout,
310                                            pcsc_readerstate_t readerstates,
311                                            pcsc_dword_t nreaderstates);
312 long (* DLSTDCALL pcsc_connect) (long context,
313                                  const char *reader,
314                                  pcsc_dword_t share_mode,
315                                  pcsc_dword_t preferred_protocols,
316                                  long *r_card,
317                                  pcsc_dword_t *r_active_protocol);
318 long (* DLSTDCALL pcsc_reconnect) (long card,
319                                    pcsc_dword_t share_mode,
320                                    pcsc_dword_t preferred_protocols,
321                                    pcsc_dword_t initialization,
322                                    pcsc_dword_t *r_active_protocol);
323 long (* DLSTDCALL pcsc_disconnect) (long card,
324                                     pcsc_dword_t disposition);
325 long (* DLSTDCALL pcsc_status) (long card,
326                                 char *reader, pcsc_dword_t *readerlen,
327                                 pcsc_dword_t *r_state,
328                                 pcsc_dword_t *r_protocol,
329                                 unsigned char *atr, pcsc_dword_t *atrlen);
330 long (* DLSTDCALL pcsc_begin_transaction) (long card);
331 long (* DLSTDCALL pcsc_end_transaction) (long card,
332                                          pcsc_dword_t disposition);
333 long (* DLSTDCALL pcsc_transmit) (long card,
334                                   const pcsc_io_request_t send_pci,
335                                   const unsigned char *send_buffer,
336                                   pcsc_dword_t send_len,
337                                   pcsc_io_request_t recv_pci,
338                                   unsigned char *recv_buffer,
339                                   pcsc_dword_t *recv_len);
340 long (* DLSTDCALL pcsc_set_timeout) (long context,
341                                      pcsc_dword_t timeout);
342 long (* DLSTDCALL pcsc_control) (long card,
343                                  pcsc_dword_t control_code,
344                                  const void *send_buffer,
345                                  pcsc_dword_t send_len,
346                                  void *recv_buffer,
347                                  pcsc_dword_t recv_len,
348                                  pcsc_dword_t *bytes_returned);
349
350
351 /*  Prototypes.  */
352 static int pcsc_get_status (int slot, unsigned int *status);
353 static int reset_pcsc_reader (int slot);
354 static int apdu_get_status_internal (int slot, int hang, int no_atr_reset,
355                                      unsigned int *status,
356                                      unsigned int *changed);
357 static int check_pcsc_pinpad (int slot, int command, pininfo_t *pininfo);
358 static int pcsc_pinpad_verify (int slot, int class, int ins, int p0, int p1,
359                                pininfo_t *pininfo);
360 static int pcsc_pinpad_modify (int slot, int class, int ins, int p0, int p1,
361                                pininfo_t *pininfo);
362
363
364 \f
365 /*
366       Helper
367  */
368
369
370 /* Find an unused reader slot for PORTSTR and put it into the reader
371    table.  Return -1 on error or the index into the reader table. */
372 static int
373 new_reader_slot (void)
374 {
375   int i, reader = -1;
376   int err;
377
378   for (i=0; i < MAX_READER; i++)
379     {
380       if (!reader_table[i].used && reader == -1)
381         reader = i;
382     }
383   if (reader == -1)
384     {
385       log_error ("new_reader_slot: out of slots\n");
386       return -1;
387     }
388 #ifdef USE_NPTH
389   if (!reader_table[reader].lock_initialized)
390     {
391       err = npth_mutex_init (&reader_table[reader].lock, NULL);
392       if (err)
393         {
394           log_error ("error initializing mutex: %s\n", strerror (err));
395           return -1;
396         }
397       reader_table[reader].lock_initialized = 1;
398     }
399 #endif /*USE_NPTH*/
400   reader_table[reader].connect_card = NULL;
401   reader_table[reader].disconnect_card = NULL;
402   reader_table[reader].close_reader = NULL;
403   reader_table[reader].shutdown_reader = NULL;
404   reader_table[reader].reset_reader = NULL;
405   reader_table[reader].get_status_reader = NULL;
406   reader_table[reader].send_apdu_reader = NULL;
407   reader_table[reader].check_pinpad = check_pcsc_pinpad;
408   reader_table[reader].dump_status_reader = NULL;
409   reader_table[reader].set_progress_cb = NULL;
410   reader_table[reader].pinpad_verify = pcsc_pinpad_verify;
411   reader_table[reader].pinpad_modify = pcsc_pinpad_modify;
412
413   reader_table[reader].used = 1;
414   reader_table[reader].any_status = 0;
415   reader_table[reader].last_status = 0;
416   reader_table[reader].is_t0 = 1;
417   reader_table[reader].is_spr532 = 0;
418   reader_table[reader].pinpad_varlen_supported = 0;
419 #ifdef NEED_PCSC_WRAPPER
420   reader_table[reader].pcsc.req_fd = -1;
421   reader_table[reader].pcsc.rsp_fd = -1;
422   reader_table[reader].pcsc.pid = (pid_t)(-1);
423 #endif
424   reader_table[reader].pcsc.verify_ioctl = 0;
425   reader_table[reader].pcsc.modify_ioctl = 0;
426   reader_table[reader].pcsc.pinmin = -1;
427   reader_table[reader].pcsc.pinmax = -1;
428
429   return reader;
430 }
431
432
433 static void
434 dump_reader_status (int slot)
435 {
436   if (!opt.verbose)
437     return;
438
439   if (reader_table[slot].dump_status_reader)
440     reader_table[slot].dump_status_reader (slot);
441
442   if (reader_table[slot].status != -1
443       && reader_table[slot].atrlen)
444     {
445       log_info ("slot %d: ATR=", slot);
446       log_printhex ("", reader_table[slot].atr, reader_table[slot].atrlen);
447     }
448 }
449
450
451
452 static const char *
453 host_sw_string (long err)
454 {
455   switch (err)
456     {
457     case 0: return "okay";
458     case SW_HOST_OUT_OF_CORE: return "out of core";
459     case SW_HOST_INV_VALUE: return "invalid value";
460     case SW_HOST_NO_DRIVER: return "no driver";
461     case SW_HOST_NOT_SUPPORTED: return "not supported";
462     case SW_HOST_LOCKING_FAILED: return "locking failed";
463     case SW_HOST_BUSY: return "busy";
464     case SW_HOST_NO_CARD: return "no card";
465     case SW_HOST_CARD_INACTIVE: return "card inactive";
466     case SW_HOST_CARD_IO_ERROR: return "card I/O error";
467     case SW_HOST_GENERAL_ERROR: return "general error";
468     case SW_HOST_NO_READER: return "no reader";
469     case SW_HOST_ABORTED: return "aborted";
470     case SW_HOST_NO_PINPAD: return "no pinpad";
471     case SW_HOST_ALREADY_CONNECTED: return "already connected";
472     default: return "unknown host status error";
473     }
474 }
475
476
477 const char *
478 apdu_strerror (int rc)
479 {
480   switch (rc)
481     {
482     case SW_EOF_REACHED    : return "eof reached";
483     case SW_EEPROM_FAILURE : return "eeprom failure";
484     case SW_WRONG_LENGTH   : return "wrong length";
485     case SW_CHV_WRONG      : return "CHV wrong";
486     case SW_CHV_BLOCKED    : return "CHV blocked";
487     case SW_USE_CONDITIONS : return "use conditions not satisfied";
488     case SW_BAD_PARAMETER  : return "bad parameter";
489     case SW_NOT_SUPPORTED  : return "not supported";
490     case SW_FILE_NOT_FOUND : return "file not found";
491     case SW_RECORD_NOT_FOUND:return "record not found";
492     case SW_REF_NOT_FOUND  : return "reference not found";
493     case SW_NOT_ENOUGH_MEMORY: return "not enough memory space in the file";
494     case SW_INCONSISTENT_LC: return "Lc inconsistent with TLV structure.";
495     case SW_INCORRECT_P0_P1: return "incorrect parameters P0,P1";
496     case SW_BAD_LC         : return "Lc inconsistent with P0,P1";
497     case SW_BAD_P0_P1      : return "bad P0,P1";
498     case SW_INS_NOT_SUP    : return "instruction not supported";
499     case SW_CLA_NOT_SUP    : return "class not supported";
500     case SW_SUCCESS        : return "success";
501     default:
502       if ((rc & ~0x00ff) == SW_MORE_DATA)
503         return "more data available";
504       if ( (rc & 0x10000) )
505         return host_sw_string (rc);
506       return "unknown status error";
507     }
508 }
509
510
511 \f
512 /*
513        ct API Interface
514  */
515
516 static const char *
517 ct_error_string (long err)
518 {
519   switch (err)
520     {
521     case 0: return "okay";
522     case -1: return "invalid data";
523     case -8: return "ct error";
524     case -10: return "transmission error";
525     case -11: return "memory allocation error";
526     case -128: return "HTSI error";
527     default: return "unknown CT-API error";
528     }
529 }
530
531
532 static void
533 ct_dump_reader_status (int slot)
534 {
535   log_info ("reader slot %d: %s\n", slot,
536             reader_table[slot].status == 1? "Processor ICC present" :
537             reader_table[slot].status == 0? "Memory ICC present" :
538             "ICC not present" );
539 }
540
541
542 /* Wait for the card in SLOT and activate it.  Return a status word
543    error or 0 on success. */
544 static int
545 ct_activate_card (int slot)
546 {
547   int rc;
548   unsigned char dad[1], sad[1], cmd[11], buf[256];
549   unsigned short buflen;
550
551   /* Check whether card has been inserted. */
552   dad[0] = 1;     /* Destination address: CT. */
553   sad[0] = 2;     /* Source address: Host. */
554
555   cmd[0] = 0x20;  /* Class byte. */
556   cmd[1] = 0x13;  /* Request status. */
557   cmd[2] = 0x00;  /* From kernel. */
558   cmd[3] = 0x80;  /* Return card's DO. */
559   cmd[4] = 0x00;
560
561   buflen = DIM(buf);
562
563   rc = CT_data (slot, dad, sad, 5, cmd, &buflen, buf);
564   if (rc || buflen < 2 || buf[buflen-2] != 0x90)
565     {
566       log_error ("ct_activate_card: can't get status of reader %d: %s\n",
567                  slot, ct_error_string (rc));
568       return SW_HOST_CARD_IO_ERROR;
569     }
570
571   /* Connected, now activate the card. */
572   dad[0] = 1;    /* Destination address: CT. */
573   sad[0] = 2;    /* Source address: Host. */
574
575   cmd[0] = 0x20;  /* Class byte. */
576   cmd[1] = 0x12;  /* Request ICC. */
577   cmd[2] = 0x01;  /* From first interface. */
578   cmd[3] = 0x01;  /* Return card's ATR. */
579   cmd[4] = 0x00;
580
581   buflen = DIM(buf);
582
583   rc = CT_data (slot, dad, sad, 5, cmd, &buflen, buf);
584   if (rc || buflen < 2 || buf[buflen-2] != 0x90)
585     {
586       log_error ("ct_activate_card(%d): activation failed: %s\n",
587                  slot, ct_error_string (rc));
588       if (!rc)
589         log_printhex ("  received data:", buf, buflen);
590       return SW_HOST_CARD_IO_ERROR;
591     }
592
593   /* Store the type and the ATR. */
594   if (buflen - 2 > DIM (reader_table[0].atr))
595     {
596       log_error ("ct_activate_card(%d): ATR too long\n", slot);
597       return SW_HOST_CARD_IO_ERROR;
598     }
599
600   reader_table[slot].status = buf[buflen - 1];
601   memcpy (reader_table[slot].atr, buf, buflen - 2);
602   reader_table[slot].atrlen = buflen - 2;
603   return 0;
604 }
605
606
607 static int
608 close_ct_reader (int slot)
609 {
610   CT_close (slot);
611   reader_table[slot].used = 0;
612   return 0;
613 }
614
615 static int
616 reset_ct_reader (int slot)
617 {
618   /* FIXME: Check is this is sufficient do do a reset. */
619   return ct_activate_card (slot);
620 }
621
622
623 static int
624 ct_get_status (int slot, unsigned int *status)
625 {
626   (void)slot;
627   /* The status we returned is wrong but we don't care becuase ctAPI
628      is not anymore required.  */
629   *status = APDU_CARD_USABLE|APDU_CARD_PRESENT|APDU_CARD_ACTIVE;
630   return 0;
631 }
632
633 /* Actually send the APDU of length APDULEN to SLOT and return a
634    maximum of *BUFLEN data in BUFFER, the actual retruned size will be
635    set to BUFLEN.  Returns: CT API error code. */
636 static int
637 ct_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
638               unsigned char *buffer, size_t *buflen, pininfo_t *pininfo)
639 {
640   int rc;
641   unsigned char dad[1], sad[1];
642   unsigned short ctbuflen;
643
644   (void)pininfo;
645
646   /* If we don't have an ATR, we need to reset the reader first. */
647   if (!reader_table[slot].atrlen
648       && (rc = reset_ct_reader (slot)))
649     return rc;
650
651   dad[0] = 0;     /* Destination address: Card. */
652   sad[0] = 2;     /* Source address: Host. */
653   ctbuflen = *buflen;
654   if (DBG_CARD_IO)
655     log_printhex ("  CT_data:", apdu, apdulen);
656   rc = CT_data (slot, dad, sad, apdulen, apdu, &ctbuflen, buffer);
657   *buflen = ctbuflen;
658
659   return rc? SW_HOST_CARD_IO_ERROR: 0;
660 }
661
662
663
664 /* Open a reader and return an internal handle for it.  PORT is a
665    non-negative value with the port number of the reader. USB readers
666    do have port numbers starting at 32769. */
667 static int
668 open_ct_reader (int port)
669 {
670   int rc, reader;
671
672   if (port < 0 || port > 0xffff)
673     {
674       log_error ("open_ct_reader: invalid port %d requested\n", port);
675       return -1;
676     }
677   reader = new_reader_slot ();
678   if (reader == -1)
679     return reader;
680   reader_table[reader].port = port;
681
682   rc = CT_init (reader, (unsigned short)port);
683   if (rc)
684     {
685       log_error ("apdu_open_ct_reader failed on port %d: %s\n",
686                  port, ct_error_string (rc));
687       reader_table[reader].used = 0;
688       return -1;
689     }
690
691   /* Only try to activate the card. */
692   rc = ct_activate_card (reader);
693   if (rc)
694     {
695       reader_table[reader].atrlen = 0;
696       rc = 0;
697     }
698
699   reader_table[reader].close_reader = close_ct_reader;
700   reader_table[reader].reset_reader = reset_ct_reader;
701   reader_table[reader].get_status_reader = ct_get_status;
702   reader_table[reader].send_apdu_reader = ct_send_apdu;
703   reader_table[reader].check_pinpad = NULL;
704   reader_table[reader].dump_status_reader = ct_dump_reader_status;
705   reader_table[reader].pinpad_verify = NULL;
706   reader_table[reader].pinpad_modify = NULL;
707
708   dump_reader_status (reader);
709   return reader;
710 }
711
712 \f
713 /*
714        PC/SC Interface
715  */
716
717 #ifdef NEED_PCSC_WRAPPER
718 static int
719 writen (int fd, const void *buf, size_t nbytes)
720 {
721   size_t nleft = nbytes;
722   int nwritten;
723
724 /*   log_printhex (" writen:", buf, nbytes); */
725
726   while (nleft > 0)
727     {
728 #ifdef USE_NPTH
729       nwritten = npth_write (fd, buf, nleft);
730 #else
731       nwritten = write (fd, buf, nleft);
732 #endif
733       if (nwritten < 0 && errno == EINTR)
734         continue;
735       if (nwritten < 0)
736         return -1;
737       nleft -= nwritten;
738       buf = (const char*)buf + nwritten;
739     }
740   return 0;
741 }
742
743 /* Read up to BUFLEN bytes from FD and return the number of bytes
744    actually read in NREAD.  Returns -1 on error or 0 on success. */
745 static int
746 readn (int fd, void *buf, size_t buflen, size_t *nread)
747 {
748   size_t nleft = buflen;
749   int n;
750 /*   void *orig_buf = buf; */
751
752   while (nleft > 0)
753     {
754 #ifdef USE_NPTH
755 # ifdef HAVE_W32_SYSTEM
756 #  error Cannot use npth_read here because it expects a system HANDLE.
757 # endif
758       n = npth_read (fd, buf, nleft);
759 #else
760       n = read (fd, buf, nleft);
761 #endif
762       if (n < 0 && errno == EINTR)
763         continue;
764       if (n < 0)
765         return -1; /* read error. */
766       if (!n)
767         break; /* EOF */
768       nleft -= n;
769       buf = (char*)buf + n;
770     }
771   if (nread)
772     *nread = buflen - nleft;
773
774 /*   log_printhex ("  readn:", orig_buf, *nread); */
775
776   return 0;
777 }
778 #endif /*NEED_PCSC_WRAPPER*/
779
780 static const char *
781 pcsc_error_string (long err)
782 {
783   const char *s;
784
785   if (!err)
786     return "okay";
787   if ((err & 0x80100000) != 0x80100000)
788     return "invalid PC/SC error code";
789   err &= 0xffff;
790   switch (err)
791     {
792     case 0x0002: s = "cancelled"; break;
793     case 0x000e: s = "can't dispose"; break;
794     case 0x0008: s = "insufficient buffer"; break;
795     case 0x0015: s = "invalid ATR"; break;
796     case 0x0003: s = "invalid handle"; break;
797     case 0x0004: s = "invalid parameter"; break;
798     case 0x0005: s = "invalid target"; break;
799     case 0x0011: s = "invalid value"; break;
800     case 0x0006: s = "no memory"; break;
801     case 0x0013: s = "comm error"; break;
802     case 0x0001: s = "internal error"; break;
803     case 0x0014: s = "unknown error"; break;
804     case 0x0007: s = "waited too long"; break;
805     case 0x0009: s = "unknown reader"; break;
806     case 0x000a: s = "timeout"; break;
807     case 0x000b: s = "sharing violation"; break;
808     case 0x000c: s = "no smartcard"; break;
809     case 0x000d: s = "unknown card"; break;
810     case 0x000f: s = "proto mismatch"; break;
811     case 0x0010: s = "not ready"; break;
812     case 0x0012: s = "system cancelled"; break;
813     case 0x0016: s = "not transacted"; break;
814     case 0x0017: s = "reader unavailable"; break;
815     case 0x0065: s = "unsupported card"; break;
816     case 0x0066: s = "unresponsive card"; break;
817     case 0x0067: s = "unpowered card"; break;
818     case 0x0068: s = "reset card"; break;
819     case 0x0069: s = "removed card"; break;
820     case 0x006a: s = "inserted card"; break;
821     case 0x001f: s = "unsupported feature"; break;
822     case 0x0019: s = "PCI too small"; break;
823     case 0x001a: s = "reader unsupported"; break;
824     case 0x001b: s = "duplicate reader"; break;
825     case 0x001c: s = "card unsupported"; break;
826     case 0x001d: s = "no service"; break;
827     case 0x001e: s = "service stopped"; break;
828     default:     s = "unknown PC/SC error code"; break;
829     }
830   return s;
831 }
832
833 /* Map PC/SC error codes to our special host status words.  */
834 static int
835 pcsc_error_to_sw (long ec)
836 {
837   int rc;
838
839   switch ( PCSC_ERR_MASK (ec) )
840     {
841     case 0:  rc = 0; break;
842
843     case PCSC_E_CANCELLED:           rc = SW_HOST_ABORTED; break;
844     case PCSC_E_NO_MEMORY:           rc = SW_HOST_OUT_OF_CORE; break;
845     case PCSC_E_TIMEOUT:             rc = SW_HOST_CARD_IO_ERROR; break;
846     case PCSC_E_UNKNOWN_READER:      rc = SW_HOST_NO_READER; break;
847     case PCSC_E_SHARING_VIOLATION:   rc = SW_HOST_LOCKING_FAILED; break;
848     case PCSC_E_NO_SMARTCARD:        rc = SW_HOST_NO_CARD; break;
849     case PCSC_W_REMOVED_CARD:        rc = SW_HOST_NO_CARD; break;
850
851     case PCSC_E_INVALID_TARGET:
852     case PCSC_E_INVALID_VALUE:
853     case PCSC_E_INVALID_HANDLE:
854     case PCSC_E_INVALID_PARAMETER:
855     case PCSC_E_INSUFFICIENT_BUFFER: rc = SW_HOST_INV_VALUE; break;
856
857     default:  rc = SW_HOST_GENERAL_ERROR; break;
858     }
859
860   return rc;
861 }
862
863 static void
864 dump_pcsc_reader_status (int slot)
865 {
866   if (reader_table[slot].pcsc.card)
867     {
868       log_info ("reader slot %d: active protocol:", slot);
869       if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T0))
870         log_printf (" T0");
871       else if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
872         log_printf (" T1");
873       else if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_RAW))
874         log_printf (" raw");
875       log_printf ("\n");
876     }
877   else
878     log_info ("reader slot %d: not connected\n", slot);
879 }
880
881
882 #ifndef NEED_PCSC_WRAPPER
883 static int
884 pcsc_get_status_direct (int slot, unsigned int *status)
885 {
886   long err;
887   struct pcsc_readerstate_s rdrstates[1];
888
889   memset (rdrstates, 0, sizeof *rdrstates);
890   rdrstates[0].reader = reader_table[slot].rdrname;
891   rdrstates[0].current_state = PCSC_STATE_UNAWARE;
892   err = pcsc_get_status_change (reader_table[slot].pcsc.context,
893                                 0,
894                                 rdrstates, 1);
895   if (err == PCSC_E_TIMEOUT)
896     err = 0; /* Timeout is no error error here. */
897   if (err)
898     {
899       log_error ("pcsc_get_status_change failed: %s (0x%lx)\n",
900                  pcsc_error_string (err), err);
901       return pcsc_error_to_sw (err);
902     }
903
904   /*   log_debug  */
905   /*     ("pcsc_get_status_change: %s%s%s%s%s%s%s%s%s%s\n", */
906   /*      (rdrstates[0].event_state & PCSC_STATE_IGNORE)? " ignore":"", */
907   /*      (rdrstates[0].event_state & PCSC_STATE_CHANGED)? " changed":"", */
908   /*      (rdrstates[0].event_state & PCSC_STATE_UNKNOWN)? " unknown":"", */
909   /*      (rdrstates[0].event_state & PCSC_STATE_UNAVAILABLE)?" unavail":"", */
910   /*      (rdrstates[0].event_state & PCSC_STATE_EMPTY)? " empty":"", */
911   /*      (rdrstates[0].event_state & PCSC_STATE_PRESENT)? " present":"", */
912   /*      (rdrstates[0].event_state & PCSC_STATE_ATRMATCH)? " atr":"", */
913   /*      (rdrstates[0].event_state & PCSC_STATE_EXCLUSIVE)? " excl":"", */
914   /*      (rdrstates[0].event_state & PCSC_STATE_INUSE)? " unuse":"", */
915   /*      (rdrstates[0].event_state & PCSC_STATE_MUTE)? " mute":"" ); */
916
917   *status = 0;
918   if ( (rdrstates[0].event_state & PCSC_STATE_PRESENT) )
919     {
920       *status |= APDU_CARD_PRESENT;
921       if ( !(rdrstates[0].event_state & PCSC_STATE_MUTE) )
922         *status |= APDU_CARD_ACTIVE;
923     }
924 #ifndef HAVE_W32_SYSTEM
925   /* We indicate a useful card if it is not in use by another
926      application.  This is because we only use exclusive access
927      mode.  */
928   if ( (*status & (APDU_CARD_PRESENT|APDU_CARD_ACTIVE))
929        == (APDU_CARD_PRESENT|APDU_CARD_ACTIVE)
930        && !(rdrstates[0].event_state & PCSC_STATE_INUSE) )
931     *status |= APDU_CARD_USABLE;
932 #else
933   /* Some winscard drivers may set EXCLUSIVE and INUSE at the same
934      time when we are the only user (SCM SCR335) under Windows.  */
935   if ((*status & (APDU_CARD_PRESENT|APDU_CARD_ACTIVE))
936       == (APDU_CARD_PRESENT|APDU_CARD_ACTIVE))
937     *status |= APDU_CARD_USABLE;
938 #endif
939
940   return 0;
941 }
942 #endif /*!NEED_PCSC_WRAPPER*/
943
944
945 #ifdef NEED_PCSC_WRAPPER
946 static int
947 pcsc_get_status_wrapped (int slot, unsigned int *status)
948 {
949   long err;
950   reader_table_t slotp;
951   size_t len, full_len;
952   int i, n;
953   unsigned char msgbuf[9];
954   unsigned char buffer[16];
955   int sw = SW_HOST_CARD_IO_ERROR;
956
957   slotp = reader_table + slot;
958
959   if (slotp->pcsc.req_fd == -1
960       || slotp->pcsc.rsp_fd == -1
961       || slotp->pcsc.pid == (pid_t)(-1) )
962     {
963       log_error ("pcsc_get_status: pcsc-wrapper not running\n");
964       return sw;
965     }
966
967   msgbuf[0] = 0x04; /* STATUS command. */
968   len = 0;
969   msgbuf[1] = (len >> 24);
970   msgbuf[2] = (len >> 16);
971   msgbuf[3] = (len >>  8);
972   msgbuf[4] = (len      );
973   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
974     {
975       log_error ("error sending PC/SC STATUS request: %s\n",
976                  strerror (errno));
977       goto command_failed;
978     }
979
980   /* Read the response. */
981   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
982     {
983       log_error ("error receiving PC/SC STATUS response: %s\n",
984                  i? strerror (errno) : "premature EOF");
985       goto command_failed;
986     }
987   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
988   if (msgbuf[0] != 0x81 || len < 4)
989     {
990       log_error ("invalid response header from PC/SC received\n");
991       goto command_failed;
992     }
993   len -= 4; /* Already read the error code. */
994   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
995                        | (msgbuf[7] << 8 ) | msgbuf[8]);
996   if (err)
997     {
998       log_error ("pcsc_status failed: %s (0x%lx)\n",
999                  pcsc_error_string (err), err);
1000       /* This is a proper error code, so return immediately.  */
1001       return pcsc_error_to_sw (err);
1002     }
1003
1004   full_len = len;
1005
1006   /* The current version returns 3 words but we allow also for old
1007      versions returning only 2 words. */
1008   n = 12 < len ? 12 : len;
1009   if ((i=readn (slotp->pcsc.rsp_fd, buffer, n, &len))
1010       || (len != 8 && len != 12))
1011     {
1012       log_error ("error receiving PC/SC STATUS response: %s\n",
1013                  i? strerror (errno) : "premature EOF");
1014       goto command_failed;
1015     }
1016
1017   slotp->is_t0 = (len == 12 && !!(buffer[11] & PCSC_PROTOCOL_T0));
1018
1019
1020   full_len -= len;
1021   /* Newer versions of the wrapper might send more status bytes.
1022      Read them. */
1023   while (full_len)
1024     {
1025       unsigned char dummybuf[128];
1026
1027       n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
1028       if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
1029         {
1030           log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1031                      i? strerror (errno) : "premature EOF");
1032           goto command_failed;
1033         }
1034       full_len -= n;
1035     }
1036
1037   /* We are lucky: The wrapper already returns the data in the
1038      required format. */
1039   *status = buffer[3];
1040   return 0;
1041
1042  command_failed:
1043   close (slotp->pcsc.req_fd);
1044   close (slotp->pcsc.rsp_fd);
1045   slotp->pcsc.req_fd = -1;
1046   slotp->pcsc.rsp_fd = -1;
1047   if (slotp->pcsc.pid != -1)
1048     kill (slotp->pcsc.pid, SIGTERM);
1049   slotp->pcsc.pid = (pid_t)(-1);
1050   slotp->used = 0;
1051   return sw;
1052 }
1053 #endif /*NEED_PCSC_WRAPPER*/
1054
1055
1056 static int
1057 pcsc_get_status (int slot, unsigned int *status)
1058 {
1059 #ifdef NEED_PCSC_WRAPPER
1060   return pcsc_get_status_wrapped (slot, status);
1061 #else
1062   return pcsc_get_status_direct (slot, status);
1063 #endif
1064 }
1065
1066
1067 #ifndef NEED_PCSC_WRAPPER
1068 static int
1069 pcsc_send_apdu_direct (int slot, unsigned char *apdu, size_t apdulen,
1070                        unsigned char *buffer, size_t *buflen,
1071                        pininfo_t *pininfo)
1072 {
1073   long err;
1074   struct pcsc_io_request_s send_pci;
1075   pcsc_dword_t recv_len;
1076
1077   if (!reader_table[slot].atrlen
1078       && (err = reset_pcsc_reader (slot)))
1079     return err;
1080
1081   if (DBG_CARD_IO)
1082     log_printhex ("  PCSC_data:", apdu, apdulen);
1083
1084   if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
1085       send_pci.protocol = PCSC_PROTOCOL_T1;
1086   else
1087       send_pci.protocol = PCSC_PROTOCOL_T0;
1088   send_pci.pci_len = sizeof send_pci;
1089   recv_len = *buflen;
1090   err = pcsc_transmit (reader_table[slot].pcsc.card,
1091                        &send_pci, apdu, apdulen,
1092                        NULL, buffer, &recv_len);
1093   *buflen = recv_len;
1094   if (err)
1095     log_error ("pcsc_transmit failed: %s (0x%lx)\n",
1096                pcsc_error_string (err), err);
1097
1098   return pcsc_error_to_sw (err);
1099 }
1100 #endif /*!NEED_PCSC_WRAPPER*/
1101
1102
1103 #ifdef NEED_PCSC_WRAPPER
1104 static int
1105 pcsc_send_apdu_wrapped (int slot, unsigned char *apdu, size_t apdulen,
1106                         unsigned char *buffer, size_t *buflen,
1107                         pininfo_t *pininfo)
1108 {
1109   long err;
1110   reader_table_t slotp;
1111   size_t len, full_len;
1112   int i, n;
1113   unsigned char msgbuf[9];
1114   int sw = SW_HOST_CARD_IO_ERROR;
1115
1116   (void)pininfo;
1117
1118   if (!reader_table[slot].atrlen
1119       && (err = reset_pcsc_reader (slot)))
1120     return err;
1121
1122   if (DBG_CARD_IO)
1123     log_printhex ("  PCSC_data:", apdu, apdulen);
1124
1125   slotp = reader_table + slot;
1126
1127   if (slotp->pcsc.req_fd == -1
1128       || slotp->pcsc.rsp_fd == -1
1129       || slotp->pcsc.pid == (pid_t)(-1) )
1130     {
1131       log_error ("pcsc_send_apdu: pcsc-wrapper not running\n");
1132       return sw;
1133     }
1134
1135   msgbuf[0] = 0x03; /* TRANSMIT command. */
1136   len = apdulen;
1137   msgbuf[1] = (len >> 24);
1138   msgbuf[2] = (len >> 16);
1139   msgbuf[3] = (len >>  8);
1140   msgbuf[4] = (len      );
1141   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
1142        || writen (slotp->pcsc.req_fd, apdu, len))
1143     {
1144       log_error ("error sending PC/SC TRANSMIT request: %s\n",
1145                  strerror (errno));
1146       goto command_failed;
1147     }
1148
1149   /* Read the response. */
1150   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1151     {
1152       log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1153                  i? strerror (errno) : "premature EOF");
1154       goto command_failed;
1155     }
1156   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1157   if (msgbuf[0] != 0x81 || len < 4)
1158     {
1159       log_error ("invalid response header from PC/SC received\n");
1160       goto command_failed;
1161     }
1162   len -= 4; /* Already read the error code. */
1163   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
1164                        | (msgbuf[7] << 8 ) | msgbuf[8]);
1165   if (err)
1166     {
1167       log_error ("pcsc_transmit failed: %s (0x%lx)\n",
1168                  pcsc_error_string (err), err);
1169       return pcsc_error_to_sw (err);
1170     }
1171
1172    full_len = len;
1173
1174    n = *buflen < len ? *buflen : len;
1175    if ((i=readn (slotp->pcsc.rsp_fd, buffer, n, &len)) || len != n)
1176      {
1177        log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1178                   i? strerror (errno) : "premature EOF");
1179        goto command_failed;
1180      }
1181    *buflen = n;
1182
1183    full_len -= len;
1184    if (full_len)
1185      {
1186        log_error ("pcsc_send_apdu: provided buffer too short - truncated\n");
1187        err = SW_HOST_INV_VALUE;
1188      }
1189    /* We need to read any rest of the response, to keep the
1190       protocol running.  */
1191    while (full_len)
1192      {
1193        unsigned char dummybuf[128];
1194
1195        n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
1196        if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
1197          {
1198            log_error ("error receiving PC/SC TRANSMIT response: %s\n",
1199                       i? strerror (errno) : "premature EOF");
1200            goto command_failed;
1201          }
1202        full_len -= n;
1203      }
1204
1205    return err;
1206
1207  command_failed:
1208   close (slotp->pcsc.req_fd);
1209   close (slotp->pcsc.rsp_fd);
1210   slotp->pcsc.req_fd = -1;
1211   slotp->pcsc.rsp_fd = -1;
1212   if (slotp->pcsc.pid != -1)
1213     kill (slotp->pcsc.pid, SIGTERM);
1214   slotp->pcsc.pid = (pid_t)(-1);
1215   slotp->used = 0;
1216   return sw;
1217 }
1218 #endif /*NEED_PCSC_WRAPPER*/
1219
1220
1221 /* Send the APDU of length APDULEN to SLOT and return a maximum of
1222    *BUFLEN data in BUFFER, the actual returned size will be stored at
1223    BUFLEN.  Returns: A status word. */
1224 static int
1225 pcsc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
1226                 unsigned char *buffer, size_t *buflen,
1227                 pininfo_t *pininfo)
1228 {
1229 #ifdef NEED_PCSC_WRAPPER
1230   return pcsc_send_apdu_wrapped (slot, apdu, apdulen, buffer, buflen, pininfo);
1231 #else
1232   return pcsc_send_apdu_direct (slot, apdu, apdulen, buffer, buflen, pininfo);
1233 #endif
1234 }
1235
1236
1237 #ifndef NEED_PCSC_WRAPPER
1238 static int
1239 control_pcsc_direct (int slot, pcsc_dword_t ioctl_code,
1240                      const unsigned char *cntlbuf, size_t len,
1241                      unsigned char *buffer, pcsc_dword_t *buflen)
1242 {
1243   long err;
1244
1245   err = pcsc_control (reader_table[slot].pcsc.card, ioctl_code,
1246                       cntlbuf, len, buffer, *buflen, buflen);
1247   if (err)
1248     {
1249       log_error ("pcsc_control failed: %s (0x%lx)\n",
1250                  pcsc_error_string (err), err);
1251       return pcsc_error_to_sw (err);
1252     }
1253
1254   return 0;
1255 }
1256 #endif /*!NEED_PCSC_WRAPPER*/
1257
1258
1259 #ifdef NEED_PCSC_WRAPPER
1260 static int
1261 control_pcsc_wrapped (int slot, pcsc_dword_t ioctl_code,
1262                       const unsigned char *cntlbuf, size_t len,
1263                       unsigned char *buffer, pcsc_dword_t *buflen)
1264 {
1265   long err = PCSC_E_NOT_TRANSACTED;
1266   reader_table_t slotp;
1267   unsigned char msgbuf[9];
1268   int i, n;
1269   size_t full_len;
1270
1271   slotp = reader_table + slot;
1272
1273   msgbuf[0] = 0x06; /* CONTROL command. */
1274   msgbuf[1] = ((len + 4) >> 24);
1275   msgbuf[2] = ((len + 4) >> 16);
1276   msgbuf[3] = ((len + 4) >>  8);
1277   msgbuf[4] = ((len + 4)      );
1278   msgbuf[5] = (ioctl_code >> 24);
1279   msgbuf[6] = (ioctl_code >> 16);
1280   msgbuf[7] = (ioctl_code >>  8);
1281   msgbuf[8] = (ioctl_code      );
1282   if ( writen (slotp->pcsc.req_fd, msgbuf, 9)
1283        || writen (slotp->pcsc.req_fd, cntlbuf, len))
1284     {
1285       log_error ("error sending PC/SC CONTROL request: %s\n",
1286                  strerror (errno));
1287       goto command_failed;
1288     }
1289
1290   /* Read the response. */
1291   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1292     {
1293       log_error ("error receiving PC/SC CONTROL response: %s\n",
1294                  i? strerror (errno) : "premature EOF");
1295       goto command_failed;
1296     }
1297   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1298   if (msgbuf[0] != 0x81 || len < 4)
1299     {
1300       log_error ("invalid response header from PC/SC received\n");
1301       goto command_failed;
1302     }
1303   len -= 4; /* Already read the error code. */
1304   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
1305                        | (msgbuf[7] << 8 ) | msgbuf[8]);
1306   if (err)
1307     {
1308       log_error ("pcsc_control failed: %s (0x%lx)\n",
1309                  pcsc_error_string (err), err);
1310       return pcsc_error_to_sw (err);
1311     }
1312
1313   full_len = len;
1314
1315   n = *buflen < len ? *buflen : len;
1316   if ((i=readn (slotp->pcsc.rsp_fd, buffer, n, &len)) || len != n)
1317     {
1318       log_error ("error receiving PC/SC CONTROL response: %s\n",
1319                  i? strerror (errno) : "premature EOF");
1320       goto command_failed;
1321     }
1322   *buflen = n;
1323
1324   full_len -= len;
1325   if (full_len)
1326     {
1327       log_error ("pcsc_send_apdu: provided buffer too short - truncated\n");
1328       err = PCSC_E_INVALID_VALUE;
1329     }
1330   /* We need to read any rest of the response, to keep the
1331      protocol running.  */
1332   while (full_len)
1333     {
1334       unsigned char dummybuf[128];
1335
1336       n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
1337       if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
1338         {
1339           log_error ("error receiving PC/SC CONTROL response: %s\n",
1340                      i? strerror (errno) : "premature EOF");
1341           goto command_failed;
1342         }
1343       full_len -= n;
1344     }
1345
1346   if (!err)
1347     return 0;
1348
1349  command_failed:
1350   close (slotp->pcsc.req_fd);
1351   close (slotp->pcsc.rsp_fd);
1352   slotp->pcsc.req_fd = -1;
1353   slotp->pcsc.rsp_fd = -1;
1354   if (slotp->pcsc.pid != -1)
1355     kill (slotp->pcsc.pid, SIGTERM);
1356   slotp->pcsc.pid = (pid_t)(-1);
1357   slotp->used = 0;
1358   return pcsc_error_to_sw (err);
1359 }
1360 #endif /*NEED_PCSC_WRAPPER*/
1361
1362
1363
1364 /* Do some control with the value of IOCTL_CODE to the card inserted
1365    to SLOT.  Input buffer is specified by CNTLBUF of length LEN.
1366    Output buffer is specified by BUFFER of length *BUFLEN, and the
1367    actual output size will be stored at BUFLEN.  Returns: A status word.
1368    This routine is used for PIN pad input support.  */
1369 static int
1370 control_pcsc (int slot, pcsc_dword_t ioctl_code,
1371               const unsigned char *cntlbuf, size_t len,
1372               unsigned char *buffer, pcsc_dword_t *buflen)
1373 {
1374 #ifdef NEED_PCSC_WRAPPER
1375   return control_pcsc_wrapped (slot, ioctl_code, cntlbuf, len, buffer, buflen);
1376 #else
1377   return control_pcsc_direct (slot, ioctl_code, cntlbuf, len, buffer, buflen);
1378 #endif
1379 }
1380
1381
1382 #ifndef NEED_PCSC_WRAPPER
1383 static int
1384 close_pcsc_reader_direct (int slot)
1385 {
1386   pcsc_release_context (reader_table[slot].pcsc.context);
1387   xfree (reader_table[slot].rdrname);
1388   reader_table[slot].rdrname = NULL;
1389   reader_table[slot].used = 0;
1390   return 0;
1391 }
1392 #endif /*!NEED_PCSC_WRAPPER*/
1393
1394
1395 #ifdef NEED_PCSC_WRAPPER
1396 static int
1397 close_pcsc_reader_wrapped (int slot)
1398 {
1399   long err;
1400   reader_table_t slotp;
1401   size_t len;
1402   int i;
1403   unsigned char msgbuf[9];
1404
1405   slotp = reader_table + slot;
1406
1407   if (slotp->pcsc.req_fd == -1
1408       || slotp->pcsc.rsp_fd == -1
1409       || slotp->pcsc.pid == (pid_t)(-1) )
1410     {
1411       log_error ("close_pcsc_reader: pcsc-wrapper not running\n");
1412       return 0;
1413     }
1414
1415   msgbuf[0] = 0x02; /* CLOSE command. */
1416   len = 0;
1417   msgbuf[1] = (len >> 24);
1418   msgbuf[2] = (len >> 16);
1419   msgbuf[3] = (len >>  8);
1420   msgbuf[4] = (len      );
1421   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
1422     {
1423       log_error ("error sending PC/SC CLOSE request: %s\n",
1424                  strerror (errno));
1425       goto command_failed;
1426     }
1427
1428   /* Read the response. */
1429   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1430     {
1431       log_error ("error receiving PC/SC CLOSE response: %s\n",
1432                  i? strerror (errno) : "premature EOF");
1433       goto command_failed;
1434     }
1435   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1436   if (msgbuf[0] != 0x81 || len < 4)
1437     {
1438       log_error ("invalid response header from PC/SC received\n");
1439       goto command_failed;
1440     }
1441   len -= 4; /* Already read the error code. */
1442   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
1443                        | (msgbuf[7] << 8 ) | msgbuf[8]);
1444   if (err)
1445     log_error ("pcsc_close failed: %s (0x%lx)\n",
1446                pcsc_error_string (err), err);
1447
1448   /* We will close the wrapper in any case - errors are merely
1449      informational. */
1450
1451  command_failed:
1452   close (slotp->pcsc.req_fd);
1453   close (slotp->pcsc.rsp_fd);
1454   slotp->pcsc.req_fd = -1;
1455   slotp->pcsc.rsp_fd = -1;
1456   if (slotp->pcsc.pid != -1)
1457     kill (slotp->pcsc.pid, SIGTERM);
1458   slotp->pcsc.pid = (pid_t)(-1);
1459   slotp->used = 0;
1460   return 0;
1461 }
1462 #endif /*NEED_PCSC_WRAPPER*/
1463
1464
1465 static int
1466 close_pcsc_reader (int slot)
1467 {
1468 #ifdef NEED_PCSC_WRAPPER
1469   return close_pcsc_reader_wrapped (slot);
1470 #else
1471   return close_pcsc_reader_direct (slot);
1472 #endif
1473 }
1474
1475
1476 /* Connect a PC/SC card.  */
1477 #ifndef NEED_PCSC_WRAPPER
1478 static int
1479 connect_pcsc_card (int slot)
1480 {
1481   long err;
1482
1483   assert (slot >= 0 && slot < MAX_READER);
1484
1485   if (reader_table[slot].pcsc.card)
1486     return SW_HOST_ALREADY_CONNECTED;
1487
1488   reader_table[slot].atrlen = 0;
1489   reader_table[slot].last_status = 0;
1490   reader_table[slot].is_t0 = 0;
1491
1492   err = pcsc_connect (reader_table[slot].pcsc.context,
1493                       reader_table[slot].rdrname,
1494                       PCSC_SHARE_EXCLUSIVE,
1495                       PCSC_PROTOCOL_T0|PCSC_PROTOCOL_T1,
1496                       &reader_table[slot].pcsc.card,
1497                       &reader_table[slot].pcsc.protocol);
1498   if (err)
1499     {
1500       reader_table[slot].pcsc.card = 0;
1501       if (err != PCSC_E_NO_SMARTCARD)
1502         log_error ("pcsc_connect failed: %s (0x%lx)\n",
1503                    pcsc_error_string (err), err);
1504     }
1505   else
1506     {
1507       char reader[250];
1508       pcsc_dword_t readerlen, atrlen;
1509       long card_state, card_protocol;
1510
1511       atrlen = DIM (reader_table[0].atr);
1512       readerlen = sizeof reader -1 ;
1513       err = pcsc_status (reader_table[slot].pcsc.card,
1514                          reader, &readerlen,
1515                          &card_state, &card_protocol,
1516                          reader_table[slot].atr, &atrlen);
1517       if (err)
1518         log_error ("pcsc_status failed: %s (0x%lx) %lu\n",
1519                    pcsc_error_string (err), err, readerlen);
1520       else
1521         {
1522           if (atrlen > DIM (reader_table[0].atr))
1523             log_bug ("ATR returned by pcsc_status is too large\n");
1524           reader_table[slot].atrlen = atrlen;
1525           /* If we got to here we know that a card is present
1526              and usable.  Remember this.  */
1527           reader_table[slot].last_status = (   APDU_CARD_USABLE
1528                                              | APDU_CARD_PRESENT
1529                                              | APDU_CARD_ACTIVE);
1530           reader_table[slot].is_t0 = !!(card_protocol & PCSC_PROTOCOL_T0);
1531         }
1532     }
1533
1534   dump_reader_status (slot);
1535   return pcsc_error_to_sw (err);
1536 }
1537 #endif /*!NEED_PCSC_WRAPPER*/
1538
1539
1540 /* Disconnect a PC/SC card.  Note that this succeeds even if the card
1541    is not connected.  */
1542 #ifndef NEED_PCSC_WRAPPER
1543 static int
1544 disconnect_pcsc_card (int slot)
1545 {
1546   long err;
1547
1548   assert (slot >= 0 && slot < MAX_READER);
1549
1550   if (!reader_table[slot].pcsc.card)
1551     return 0;
1552
1553   err = pcsc_disconnect (reader_table[slot].pcsc.card, PCSC_LEAVE_CARD);
1554   if (err)
1555     {
1556       log_error ("pcsc_disconnect failed: %s (0x%lx)\n",
1557                  pcsc_error_string (err), err);
1558       return SW_HOST_CARD_IO_ERROR;
1559     }
1560   reader_table[slot].pcsc.card = 0;
1561   return 0;
1562 }
1563 #endif /*!NEED_PCSC_WRAPPER*/
1564
1565
1566 #ifndef NEED_PCSC_WRAPPER
1567 static int
1568 reset_pcsc_reader_direct (int slot)
1569 {
1570   int sw;
1571
1572   sw = disconnect_pcsc_card (slot);
1573   if (!sw)
1574     sw = connect_pcsc_card (slot);
1575
1576   return sw;
1577 }
1578 #endif /*NEED_PCSC_WRAPPER*/
1579
1580
1581 #ifdef NEED_PCSC_WRAPPER
1582 static int
1583 reset_pcsc_reader_wrapped (int slot)
1584 {
1585   long err;
1586   reader_table_t slotp;
1587   size_t len;
1588   int i, n;
1589   unsigned char msgbuf[9];
1590   unsigned int dummy_status;
1591   int sw = SW_HOST_CARD_IO_ERROR;
1592
1593   slotp = reader_table + slot;
1594
1595   if (slotp->pcsc.req_fd == -1
1596       || slotp->pcsc.rsp_fd == -1
1597       || slotp->pcsc.pid == (pid_t)(-1) )
1598     {
1599       log_error ("pcsc_get_status: pcsc-wrapper not running\n");
1600       return sw;
1601     }
1602
1603   msgbuf[0] = 0x05; /* RESET command. */
1604   len = 0;
1605   msgbuf[1] = (len >> 24);
1606   msgbuf[2] = (len >> 16);
1607   msgbuf[3] = (len >>  8);
1608   msgbuf[4] = (len      );
1609   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
1610     {
1611       log_error ("error sending PC/SC RESET request: %s\n",
1612                  strerror (errno));
1613       goto command_failed;
1614     }
1615
1616   /* Read the response. */
1617   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1618     {
1619       log_error ("error receiving PC/SC RESET response: %s\n",
1620                  i? strerror (errno) : "premature EOF");
1621       goto command_failed;
1622     }
1623   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1624   if (msgbuf[0] != 0x81 || len < 4)
1625     {
1626       log_error ("invalid response header from PC/SC received\n");
1627       goto command_failed;
1628     }
1629   len -= 4; /* Already read the error code. */
1630   if (len > DIM (slotp->atr))
1631     {
1632       log_error ("PC/SC returned a too large ATR (len=%lx)\n",
1633                  (unsigned long)len);
1634       sw = SW_HOST_GENERAL_ERROR;
1635       goto command_failed;
1636     }
1637   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
1638                        | (msgbuf[7] << 8 ) | msgbuf[8]);
1639   if (err)
1640     {
1641       log_error ("PC/SC RESET failed: %s (0x%lx)\n",
1642                  pcsc_error_string (err), err);
1643       /* If the error code is no smart card, we should not considere
1644          this a major error and close the wrapper.  */
1645       sw = pcsc_error_to_sw (err);
1646       if (err == PCSC_E_NO_SMARTCARD)
1647         return sw;
1648       goto command_failed;
1649     }
1650
1651   /* The open function may return a zero for the ATR length to
1652      indicate that no card is present.  */
1653   n = len;
1654   if (n)
1655     {
1656       if ((i=readn (slotp->pcsc.rsp_fd, slotp->atr, n, &len)) || len != n)
1657         {
1658           log_error ("error receiving PC/SC RESET response: %s\n",
1659                      i? strerror (errno) : "premature EOF");
1660           goto command_failed;
1661         }
1662     }
1663   slotp->atrlen = len;
1664
1665   /* Read the status so that IS_T0 will be set. */
1666   pcsc_get_status (slot, &dummy_status);
1667
1668   return 0;
1669
1670  command_failed:
1671   close (slotp->pcsc.req_fd);
1672   close (slotp->pcsc.rsp_fd);
1673   slotp->pcsc.req_fd = -1;
1674   slotp->pcsc.rsp_fd = -1;
1675   if (slotp->pcsc.pid != -1)
1676     kill (slotp->pcsc.pid, SIGTERM);
1677   slotp->pcsc.pid = (pid_t)(-1);
1678   slotp->used = 0;
1679   return sw;
1680 }
1681 #endif /* !NEED_PCSC_WRAPPER */
1682
1683
1684 /* Send an PC/SC reset command and return a status word on error or 0
1685    on success. */
1686 static int
1687 reset_pcsc_reader (int slot)
1688 {
1689 #ifdef NEED_PCSC_WRAPPER
1690   return reset_pcsc_reader_wrapped (slot);
1691 #else
1692   return reset_pcsc_reader_direct (slot);
1693 #endif
1694 }
1695
1696
1697 /* Examine reader specific parameters and initialize.  This is mostly
1698    for pinpad input.  Called at opening the connection to the reader.  */
1699 static int
1700 pcsc_vendor_specific_init (int slot)
1701 {
1702   unsigned char buf[256];
1703   pcsc_dword_t len;
1704   int sw;
1705   int vendor = 0;
1706   int product = 0;
1707   pcsc_dword_t get_tlv_ioctl = (pcsc_dword_t)-1;
1708   unsigned char *p;
1709
1710   len = sizeof (buf);
1711   sw = control_pcsc (slot, CM_IOCTL_GET_FEATURE_REQUEST, NULL, 0, buf, &len);
1712   if (sw)
1713     {
1714       log_error ("pcsc_vendor_specific_init: GET_FEATURE_REQUEST failed: %d\n",
1715                  sw);
1716       return SW_NOT_SUPPORTED;
1717     }
1718   else
1719     {
1720       p = buf;
1721       while (p < buf + len)
1722         {
1723           unsigned char code = *p++;
1724           int l = *p++;
1725           unsigned int v = 0;
1726
1727           if (l == 1)
1728             v = p[0];
1729           else if (l == 2)
1730             v = ((p[0] << 8) | p[1]);
1731           else if (l == 4)
1732             v = ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
1733
1734           if (code == FEATURE_VERIFY_PIN_DIRECT)
1735             reader_table[slot].pcsc.verify_ioctl = v;
1736           else if (code == FEATURE_MODIFY_PIN_DIRECT)
1737             reader_table[slot].pcsc.modify_ioctl = v;
1738           else if (code == FEATURE_GET_TLV_PROPERTIES)
1739             get_tlv_ioctl = v;
1740
1741           if (DBG_CARD_IO)
1742             log_debug ("feature: code=%02X, len=%d, v=%02X\n", code, l, v);
1743
1744           p += l;
1745         }
1746     }
1747
1748   /*
1749    * For system which doesn't support GET_TLV_PROPERTIES,
1750    * we put some heuristics here.
1751    */
1752   if (reader_table[slot].rdrname
1753       && strstr (reader_table[slot].rdrname, "SPRx32"))
1754     {
1755       reader_table[slot].is_spr532 = 1;
1756       reader_table[slot].pinpad_varlen_supported = 1;
1757       return 0;
1758     }
1759
1760   if (get_tlv_ioctl == (pcsc_dword_t)-1)
1761     return 0;
1762
1763   len = sizeof (buf);
1764   sw = control_pcsc (slot, get_tlv_ioctl, NULL, 0, buf, &len);
1765   if (sw)
1766     {
1767       log_error ("pcsc_vendor_specific_init: GET_TLV_IOCTL failed: %d\n", sw);
1768       return SW_NOT_SUPPORTED;
1769     }
1770
1771   p = buf;
1772   while (p < buf + len)
1773     {
1774       unsigned char tag = *p++;
1775       int l = *p++;
1776       unsigned int v = 0;
1777
1778       /* Umm... here is little endian, while the encoding above is big.  */
1779       if (l == 1)
1780         v = p[0];
1781       else if (l == 2)
1782         v = ((p[1] << 8) | p[0]);
1783       else if (l == 4)
1784         v = ((p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]);
1785
1786       if (tag == PCSCv2_PART10_PROPERTY_bMinPINSize)
1787         reader_table[slot].pcsc.pinmin = v;
1788       else if (tag == PCSCv2_PART10_PROPERTY_bMaxPINSize)
1789         reader_table[slot].pcsc.pinmax = v;
1790       else if (tag == PCSCv2_PART10_PROPERTY_wIdVendor)
1791         vendor = v;
1792       else if (tag == PCSCv2_PART10_PROPERTY_wIdProduct)
1793         product = v;
1794
1795       if (DBG_CARD_IO)
1796         log_debug ("TLV properties: tag=%02X, len=%d, v=%08X\n", tag, l, v);
1797
1798       p += l;
1799     }
1800
1801   if (vendor == VENDOR_VEGA && product == VEGA_ALPHA)
1802     {
1803       /*
1804        * Please read the comment of ccid_vendor_specific_init in
1805        * ccid-driver.c.
1806        */
1807       const unsigned char cmd[] = { '\xb5', '\x01', '\x00', '\x03', '\x00' };
1808       sw = control_pcsc (slot, CM_IOCTL_VENDOR_IFD_EXCHANGE,
1809                          cmd, sizeof (cmd), NULL, 0);
1810       if (sw)
1811         return SW_NOT_SUPPORTED;
1812     }
1813   else if (vendor == VENDOR_SCM && product == SCM_SPR532) /* SCM SPR532 */
1814     {
1815       reader_table[slot].is_spr532 = 1;
1816       reader_table[slot].pinpad_varlen_supported = 1;
1817     }
1818
1819   return 0;
1820 }
1821
1822
1823 /* Open the PC/SC reader without using the wrapper.  Returns -1 on
1824    error or a slot number for the reader.  */
1825 #ifndef NEED_PCSC_WRAPPER
1826 static int
1827 open_pcsc_reader_direct (const char *portstr)
1828 {
1829   long err;
1830   int slot;
1831   char *list = NULL;
1832   pcsc_dword_t nreader, listlen;
1833   char *p;
1834
1835   slot = new_reader_slot ();
1836   if (slot == -1)
1837     return -1;
1838
1839   /* Fixme: Allocating a context for each slot is not required.  One
1840      global context should be sufficient.  */
1841   err = pcsc_establish_context (PCSC_SCOPE_SYSTEM, NULL, NULL,
1842                                 &reader_table[slot].pcsc.context);
1843   if (err)
1844     {
1845       log_error ("pcsc_establish_context failed: %s (0x%lx)\n",
1846                  pcsc_error_string (err), err);
1847       reader_table[slot].used = 0;
1848       return -1;
1849     }
1850
1851   err = pcsc_list_readers (reader_table[slot].pcsc.context,
1852                            NULL, NULL, &nreader);
1853   if (!err)
1854     {
1855       list = xtrymalloc (nreader+1); /* Better add 1 for safety reasons. */
1856       if (!list)
1857         {
1858           log_error ("error allocating memory for reader list\n");
1859           pcsc_release_context (reader_table[slot].pcsc.context);
1860           reader_table[slot].used = 0;
1861           return -1 /*SW_HOST_OUT_OF_CORE*/;
1862         }
1863       err = pcsc_list_readers (reader_table[slot].pcsc.context,
1864                                NULL, list, &nreader);
1865     }
1866   if (err)
1867     {
1868       log_error ("pcsc_list_readers failed: %s (0x%lx)\n",
1869                  pcsc_error_string (err), err);
1870       pcsc_release_context (reader_table[slot].pcsc.context);
1871       reader_table[slot].used = 0;
1872       xfree (list);
1873       return -1;
1874     }
1875
1876   listlen = nreader;
1877   p = list;
1878   while (nreader)
1879     {
1880       if (!*p && !p[1])
1881         break;
1882       if (*p)
1883         log_info ("detected reader '%s'\n", p);
1884       if (nreader < (strlen (p)+1))
1885         {
1886           log_error ("invalid response from pcsc_list_readers\n");
1887           break;
1888         }
1889       nreader -= strlen (p)+1;
1890       p += strlen (p) + 1;
1891     }
1892
1893   reader_table[slot].rdrname = xtrymalloc (strlen (portstr? portstr : list)+1);
1894   if (!reader_table[slot].rdrname)
1895     {
1896       log_error ("error allocating memory for reader name\n");
1897       pcsc_release_context (reader_table[slot].pcsc.context);
1898       reader_table[slot].used = 0;
1899       return -1;
1900     }
1901   strcpy (reader_table[slot].rdrname, portstr? portstr : list);
1902   xfree (list);
1903   list = NULL;
1904
1905   reader_table[slot].pcsc.card = 0;
1906   reader_table[slot].atrlen = 0;
1907   reader_table[slot].last_status = 0;
1908
1909   reader_table[slot].connect_card = connect_pcsc_card;
1910   reader_table[slot].disconnect_card = disconnect_pcsc_card;
1911   reader_table[slot].close_reader = close_pcsc_reader;
1912   reader_table[slot].reset_reader = reset_pcsc_reader;
1913   reader_table[slot].get_status_reader = pcsc_get_status;
1914   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
1915   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
1916
1917   pcsc_vendor_specific_init (slot);
1918   dump_reader_status (slot);
1919   return slot;
1920 }
1921 #endif /*!NEED_PCSC_WRAPPER */
1922
1923
1924 /* Open the PC/SC reader using the pcsc_wrapper program.  This is
1925    needed to cope with different thread models and other peculiarities
1926    of libpcsclite. */
1927 #ifdef NEED_PCSC_WRAPPER
1928 static int
1929 open_pcsc_reader_wrapped (const char *portstr)
1930 {
1931   int slot;
1932   reader_table_t slotp;
1933   int fd, rp[2], wp[2];
1934   int n, i;
1935   pid_t pid;
1936   size_t len;
1937   unsigned char msgbuf[9];
1938   int err;
1939   unsigned int dummy_status;
1940
1941   /* Note that we use the constant and not the fucntion because this
1942      code won't be be used under Windows.  */
1943   const char *wrapperpgm = GNUPG_LIBEXECDIR "/gnupg-pcsc-wrapper";
1944
1945   if (access (wrapperpgm, X_OK))
1946     {
1947       log_error ("can't run PC/SC access module '%s': %s\n",
1948                  wrapperpgm, strerror (errno));
1949       return -1;
1950     }
1951
1952   slot = new_reader_slot ();
1953   if (slot == -1)
1954     return -1;
1955   slotp = reader_table + slot;
1956
1957   /* Fire up the PC/SCc wrapper.  We don't use any fork/exec code from
1958      the common directy but implement it directly so that this file
1959      may still be source copied. */
1960
1961   if (pipe (rp) == -1)
1962     {
1963       log_error ("error creating a pipe: %s\n", strerror (errno));
1964       slotp->used = 0;
1965       return -1;
1966     }
1967   if (pipe (wp) == -1)
1968     {
1969       log_error ("error creating a pipe: %s\n", strerror (errno));
1970       close (rp[0]);
1971       close (rp[1]);
1972       slotp->used = 0;
1973       return -1;
1974     }
1975
1976   pid = fork ();
1977   if (pid == -1)
1978     {
1979       log_error ("error forking process: %s\n", strerror (errno));
1980       close (rp[0]);
1981       close (rp[1]);
1982       close (wp[0]);
1983       close (wp[1]);
1984       slotp->used = 0;
1985       return -1;
1986     }
1987   slotp->pcsc.pid = pid;
1988
1989   if (!pid)
1990     { /*
1991          === Child ===
1992        */
1993
1994       /* Double fork. */
1995       pid = fork ();
1996       if (pid == -1)
1997         _exit (31);
1998       if (pid)
1999         _exit (0); /* Immediate exit this parent, so that the child
2000                       gets cleaned up by the init process. */
2001
2002       /* Connect our pipes. */
2003       if (wp[0] != 0 && dup2 (wp[0], 0) == -1)
2004         log_fatal ("dup2 stdin failed: %s\n", strerror (errno));
2005       if (rp[1] != 1 && dup2 (rp[1], 1) == -1)
2006         log_fatal ("dup2 stdout failed: %s\n", strerror (errno));
2007
2008       /* Send stderr to the bit bucket. */
2009       fd = open ("/dev/null", O_WRONLY);
2010       if (fd == -1)
2011         log_fatal ("can't open '/dev/null': %s", strerror (errno));
2012       if (fd != 2 && dup2 (fd, 2) == -1)
2013         log_fatal ("dup2 stderr failed: %s\n", strerror (errno));
2014
2015       /* Close all other files. */
2016       close_all_fds (3, NULL);
2017
2018       execl (wrapperpgm,
2019              "pcsc-wrapper",
2020              "--",
2021              "1", /* API version */
2022              opt.pcsc_driver, /* Name of the PC/SC library. */
2023               NULL);
2024       _exit (31);
2025     }
2026
2027   /*
2028      === Parent ===
2029    */
2030   close (wp[0]);
2031   close (rp[1]);
2032   slotp->pcsc.req_fd = wp[1];
2033   slotp->pcsc.rsp_fd = rp[0];
2034
2035   /* Wait for the intermediate child to terminate. */
2036 #ifdef USE_NPTH
2037 #define WAIT npth_waitpid
2038 #else
2039 #define WAIT waitpid
2040 #endif
2041   while ( (i=WAIT (pid, NULL, 0)) == -1 && errno == EINTR)
2042     ;
2043 #undef WAIT
2044
2045   /* Now send the open request. */
2046   msgbuf[0] = 0x01; /* OPEN command. */
2047   len = portstr? strlen (portstr):0;
2048   msgbuf[1] = (len >> 24);
2049   msgbuf[2] = (len >> 16);
2050   msgbuf[3] = (len >>  8);
2051   msgbuf[4] = (len      );
2052   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
2053        || (portstr && writen (slotp->pcsc.req_fd, portstr, len)))
2054     {
2055       log_error ("error sending PC/SC OPEN request: %s\n",
2056                  strerror (errno));
2057       goto command_failed;
2058     }
2059   /* Read the response. */
2060   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
2061     {
2062       log_error ("error receiving PC/SC OPEN response: %s\n",
2063                  i? strerror (errno) : "premature EOF");
2064       goto command_failed;
2065     }
2066   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
2067   if (msgbuf[0] != 0x81 || len < 4)
2068     {
2069       log_error ("invalid response header from PC/SC received\n");
2070       goto command_failed;
2071     }
2072   len -= 4; /* Already read the error code. */
2073   if (len > DIM (slotp->atr))
2074     {
2075       log_error ("PC/SC returned a too large ATR (len=%lx)\n",
2076                  (unsigned long)len);
2077       goto command_failed;
2078     }
2079   err = PCSC_ERR_MASK ((msgbuf[5] << 24) | (msgbuf[6] << 16)
2080                        | (msgbuf[7] << 8 ) | msgbuf[8]);
2081
2082   if (err)
2083     {
2084       log_error ("PC/SC OPEN failed: %s\n", pcsc_error_string (err));
2085       goto command_failed;
2086     }
2087
2088   slotp->last_status = 0;
2089
2090   /* The open request may return a zero for the ATR length to
2091      indicate that no card is present.  */
2092   n = len;
2093   if (n)
2094     {
2095       if ((i=readn (slotp->pcsc.rsp_fd, slotp->atr, n, &len)) || len != n)
2096         {
2097           log_error ("error receiving PC/SC OPEN response: %s\n",
2098                      i? strerror (errno) : "premature EOF");
2099           goto command_failed;
2100         }
2101       /* If we got to here we know that a card is present
2102          and usable.  Thus remember this.  */
2103       slotp->last_status = (  APDU_CARD_USABLE
2104                             | APDU_CARD_PRESENT
2105                             | APDU_CARD_ACTIVE);
2106     }
2107   slotp->atrlen = len;
2108
2109   reader_table[slot].close_reader = close_pcsc_reader;
2110   reader_table[slot].reset_reader = reset_pcsc_reader;
2111   reader_table[slot].get_status_reader = pcsc_get_status;
2112   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
2113   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
2114
2115   pcsc_vendor_specific_init (slot);
2116
2117   /* Read the status so that IS_T0 will be set. */
2118   pcsc_get_status (slot, &dummy_status);
2119
2120   dump_reader_status (slot);
2121   return slot;
2122
2123  command_failed:
2124   close (slotp->pcsc.req_fd);
2125   close (slotp->pcsc.rsp_fd);
2126   slotp->pcsc.req_fd = -1;
2127   slotp->pcsc.rsp_fd = -1;
2128   if (slotp->pcsc.pid != -1)
2129     kill (slotp->pcsc.pid, SIGTERM);
2130   slotp->pcsc.pid = (pid_t)(-1);
2131   slotp->used = 0;
2132   /* There is no way to return SW. */
2133   return -1;
2134
2135 }
2136 #endif /*NEED_PCSC_WRAPPER*/
2137
2138
2139 static int
2140 open_pcsc_reader (const char *portstr)
2141 {
2142 #ifdef NEED_PCSC_WRAPPER
2143   return open_pcsc_reader_wrapped (portstr);
2144 #else
2145   return open_pcsc_reader_direct (portstr);
2146 #endif
2147 }
2148
2149
2150 /* Check whether the reader supports the ISO command code COMMAND
2151    on the pinpad.  Return 0 on success.  */
2152 static int
2153 check_pcsc_pinpad (int slot, int command, pininfo_t *pininfo)
2154 {
2155   int r;
2156
2157   pininfo->minlen = reader_table[slot].pcsc.pinmin;
2158   pininfo->maxlen = reader_table[slot].pcsc.pinmax;
2159
2160   if ((command == ISO7816_VERIFY && reader_table[slot].pcsc.verify_ioctl != 0)
2161       || (command == ISO7816_CHANGE_REFERENCE_DATA
2162           && reader_table[slot].pcsc.modify_ioctl != 0))
2163     r = 0;                       /* Success */
2164   else
2165     r = SW_NOT_SUPPORTED;
2166
2167   if (DBG_CARD_IO)
2168     log_debug ("check_pcsc_pinpad: command=%02X, r=%d\n",
2169                (unsigned int)command, r);
2170
2171   if (reader_table[slot].pinpad_varlen_supported)
2172     pininfo->fixedlen = 0;
2173
2174   return r;
2175 }
2176
2177 #define PIN_VERIFY_STRUCTURE_SIZE 24
2178 static int
2179 pcsc_pinpad_verify (int slot, int class, int ins, int p0, int p1,
2180                     pininfo_t *pininfo)
2181 {
2182   int sw;
2183   unsigned char *pin_verify;
2184   int len = PIN_VERIFY_STRUCTURE_SIZE + pininfo->fixedlen;
2185   unsigned char result[2];
2186   pcsc_dword_t resultlen = 2;
2187   int no_lc;
2188
2189   if (!reader_table[slot].atrlen
2190       && (sw = reset_pcsc_reader (slot)))
2191     return sw;
2192
2193   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2194     return SW_NOT_SUPPORTED;
2195
2196   if (!pininfo->minlen)
2197     pininfo->minlen = 1;
2198   if (!pininfo->maxlen)
2199     pininfo->maxlen = 15;
2200
2201   /* Note that the 25 is the maximum value the SPR532 allows.  */
2202   if (pininfo->minlen < 1 || pininfo->minlen > 25
2203       || pininfo->maxlen < 1 || pininfo->maxlen > 25
2204       || pininfo->minlen > pininfo->maxlen)
2205     return SW_HOST_INV_VALUE;
2206
2207   pin_verify = xtrymalloc (len);
2208   if (!pin_verify)
2209     return SW_HOST_OUT_OF_CORE;
2210
2211   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2212
2213   pin_verify[0] = 0x00; /* bTimeOut */
2214   pin_verify[1] = 0x00; /* bTimeOut2 */
2215   pin_verify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2216   pin_verify[3] = pininfo->fixedlen; /* bmPINBlockString */
2217   pin_verify[4] = 0x00; /* bmPINLengthFormat */
2218   pin_verify[5] = pininfo->maxlen; /* wPINMaxExtraDigit */
2219   pin_verify[6] = pininfo->minlen; /* wPINMaxExtraDigit */
2220   pin_verify[7] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2221   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2222     pin_verify[7] |= 0x01; /* Max size reached.  */
2223   pin_verify[8] = 0x01; /* bNumberMessage: One message */
2224   pin_verify[9] =  0x09; /* wLangId: 0x0409: US English */
2225   pin_verify[10] = 0x04; /* wLangId: 0x0409: US English */
2226   pin_verify[11] = 0x00; /* bMsgIndex */
2227   pin_verify[12] = 0x00; /* bTeoPrologue[0] */
2228   pin_verify[13] = 0x00; /* bTeoPrologue[1] */
2229   pin_verify[14] = pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2230   pin_verify[15] = pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2231   pin_verify[16] = 0x00; /* ulDataLength */
2232   pin_verify[17] = 0x00; /* ulDataLength */
2233   pin_verify[18] = 0x00; /* ulDataLength */
2234   pin_verify[19] = class; /* abData[0] */
2235   pin_verify[20] = ins; /* abData[1] */
2236   pin_verify[21] = p0; /* abData[2] */
2237   pin_verify[22] = p1; /* abData[3] */
2238   pin_verify[23] = pininfo->fixedlen; /* abData[4] */
2239   if (pininfo->fixedlen)
2240     memset (&pin_verify[24], 0xff, pininfo->fixedlen);
2241   else if (no_lc)
2242     len--;
2243
2244   if (DBG_CARD_IO)
2245     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2246                class, ins, p0, p1, len, pininfo->maxlen);
2247
2248   sw = control_pcsc (slot, reader_table[slot].pcsc.verify_ioctl,
2249                      pin_verify, len, result, &resultlen);
2250   xfree (pin_verify);
2251   if (sw || resultlen < 2)
2252     return sw? sw : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2253   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2254     {
2255       log_error ("control_pcsc failed: %d\n", sw);
2256       return sw? sw: SW_HOST_INCOMPLETE_CARD_RESPONSE;
2257     }
2258   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2259   if (DBG_CARD_IO)
2260     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2261   return sw;
2262 }
2263
2264
2265 #define PIN_MODIFY_STRUCTURE_SIZE 29
2266 static int
2267 pcsc_pinpad_modify (int slot, int class, int ins, int p0, int p1,
2268                     pininfo_t *pininfo)
2269 {
2270   int sw;
2271   unsigned char *pin_modify;
2272   int len = PIN_MODIFY_STRUCTURE_SIZE + 2 * pininfo->fixedlen;
2273   unsigned char result[2];
2274   pcsc_dword_t resultlen = 2;
2275   int no_lc;
2276
2277   if (!reader_table[slot].atrlen
2278       && (sw = reset_pcsc_reader (slot)))
2279     return sw;
2280
2281   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2282     return SW_NOT_SUPPORTED;
2283
2284   if (!pininfo->minlen)
2285     pininfo->minlen = 1;
2286   if (!pininfo->maxlen)
2287     pininfo->maxlen = 15;
2288
2289   /* Note that the 25 is the maximum value the SPR532 allows.  */
2290   if (pininfo->minlen < 1 || pininfo->minlen > 25
2291       || pininfo->maxlen < 1 || pininfo->maxlen > 25
2292       || pininfo->minlen > pininfo->maxlen)
2293     return SW_HOST_INV_VALUE;
2294
2295   pin_modify = xtrymalloc (len);
2296   if (!pin_modify)
2297     return SW_HOST_OUT_OF_CORE;
2298
2299   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2300
2301   pin_modify[0] = 0x00; /* bTimeOut */
2302   pin_modify[1] = 0x00; /* bTimeOut2 */
2303   pin_modify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2304   pin_modify[3] = pininfo->fixedlen; /* bmPINBlockString */
2305   pin_modify[4] = 0x00; /* bmPINLengthFormat */
2306   pin_modify[5] = 0x00; /* bInsertionOffsetOld */
2307   pin_modify[6] = pininfo->fixedlen; /* bInsertionOffsetNew */
2308   pin_modify[7] = pininfo->maxlen; /* wPINMaxExtraDigit */
2309   pin_modify[8] = pininfo->minlen; /* wPINMaxExtraDigit */
2310   pin_modify[9] = (p0 == 0 ? 0x03 : 0x01);
2311                   /* bConfirmPIN
2312                    *    0x00: new PIN once
2313                    *    0x01: new PIN twice (confirmation)
2314                    *    0x02: old PIN and new PIN once
2315                    *    0x03: old PIN and new PIN twice (confirmation)
2316                    */
2317   pin_modify[10] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2318   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2319     pin_modify[10] |= 0x01; /* Max size reached.  */
2320   pin_modify[11] = 0x03; /* bNumberMessage: Three messages */
2321   pin_modify[12] = 0x09; /* wLangId: 0x0409: US English */
2322   pin_modify[13] = 0x04; /* wLangId: 0x0409: US English */
2323   pin_modify[14] = 0x00; /* bMsgIndex1 */
2324   pin_modify[15] = 0x01; /* bMsgIndex2 */
2325   pin_modify[16] = 0x02; /* bMsgIndex3 */
2326   pin_modify[17] = 0x00; /* bTeoPrologue[0] */
2327   pin_modify[18] = 0x00; /* bTeoPrologue[1] */
2328   pin_modify[19] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2329   pin_modify[20] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2330   pin_modify[21] = 0x00; /* ulDataLength */
2331   pin_modify[22] = 0x00; /* ulDataLength */
2332   pin_modify[23] = 0x00; /* ulDataLength */
2333   pin_modify[24] = class; /* abData[0] */
2334   pin_modify[25] = ins; /* abData[1] */
2335   pin_modify[26] = p0; /* abData[2] */
2336   pin_modify[27] = p1; /* abData[3] */
2337   pin_modify[28] = 2 * pininfo->fixedlen; /* abData[4] */
2338   if (pininfo->fixedlen)
2339     memset (&pin_modify[29], 0xff, 2 * pininfo->fixedlen);
2340   else if (no_lc)
2341     len--;
2342
2343   if (DBG_CARD_IO)
2344     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2345                class, ins, p0, p1, len, (int)pininfo->maxlen);
2346
2347   sw = control_pcsc (slot, reader_table[slot].pcsc.modify_ioctl,
2348                      pin_modify, len, result, &resultlen);
2349   xfree (pin_modify);
2350   if (sw || resultlen < 2)
2351     {
2352       log_error ("control_pcsc failed: %d\n", sw);
2353       return sw? sw : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2354     }
2355   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2356   if (DBG_CARD_IO)
2357     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2358   return sw;
2359 }
2360 \f
2361 #ifdef HAVE_LIBUSB
2362 /*
2363      Internal CCID driver interface.
2364  */
2365
2366
2367 static void
2368 dump_ccid_reader_status (int slot)
2369 {
2370   log_info ("reader slot %d: using ccid driver\n", slot);
2371 }
2372
2373 static int
2374 close_ccid_reader (int slot)
2375 {
2376   ccid_close_reader (reader_table[slot].ccid.handle);
2377   reader_table[slot].used = 0;
2378   return 0;
2379 }
2380
2381
2382 static int
2383 shutdown_ccid_reader (int slot)
2384 {
2385   ccid_shutdown_reader (reader_table[slot].ccid.handle);
2386   return 0;
2387 }
2388
2389
2390 static int
2391 reset_ccid_reader (int slot)
2392 {
2393   int err;
2394   reader_table_t slotp = reader_table + slot;
2395   unsigned char atr[33];
2396   size_t atrlen;
2397
2398   err = ccid_get_atr (slotp->ccid.handle, atr, sizeof atr, &atrlen);
2399   if (err)
2400     return err;
2401   /* If the reset was successful, update the ATR. */
2402   assert (sizeof slotp->atr >= sizeof atr);
2403   slotp->atrlen = atrlen;
2404   memcpy (slotp->atr, atr, atrlen);
2405   dump_reader_status (slot);
2406   return 0;
2407 }
2408
2409
2410 static int
2411 set_progress_cb_ccid_reader (int slot, gcry_handler_progress_t cb, void *cb_arg)
2412 {
2413   reader_table_t slotp = reader_table + slot;
2414
2415   return ccid_set_progress_cb (slotp->ccid.handle, cb, cb_arg);
2416 }
2417
2418
2419 static int
2420 get_status_ccid (int slot, unsigned int *status)
2421 {
2422   int rc;
2423   int bits;
2424
2425   rc = ccid_slot_status (reader_table[slot].ccid.handle, &bits);
2426   if (rc)
2427     return rc;
2428
2429   if (bits == 0)
2430     *status = (APDU_CARD_USABLE|APDU_CARD_PRESENT|APDU_CARD_ACTIVE);
2431   else if (bits == 1)
2432     *status = APDU_CARD_PRESENT;
2433   else
2434     *status = 0;
2435
2436   return 0;
2437 }
2438
2439
2440 /* Actually send the APDU of length APDULEN to SLOT and return a
2441    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2442    set to BUFLEN.  Returns: Internal CCID driver error code. */
2443 static int
2444 send_apdu_ccid (int slot, unsigned char *apdu, size_t apdulen,
2445                 unsigned char *buffer, size_t *buflen,
2446                 pininfo_t *pininfo)
2447 {
2448   long err;
2449   size_t maxbuflen;
2450
2451   /* If we don't have an ATR, we need to reset the reader first. */
2452   if (!reader_table[slot].atrlen
2453       && (err = reset_ccid_reader (slot)))
2454     return err;
2455
2456   if (DBG_CARD_IO)
2457     log_printhex (" raw apdu:", apdu, apdulen);
2458
2459   maxbuflen = *buflen;
2460   if (pininfo)
2461     err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2462                                   apdu, apdulen, pininfo,
2463                                   buffer, maxbuflen, buflen);
2464   else
2465     err = ccid_transceive (reader_table[slot].ccid.handle,
2466                            apdu, apdulen,
2467                            buffer, maxbuflen, buflen);
2468   if (err)
2469     log_error ("ccid_transceive failed: (0x%lx)\n",
2470                err);
2471
2472   return err;
2473 }
2474
2475
2476 /* Check whether the CCID reader supports the ISO command code COMMAND
2477    on the pinpad.  Return 0 on success.  For a description of the pin
2478    parameters, see ccid-driver.c */
2479 static int
2480 check_ccid_pinpad (int slot, int command, pininfo_t *pininfo)
2481 {
2482   unsigned char apdu[] = { 0, 0, 0, 0x81 };
2483
2484   apdu[1] = command;
2485   return ccid_transceive_secure (reader_table[slot].ccid.handle, apdu,
2486                                  sizeof apdu, pininfo, NULL, 0, NULL);
2487 }
2488
2489
2490 static int
2491 ccid_pinpad_operation (int slot, int class, int ins, int p0, int p1,
2492                        pininfo_t *pininfo)
2493 {
2494   unsigned char apdu[4];
2495   int err, sw;
2496   unsigned char result[2];
2497   size_t resultlen = 2;
2498
2499   apdu[0] = class;
2500   apdu[1] = ins;
2501   apdu[2] = p0;
2502   apdu[3] = p1;
2503   err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2504                                 apdu, sizeof apdu, pininfo,
2505                                 result, 2, &resultlen);
2506   if (err)
2507     return err;
2508
2509   if (resultlen < 2)
2510     return SW_HOST_INCOMPLETE_CARD_RESPONSE;
2511
2512   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2513   return sw;
2514 }
2515
2516
2517 /* Open the reader and try to read an ATR.  */
2518 static int
2519 open_ccid_reader (const char *portstr)
2520 {
2521   int err;
2522   int slot;
2523   reader_table_t slotp;
2524
2525   slot = new_reader_slot ();
2526   if (slot == -1)
2527     return -1;
2528   slotp = reader_table + slot;
2529
2530   err = ccid_open_reader (&slotp->ccid.handle, portstr);
2531   if (err)
2532     {
2533       slotp->used = 0;
2534       return -1;
2535     }
2536
2537   err = ccid_get_atr (slotp->ccid.handle,
2538                       slotp->atr, sizeof slotp->atr, &slotp->atrlen);
2539   if (err)
2540     {
2541       slotp->atrlen = 0;
2542       err = 0;
2543     }
2544   else
2545     {
2546       /* If we got to here we know that a card is present
2547          and usable.  Thus remember this.  */
2548       reader_table[slot].last_status = (APDU_CARD_USABLE
2549                                         | APDU_CARD_PRESENT
2550                                         | APDU_CARD_ACTIVE);
2551     }
2552
2553   reader_table[slot].close_reader = close_ccid_reader;
2554   reader_table[slot].shutdown_reader = shutdown_ccid_reader;
2555   reader_table[slot].reset_reader = reset_ccid_reader;
2556   reader_table[slot].get_status_reader = get_status_ccid;
2557   reader_table[slot].send_apdu_reader = send_apdu_ccid;
2558   reader_table[slot].check_pinpad = check_ccid_pinpad;
2559   reader_table[slot].dump_status_reader = dump_ccid_reader_status;
2560   reader_table[slot].set_progress_cb = set_progress_cb_ccid_reader;
2561   reader_table[slot].pinpad_verify = ccid_pinpad_operation;
2562   reader_table[slot].pinpad_modify = ccid_pinpad_operation;
2563   /* Our CCID reader code does not support T=0 at all, thus reset the
2564      flag.  */
2565   reader_table[slot].is_t0 = 0;
2566
2567   dump_reader_status (slot);
2568   return slot;
2569 }
2570
2571
2572
2573 #endif /* HAVE_LIBUSB */
2574
2575
2576 \f
2577 #ifdef USE_G10CODE_RAPDU
2578 /*
2579      The Remote APDU Interface.
2580
2581      This uses the Remote APDU protocol to contact a reader.
2582
2583      The port number is actually an index into the list of ports as
2584      returned via the protocol.
2585  */
2586
2587
2588 static int
2589 rapdu_status_to_sw (int status)
2590 {
2591   int rc;
2592
2593   switch (status)
2594     {
2595     case RAPDU_STATUS_SUCCESS:  rc = 0; break;
2596
2597     case RAPDU_STATUS_INVCMD:
2598     case RAPDU_STATUS_INVPROT:
2599     case RAPDU_STATUS_INVSEQ:
2600     case RAPDU_STATUS_INVCOOKIE:
2601     case RAPDU_STATUS_INVREADER:  rc = SW_HOST_INV_VALUE;  break;
2602
2603     case RAPDU_STATUS_TIMEOUT:  rc = SW_HOST_CARD_IO_ERROR; break;
2604     case RAPDU_STATUS_CARDIO:   rc = SW_HOST_CARD_IO_ERROR; break;
2605     case RAPDU_STATUS_NOCARD:   rc = SW_HOST_NO_CARD; break;
2606     case RAPDU_STATUS_CARDCHG:  rc = SW_HOST_NO_CARD; break;
2607     case RAPDU_STATUS_BUSY:     rc = SW_HOST_BUSY; break;
2608     case RAPDU_STATUS_NEEDRESET: rc = SW_HOST_CARD_INACTIVE; break;
2609
2610     default: rc = SW_HOST_GENERAL_ERROR; break;
2611     }
2612
2613   return rc;
2614 }
2615
2616
2617
2618 static int
2619 close_rapdu_reader (int slot)
2620 {
2621   rapdu_release (reader_table[slot].rapdu.handle);
2622   reader_table[slot].used = 0;
2623   return 0;
2624 }
2625
2626
2627 static int
2628 reset_rapdu_reader (int slot)
2629 {
2630   int err;
2631   reader_table_t slotp;
2632   rapdu_msg_t msg = NULL;
2633
2634   slotp = reader_table + slot;
2635
2636   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2637   if (err)
2638     {
2639       log_error ("sending rapdu command RESET failed: %s\n",
2640                 err < 0 ? strerror (errno): rapdu_strerror (err));
2641       rapdu_msg_release (msg);
2642       return rapdu_status_to_sw (err);
2643     }
2644   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2645   if (err)
2646     {
2647       log_error ("receiving rapdu message failed: %s\n",
2648                 err < 0 ? strerror (errno): rapdu_strerror (err));
2649       rapdu_msg_release (msg);
2650       return rapdu_status_to_sw (err);
2651     }
2652   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2653     {
2654       int sw = rapdu_status_to_sw (msg->cmd);
2655       log_error ("rapdu command RESET failed: %s\n",
2656                  rapdu_strerror (msg->cmd));
2657       rapdu_msg_release (msg);
2658       return sw;
2659     }
2660   if (msg->datalen > DIM (slotp->atr))
2661     {
2662       log_error ("ATR returned by the RAPDU layer is too large\n");
2663       rapdu_msg_release (msg);
2664       return SW_HOST_INV_VALUE;
2665     }
2666   slotp->atrlen = msg->datalen;
2667   memcpy (slotp->atr, msg->data, msg->datalen);
2668
2669   rapdu_msg_release (msg);
2670   return 0;
2671 }
2672
2673
2674 static int
2675 my_rapdu_get_status (int slot, unsigned int *status)
2676 {
2677   int err;
2678   reader_table_t slotp;
2679   rapdu_msg_t msg = NULL;
2680   int oldslot;
2681
2682   slotp = reader_table + slot;
2683
2684   oldslot = rapdu_set_reader (slotp->rapdu.handle, slot);
2685   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_STATUS);
2686   rapdu_set_reader (slotp->rapdu.handle, oldslot);
2687   if (err)
2688     {
2689       log_error ("sending rapdu command GET_STATUS failed: %s\n",
2690                 err < 0 ? strerror (errno): rapdu_strerror (err));
2691       return rapdu_status_to_sw (err);
2692     }
2693   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2694   if (err)
2695     {
2696       log_error ("receiving rapdu message failed: %s\n",
2697                 err < 0 ? strerror (errno): rapdu_strerror (err));
2698       rapdu_msg_release (msg);
2699       return rapdu_status_to_sw (err);
2700     }
2701   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2702     {
2703       int sw = rapdu_status_to_sw (msg->cmd);
2704       log_error ("rapdu command GET_STATUS failed: %s\n",
2705                  rapdu_strerror (msg->cmd));
2706       rapdu_msg_release (msg);
2707       return sw;
2708     }
2709   *status = msg->data[0];
2710
2711   rapdu_msg_release (msg);
2712   return 0;
2713 }
2714
2715
2716 /* Actually send the APDU of length APDULEN to SLOT and return a
2717    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2718    set to BUFLEN.  Returns: APDU error code. */
2719 static int
2720 my_rapdu_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
2721                     unsigned char *buffer, size_t *buflen,
2722                     pininfo_t *pininfo)
2723 {
2724   int err;
2725   reader_table_t slotp;
2726   rapdu_msg_t msg = NULL;
2727   size_t maxlen = *buflen;
2728
2729   slotp = reader_table + slot;
2730
2731   *buflen = 0;
2732   if (DBG_CARD_IO)
2733     log_printhex ("  APDU_data:", apdu, apdulen);
2734
2735   if (apdulen < 4)
2736     {
2737       log_error ("rapdu_send_apdu: APDU is too short\n");
2738       return SW_HOST_INV_VALUE;
2739     }
2740
2741   err = rapdu_send_apdu (slotp->rapdu.handle, apdu, apdulen);
2742   if (err)
2743     {
2744       log_error ("sending rapdu command APDU failed: %s\n",
2745                 err < 0 ? strerror (errno): rapdu_strerror (err));
2746       rapdu_msg_release (msg);
2747       return rapdu_status_to_sw (err);
2748     }
2749   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2750   if (err)
2751     {
2752       log_error ("receiving rapdu message failed: %s\n",
2753                 err < 0 ? strerror (errno): rapdu_strerror (err));
2754       rapdu_msg_release (msg);
2755       return rapdu_status_to_sw (err);
2756     }
2757   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2758     {
2759       int sw = rapdu_status_to_sw (msg->cmd);
2760       log_error ("rapdu command APDU failed: %s\n",
2761                  rapdu_strerror (msg->cmd));
2762       rapdu_msg_release (msg);
2763       return sw;
2764     }
2765
2766   if (msg->datalen > maxlen)
2767     {
2768       log_error ("rapdu response apdu too large\n");
2769       rapdu_msg_release (msg);
2770       return SW_HOST_INV_VALUE;
2771     }
2772
2773   *buflen = msg->datalen;
2774   memcpy (buffer, msg->data, msg->datalen);
2775
2776   rapdu_msg_release (msg);
2777   return 0;
2778 }
2779
2780 static int
2781 open_rapdu_reader (int portno,
2782                    const unsigned char *cookie, size_t length,
2783                    int (*readfnc) (void *opaque,
2784                                    void *buffer, size_t size),
2785                    void *readfnc_value,
2786                    int (*writefnc) (void *opaque,
2787                                     const void *buffer, size_t size),
2788                    void *writefnc_value,
2789                    void (*closefnc) (void *opaque),
2790                    void *closefnc_value)
2791 {
2792   int err;
2793   int slot;
2794   reader_table_t slotp;
2795   rapdu_msg_t msg = NULL;
2796
2797   slot = new_reader_slot ();
2798   if (slot == -1)
2799     return -1;
2800   slotp = reader_table + slot;
2801
2802   slotp->rapdu.handle = rapdu_new ();
2803   if (!slotp->rapdu.handle)
2804     {
2805       slotp->used = 0;
2806       return -1;
2807     }
2808
2809   rapdu_set_reader (slotp->rapdu.handle, portno);
2810
2811   rapdu_set_iofunc (slotp->rapdu.handle,
2812                     readfnc, readfnc_value,
2813                     writefnc, writefnc_value,
2814                     closefnc, closefnc_value);
2815   rapdu_set_cookie (slotp->rapdu.handle, cookie, length);
2816
2817   /* First try to get the current ATR, but if the card is inactive
2818      issue a reset instead.  */
2819   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_ATR);
2820   if (err == RAPDU_STATUS_NEEDRESET)
2821     err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2822   if (err)
2823     {
2824       log_info ("sending rapdu command GET_ATR/RESET failed: %s\n",
2825                 err < 0 ? strerror (errno): rapdu_strerror (err));
2826       goto failure;
2827     }
2828   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2829   if (err)
2830     {
2831       log_info ("receiving rapdu message failed: %s\n",
2832                 err < 0 ? strerror (errno): rapdu_strerror (err));
2833       goto failure;
2834     }
2835   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2836     {
2837       log_info ("rapdu command GET ATR failed: %s\n",
2838                  rapdu_strerror (msg->cmd));
2839       goto failure;
2840     }
2841   if (msg->datalen > DIM (slotp->atr))
2842     {
2843       log_error ("ATR returned by the RAPDU layer is too large\n");
2844       goto failure;
2845     }
2846   slotp->atrlen = msg->datalen;
2847   memcpy (slotp->atr, msg->data, msg->datalen);
2848
2849   reader_table[slot].close_reader = close_rapdu_reader;
2850   reader_table[slot].reset_reader = reset_rapdu_reader;
2851   reader_table[slot].get_status_reader = my_rapdu_get_status;
2852   reader_table[slot].send_apdu_reader = my_rapdu_send_apdu;
2853   reader_table[slot].check_pinpad = NULL;
2854   reader_table[slot].dump_status_reader = NULL;
2855   reader_table[slot].pinpad_verify = NULL;
2856   reader_table[slot].pinpad_modify = NULL;
2857
2858   dump_reader_status (slot);
2859   rapdu_msg_release (msg);
2860   return slot;
2861
2862  failure:
2863   rapdu_msg_release (msg);
2864   rapdu_release (slotp->rapdu.handle);
2865   slotp->used = 0;
2866   return -1;
2867 }
2868
2869 #endif /*USE_G10CODE_RAPDU*/
2870
2871
2872 \f
2873 /*
2874        Driver Access
2875  */
2876
2877
2878 static int
2879 lock_slot (int slot)
2880 {
2881 #ifdef USE_NPTH
2882   int err;
2883
2884   err = npth_mutex_lock (&reader_table[slot].lock);
2885   if (err)
2886     {
2887       log_error ("failed to acquire apdu lock: %s\n", strerror (err));
2888       return SW_HOST_LOCKING_FAILED;
2889     }
2890 #endif /*USE_NPTH*/
2891   return 0;
2892 }
2893
2894 static int
2895 trylock_slot (int slot)
2896 {
2897 #ifdef USE_NPTH
2898   int err;
2899
2900   err = npth_mutex_trylock (&reader_table[slot].lock);
2901   if (err == EBUSY)
2902     return SW_HOST_BUSY;
2903   else if (err)
2904     {
2905       log_error ("failed to acquire apdu lock: %s\n", strerror (err));
2906       return SW_HOST_LOCKING_FAILED;
2907     }
2908 #endif /*USE_NPTH*/
2909   return 0;
2910 }
2911
2912 static void
2913 unlock_slot (int slot)
2914 {
2915 #ifdef USE_NPTH
2916   int err;
2917
2918   err = npth_mutex_unlock (&reader_table[slot].lock);
2919   if (err)
2920     log_error ("failed to release apdu lock: %s\n", strerror (errno));
2921 #endif /*USE_NPTH*/
2922 }
2923
2924
2925 /* Open the reader and return an internal slot number or -1 on
2926    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
2927    the first USB reader.  For PC/SC the first listed reader). */
2928 int
2929 apdu_open_reader (const char *portstr)
2930 {
2931   static int pcsc_api_loaded, ct_api_loaded;
2932   int slot;
2933
2934   if (DBG_READER)
2935     log_debug ("enter: apdu_open_reader: portstr=%s\n", portstr);
2936
2937 #ifdef HAVE_LIBUSB
2938   if (!opt.disable_ccid)
2939     {
2940       static int once_available;
2941       int i;
2942       const char *s;
2943
2944       slot = open_ccid_reader (portstr);
2945       if (slot != -1)
2946         {
2947           once_available = 1;
2948           if (DBG_READER)
2949             log_debug ("leave: apdu_open_reader => slot=%d [ccid]\n", slot);
2950           return slot; /* got one */
2951         }
2952
2953       /* If we ever loaded successfully loaded a CCID reader we never
2954          want to fallback to another driver.  This solves a problem
2955          where ccid was used, the card unplugged and then scdaemon
2956          tries to find a new reader and will eventually try PC/SC over
2957          and over again.  To reset this flag "gpgconf --kill scdaemon"
2958          can be used.  */
2959       if (once_available)
2960         {
2961           if (DBG_READER)
2962             log_debug ("leave: apdu_open_reader => slot=-1 (once_avail)\n");
2963           return -1;
2964         }
2965
2966       /* If a CCID reader specification has been given, the user does
2967          not want a fallback to other drivers. */
2968       if (portstr)
2969         for (s=portstr, i=0; *s; s++)
2970           if (*s == ':' && (++i == 3))
2971             {
2972               if (DBG_READER)
2973                 log_debug ("leave: apdu_open_reader => slot=-1 (no ccid)\n");
2974               return -1;
2975             }
2976     }
2977
2978 #endif /* HAVE_LIBUSB */
2979
2980   if (opt.ctapi_driver && *opt.ctapi_driver)
2981     {
2982       int port = portstr? atoi (portstr) : 32768;
2983
2984       if (!ct_api_loaded)
2985         {
2986           void *handle;
2987
2988           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
2989           if (!handle)
2990             {
2991               log_error ("apdu_open_reader: failed to open driver: %s\n",
2992                          dlerror ());
2993               return -1;
2994             }
2995           CT_init = dlsym (handle, "CT_init");
2996           CT_data = dlsym (handle, "CT_data");
2997           CT_close = dlsym (handle, "CT_close");
2998           if (!CT_init || !CT_data || !CT_close)
2999             {
3000               log_error ("apdu_open_reader: invalid CT-API driver\n");
3001               dlclose (handle);
3002               return -1;
3003             }
3004           ct_api_loaded = 1;
3005         }
3006       return open_ct_reader (port);
3007     }
3008
3009
3010   /* No ctAPI configured, so lets try the PC/SC API */
3011   if (!pcsc_api_loaded)
3012     {
3013 #ifndef NEED_PCSC_WRAPPER
3014       void *handle;
3015
3016       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
3017       if (!handle)
3018         {
3019           log_error ("apdu_open_reader: failed to open driver '%s': %s\n",
3020                      opt.pcsc_driver, dlerror ());
3021           return -1;
3022         }
3023
3024       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
3025       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
3026       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
3027 #if defined(_WIN32) || defined(__CYGWIN__)
3028       if (!pcsc_list_readers)
3029         pcsc_list_readers    = dlsym (handle, "SCardListReadersA");
3030 #endif
3031       pcsc_get_status_change = dlsym (handle, "SCardGetStatusChange");
3032 #if defined(_WIN32) || defined(__CYGWIN__)
3033       if (!pcsc_get_status_change)
3034         pcsc_get_status_change = dlsym (handle, "SCardGetStatusChangeA");
3035 #endif
3036       pcsc_connect           = dlsym (handle, "SCardConnect");
3037 #if defined(_WIN32) || defined(__CYGWIN__)
3038       if (!pcsc_connect)
3039         pcsc_connect         = dlsym (handle, "SCardConnectA");
3040 #endif
3041       pcsc_reconnect         = dlsym (handle, "SCardReconnect");
3042 #if defined(_WIN32) || defined(__CYGWIN__)
3043       if (!pcsc_reconnect)
3044         pcsc_reconnect       = dlsym (handle, "SCardReconnectA");
3045 #endif
3046       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
3047       pcsc_status            = dlsym (handle, "SCardStatus");
3048 #if defined(_WIN32) || defined(__CYGWIN__)
3049       if (!pcsc_status)
3050         pcsc_status          = dlsym (handle, "SCardStatusA");
3051 #endif
3052       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
3053       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
3054       pcsc_transmit          = dlsym (handle, "SCardTransmit");
3055       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
3056       pcsc_control           = dlsym (handle, "SCardControl");
3057
3058       if (!pcsc_establish_context
3059           || !pcsc_release_context
3060           || !pcsc_list_readers
3061           || !pcsc_get_status_change
3062           || !pcsc_connect
3063           || !pcsc_reconnect
3064           || !pcsc_disconnect
3065           || !pcsc_status
3066           || !pcsc_begin_transaction
3067           || !pcsc_end_transaction
3068           || !pcsc_transmit
3069           || !pcsc_control
3070           /* || !pcsc_set_timeout */)
3071         {
3072           /* Note that set_timeout is currently not used and also not
3073              available under Windows. */
3074           log_error ("apdu_open_reader: invalid PC/SC driver "
3075                      "(%d%d%d%d%d%d%d%d%d%d%d%d%d)\n",
3076                      !!pcsc_establish_context,
3077                      !!pcsc_release_context,
3078                      !!pcsc_list_readers,
3079                      !!pcsc_get_status_change,
3080                      !!pcsc_connect,
3081                      !!pcsc_reconnect,
3082                      !!pcsc_disconnect,
3083                      !!pcsc_status,
3084                      !!pcsc_begin_transaction,
3085                      !!pcsc_end_transaction,
3086                      !!pcsc_transmit,
3087                      !!pcsc_set_timeout,
3088                      !!pcsc_control );
3089           dlclose (handle);
3090           return -1;
3091         }
3092 #endif /*!NEED_PCSC_WRAPPER*/
3093       pcsc_api_loaded = 1;
3094     }
3095
3096   slot = open_pcsc_reader (portstr);
3097
3098   if (DBG_READER)
3099     log_debug ("leave: apdu_open_reader => slot=%d [pc/sc]\n", slot);
3100   return slot;
3101 }
3102
3103
3104 /* Open an remote reader and return an internal slot number or -1 on
3105    error. This function is an alternative to apdu_open_reader and used
3106    with remote readers only.  Note that the supplied CLOSEFNC will
3107    only be called once and the slot will not be valid afther this.
3108
3109    If PORTSTR is NULL we default to the first availabe port.
3110 */
3111 int
3112 apdu_open_remote_reader (const char *portstr,
3113                          const unsigned char *cookie, size_t length,
3114                          int (*readfnc) (void *opaque,
3115                                          void *buffer, size_t size),
3116                          void *readfnc_value,
3117                          int (*writefnc) (void *opaque,
3118                                           const void *buffer, size_t size),
3119                          void *writefnc_value,
3120                          void (*closefnc) (void *opaque),
3121                          void *closefnc_value)
3122 {
3123 #ifdef USE_G10CODE_RAPDU
3124   return open_rapdu_reader (portstr? atoi (portstr) : 0,
3125                             cookie, length,
3126                             readfnc, readfnc_value,
3127                             writefnc, writefnc_value,
3128                             closefnc, closefnc_value);
3129 #else
3130   (void)portstr;
3131   (void)cookie;
3132   (void)length;
3133   (void)readfnc;
3134   (void)readfnc_value;
3135   (void)writefnc;
3136   (void)writefnc_value;
3137   (void)closefnc;
3138   (void)closefnc_value;
3139 #ifdef _WIN32
3140   errno = ENOENT;
3141 #else
3142   errno = ENOSYS;
3143 #endif
3144   return -1;
3145 #endif
3146 }
3147
3148
3149 int
3150 apdu_close_reader (int slot)
3151 {
3152   int sw;
3153
3154   if (DBG_READER)
3155     log_debug ("enter: apdu_close_reader: slot=%d\n", slot);
3156
3157   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3158     {
3159       if (DBG_READER)
3160         log_debug ("leave: apdu_close_reader => SW_HOST_NO_DRIVER\n");
3161       return SW_HOST_NO_DRIVER;
3162     }
3163   sw = apdu_disconnect (slot);
3164   if (sw)
3165     {
3166       if (DBG_READER)
3167         log_debug ("leave: apdu_close_reader => 0x%x (apdu_disconnect)\n", sw);
3168       return sw;
3169     }
3170   if (reader_table[slot].close_reader)
3171     {
3172       sw = reader_table[slot].close_reader (slot);
3173       if (DBG_READER)
3174         log_debug ("leave: apdu_close_reader => 0x%x (close_reader)\n", sw);
3175       return sw;
3176     }
3177   if (DBG_READER)
3178     log_debug ("leave: apdu_close_reader => SW_HOST_NOT_SUPPORTED\n");
3179   return SW_HOST_NOT_SUPPORTED;
3180 }
3181
3182
3183 /* Function suitable for a cleanup function to close all reader.  It
3184    should not be used if the reader will be opened again.  The reason
3185    for implementing this to properly close USB devices so that they
3186    will startup the next time without error. */
3187 void
3188 apdu_prepare_exit (void)
3189 {
3190   static int sentinel;
3191   int slot;
3192
3193   if (!sentinel)
3194     {
3195       sentinel = 1;
3196       for (slot = 0; slot < MAX_READER; slot++)
3197         if (reader_table[slot].used)
3198           {
3199             apdu_disconnect (slot);
3200             if (reader_table[slot].close_reader)
3201               reader_table[slot].close_reader (slot);
3202             reader_table[slot].used = 0;
3203           }
3204       sentinel = 0;
3205     }
3206 }
3207
3208
3209 /* Shutdown a reader; that is basically the same as a close but keeps
3210    the handle ready for later use. A apdu_reset_reader or apdu_connect
3211    should be used to get it active again. */
3212 int
3213 apdu_shutdown_reader (int slot)
3214 {
3215   int sw;
3216
3217   if (DBG_READER)
3218     log_debug ("enter: apdu_shutdown_reader: slot=%d\n", slot);
3219
3220   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3221     {
3222       if (DBG_READER)
3223         log_debug ("leave: apdu_shutdown_reader => SW_HOST_NO_DRIVER\n");
3224       return SW_HOST_NO_DRIVER;
3225     }
3226   sw = apdu_disconnect (slot);
3227   if (sw)
3228     {
3229       if (DBG_READER)
3230         log_debug ("leave: apdu_shutdown_reader => 0x%x (apdu_disconnect)\n",
3231                    sw);
3232       return sw;
3233     }
3234   if (reader_table[slot].shutdown_reader)
3235     {
3236       sw = reader_table[slot].shutdown_reader (slot);
3237       if (DBG_READER)
3238         log_debug ("leave: apdu_shutdown_reader => 0x%x (close_reader)\n", sw);
3239       return sw;
3240     }
3241   if (DBG_READER)
3242     log_debug ("leave: apdu_shutdown_reader => SW_HOST_NOT_SUPPORTED\n");
3243   return SW_HOST_NOT_SUPPORTED;
3244 }
3245
3246 /* Enumerate all readers and return information on whether this reader
3247    is in use.  The caller should start with SLOT set to 0 and
3248    increment it with each call until an error is returned. */
3249 int
3250 apdu_enum_reader (int slot, int *used)
3251 {
3252   if (slot < 0 || slot >= MAX_READER)
3253     return SW_HOST_NO_DRIVER;
3254   *used = reader_table[slot].used;
3255   return 0;
3256 }
3257
3258
3259 /* Connect a card.  This is used to power up the card and make sure
3260    that an ATR is available.  Depending on the reader backend it may
3261    return an error for an inactive card or if no card is
3262    available.  */
3263 int
3264 apdu_connect (int slot)
3265 {
3266   int sw;
3267   unsigned int status;
3268
3269   if (DBG_READER)
3270     log_debug ("enter: apdu_connect: slot=%d\n", slot);
3271
3272   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3273     {
3274       if (DBG_READER)
3275         log_debug ("leave: apdu_connect => SW_HOST_NO_DRIVER\n");
3276       return SW_HOST_NO_DRIVER;
3277     }
3278
3279   /* Only if the access method provides a connect function we use it.
3280      If not, we expect that the card has been implicitly connected by
3281      apdu_open_reader.  */
3282   if (reader_table[slot].connect_card)
3283     {
3284       sw = lock_slot (slot);
3285       if (!sw)
3286         {
3287           sw = reader_table[slot].connect_card (slot);
3288           unlock_slot (slot);
3289         }
3290     }
3291   else
3292     sw = 0;
3293
3294   /* We need to call apdu_get_status_internal, so that the last-status
3295      machinery gets setup properly even if a card is inserted while
3296      scdaemon is fired up and apdu_get_status has not yet been called.
3297      Without that we would force a reset of the card with the next
3298      call to apdu_get_status.  */
3299   apdu_get_status_internal (slot, 1, 1, &status, NULL);
3300   if (sw)
3301     ;
3302   else if (!(status & APDU_CARD_PRESENT))
3303     sw = SW_HOST_NO_CARD;
3304   else if ((status & APDU_CARD_PRESENT) && !(status & APDU_CARD_ACTIVE))
3305     sw = SW_HOST_CARD_INACTIVE;
3306
3307   if (DBG_READER)
3308     log_debug ("leave: apdu_connect => sw=0x%x\n", sw);
3309
3310   return sw;
3311 }
3312
3313
3314 int
3315 apdu_disconnect (int slot)
3316 {
3317   int sw;
3318
3319   if (DBG_READER)
3320     log_debug ("enter: apdu_disconnect: slot=%d\n", slot);
3321
3322   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3323     {
3324       if (DBG_READER)
3325         log_debug ("leave: apdu_disconnect => SW_HOST_NO_DRIVER\n");
3326       return SW_HOST_NO_DRIVER;
3327     }
3328
3329   if (reader_table[slot].disconnect_card)
3330     {
3331       sw = lock_slot (slot);
3332       if (!sw)
3333         {
3334           sw = reader_table[slot].disconnect_card (slot);
3335           unlock_slot (slot);
3336         }
3337     }
3338   else
3339     sw = 0;
3340
3341   if (DBG_READER)
3342     log_debug ("leave: apdu_disconnect => sw=0x%x\n", sw);
3343   return sw;
3344 }
3345
3346
3347 /* Set the progress callback of SLOT to CB and its args to CB_ARG.  If
3348    CB is NULL the progress callback is removed.  */
3349 int
3350 apdu_set_progress_cb (int slot, gcry_handler_progress_t cb, void *cb_arg)
3351 {
3352   int sw;
3353
3354   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3355     return SW_HOST_NO_DRIVER;
3356
3357   if (reader_table[slot].set_progress_cb)
3358     {
3359       sw = lock_slot (slot);
3360       if (!sw)
3361         {
3362           sw = reader_table[slot].set_progress_cb (slot, cb, cb_arg);
3363           unlock_slot (slot);
3364         }
3365     }
3366   else
3367     sw = 0;
3368   return sw;
3369 }
3370
3371
3372 /* Do a reset for the card in reader at SLOT. */
3373 int
3374 apdu_reset (int slot)
3375 {
3376   int sw;
3377
3378   if (DBG_READER)
3379     log_debug ("enter: apdu_reset: slot=%d\n", slot);
3380
3381   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3382     {
3383       if (DBG_READER)
3384         log_debug ("leave: apdu_reset => SW_HOST_NO_DRIVER\n");
3385       return SW_HOST_NO_DRIVER;
3386     }
3387
3388   if ((sw = lock_slot (slot)))
3389     {
3390       if (DBG_READER)
3391         log_debug ("leave: apdu_reset => sw=0x%x (lock_slot)\n", sw);
3392       return sw;
3393     }
3394
3395   reader_table[slot].last_status = 0;
3396   if (reader_table[slot].reset_reader)
3397     sw = reader_table[slot].reset_reader (slot);
3398
3399   if (!sw)
3400     {
3401       /* If we got to here we know that a card is present
3402          and usable.  Thus remember this.  */
3403       reader_table[slot].last_status = (APDU_CARD_USABLE
3404                                         | APDU_CARD_PRESENT
3405                                         | APDU_CARD_ACTIVE);
3406     }
3407
3408   unlock_slot (slot);
3409   if (DBG_READER)
3410     log_debug ("leave: apdu_reset => sw=0x%x\n", sw);
3411   return sw;
3412 }
3413
3414
3415 /* Return the ATR or NULL if none is available.  On success the length
3416    of the ATR is stored at ATRLEN.  The caller must free the returned
3417    value.  */
3418 unsigned char *
3419 apdu_get_atr (int slot, size_t *atrlen)
3420 {
3421   unsigned char *buf;
3422
3423   if (DBG_READER)
3424     log_debug ("enter: apdu_get_atr: slot=%d\n", slot);
3425
3426   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3427     {
3428       if (DBG_READER)
3429         log_debug ("leave: apdu_get_atr => NULL (bad slot)\n");
3430       return NULL;
3431     }
3432   if (!reader_table[slot].atrlen)
3433     {
3434       if (DBG_READER)
3435         log_debug ("leave: apdu_get_atr => NULL (no ATR)\n");
3436       return NULL;
3437     }
3438
3439   buf = xtrymalloc (reader_table[slot].atrlen);
3440   if (!buf)
3441     {
3442       if (DBG_READER)
3443         log_debug ("leave: apdu_get_atr => NULL (out of core)\n");
3444       return NULL;
3445     }
3446   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
3447   *atrlen = reader_table[slot].atrlen;
3448   if (DBG_READER)
3449     log_debug ("leave: apdu_get_atr => atrlen=%zu\n", *atrlen);
3450   return buf;
3451 }
3452
3453
3454
3455 /* Retrieve the status for SLOT. The function does only wait for the
3456    card to become available if HANG is set to true. On success the
3457    bits in STATUS will be set to
3458
3459      APDU_CARD_USABLE  (bit 0) = card present and usable
3460      APDU_CARD_PRESENT (bit 1) = card present
3461      APDU_CARD_ACTIVE  (bit 2) = card active
3462                        (bit 3) = card access locked [not yet implemented]
3463
3464    For must applications, testing bit 0 is sufficient.
3465
3466    CHANGED will receive the value of the counter tracking the number
3467    of card insertions.  This value may be used to detect a card
3468    change.
3469 */
3470 static int
3471 apdu_get_status_internal (int slot, int hang, int no_atr_reset,
3472                           unsigned int *status, unsigned int *changed)
3473 {
3474   int sw;
3475   unsigned int s;
3476
3477   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3478     return SW_HOST_NO_DRIVER;
3479
3480   if ((sw = hang? lock_slot (slot) : trylock_slot (slot)))
3481     return sw;
3482
3483   if (reader_table[slot].get_status_reader)
3484     sw = reader_table[slot].get_status_reader (slot, &s);
3485
3486   unlock_slot (slot);
3487
3488   if (sw)
3489     {
3490       reader_table[slot].last_status = 0;
3491       return sw;
3492     }
3493
3494   /* Keep track of changes.  */
3495   if (s != reader_table[slot].last_status
3496       || !reader_table[slot].any_status )
3497     {
3498       reader_table[slot].change_counter++;
3499       /* Make sure that the ATR is invalid so that a reset will be
3500          triggered by apdu_activate.  */
3501       if (!no_atr_reset)
3502         reader_table[slot].atrlen = 0;
3503     }
3504   reader_table[slot].any_status = 1;
3505   reader_table[slot].last_status = s;
3506
3507   if (status)
3508     *status = s;
3509   if (changed)
3510     *changed = reader_table[slot].change_counter;
3511   return 0;
3512 }
3513
3514
3515 /* See above for a description.  */
3516 int
3517 apdu_get_status (int slot, int hang,
3518                  unsigned int *status, unsigned int *changed)
3519 {
3520   int sw;
3521
3522   if (DBG_READER)
3523     log_debug ("enter: apdu_get_status: slot=%d hang=%d\n", slot, hang);
3524   sw = apdu_get_status_internal (slot, hang, 0, status, changed);
3525   if (DBG_READER)
3526     {
3527       if (status && changed)
3528         log_debug ("leave: apdu_get_status => sw=0x%x status=%u changecnt=%u\n",
3529                    sw, *status, *changed);
3530       else if (status)
3531         log_debug ("leave: apdu_get_status => sw=0x%x status=%u\n",
3532                    sw, *status);
3533       else if (changed)
3534         log_debug ("leave: apdu_get_status => sw=0x%x changed=%u\n",
3535                    sw, *changed);
3536       else
3537         log_debug ("leave: apdu_get_status => sw=0x%x\n", sw);
3538     }
3539   return sw;
3540 }
3541
3542
3543 /* Check whether the reader supports the ISO command code COMMAND on
3544    the pinpad.  Return 0 on success.  For a description of the pin
3545    parameters, see ccid-driver.c */
3546 int
3547 apdu_check_pinpad (int slot, int command, pininfo_t *pininfo)
3548 {
3549   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3550     return SW_HOST_NO_DRIVER;
3551
3552   if (opt.enable_pinpad_varlen)
3553     pininfo->fixedlen = 0;
3554
3555   if (reader_table[slot].check_pinpad)
3556     {
3557       int sw;
3558
3559       if ((sw = lock_slot (slot)))
3560         return sw;
3561
3562       sw = reader_table[slot].check_pinpad (slot, command, pininfo);
3563       unlock_slot (slot);
3564       return sw;
3565     }
3566   else
3567     return SW_HOST_NOT_SUPPORTED;
3568 }
3569
3570
3571 int
3572 apdu_pinpad_verify (int slot, int class, int ins, int p0, int p1,
3573                     pininfo_t *pininfo)
3574 {
3575   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3576     return SW_HOST_NO_DRIVER;
3577
3578   if (reader_table[slot].pinpad_verify)
3579     {
3580       int sw;
3581
3582       if ((sw = lock_slot (slot)))
3583         return sw;
3584
3585       sw = reader_table[slot].pinpad_verify (slot, class, ins, p0, p1,
3586                                              pininfo);
3587       unlock_slot (slot);
3588       return sw;
3589     }
3590   else
3591     return SW_HOST_NOT_SUPPORTED;
3592 }
3593
3594
3595 int
3596 apdu_pinpad_modify (int slot, int class, int ins, int p0, int p1,
3597                     pininfo_t *pininfo)
3598 {
3599   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3600     return SW_HOST_NO_DRIVER;
3601
3602   if (reader_table[slot].pinpad_modify)
3603     {
3604       int sw;
3605
3606       if ((sw = lock_slot (slot)))
3607         return sw;
3608
3609       sw = reader_table[slot].pinpad_modify (slot, class, ins, p0, p1,
3610                                              pininfo);
3611       unlock_slot (slot);
3612       return sw;
3613     }
3614   else
3615     return SW_HOST_NOT_SUPPORTED;
3616 }
3617
3618
3619 /* Dispatcher for the actual send_apdu function. Note, that this
3620    function should be called in locked state. */
3621 static int
3622 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
3623            unsigned char *buffer, size_t *buflen, pininfo_t *pininfo)
3624 {
3625   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3626     return SW_HOST_NO_DRIVER;
3627
3628   if (reader_table[slot].send_apdu_reader)
3629     return reader_table[slot].send_apdu_reader (slot,
3630                                                 apdu, apdulen,
3631                                                 buffer, buflen,
3632                                                 pininfo);
3633   else
3634     return SW_HOST_NOT_SUPPORTED;
3635 }
3636
3637
3638 /* Core APDU tranceiver function. Parameters are described at
3639    apdu_send_le with the exception of PININFO which indicates pinpad
3640    related operations if not NULL.  If EXTENDED_MODE is not 0
3641    command chaining or extended length will be used according to these
3642    values:
3643        n < 0 := Use command chaining with the data part limited to -n
3644                 in each chunk.  If -1 is used a default value is used.
3645       n == 0 := No extended mode or command chaining.
3646       n == 1 := Use extended length for input and output without a
3647                 length limit.
3648        n > 1 := Use extended length with up to N bytes.
3649
3650 */
3651 static int
3652 send_le (int slot, int class, int ins, int p0, int p1,
3653          int lc, const char *data, int le,
3654          unsigned char **retbuf, size_t *retbuflen,
3655          pininfo_t *pininfo, int extended_mode)
3656 {
3657 #define SHORT_RESULT_BUFFER_SIZE 258
3658   /* We allocate 8 extra bytes as a safety margin towards a driver bug.  */
3659   unsigned char short_result_buffer[SHORT_RESULT_BUFFER_SIZE+10];
3660   unsigned char *result_buffer = NULL;
3661   size_t result_buffer_size;
3662   unsigned char *result;
3663   size_t resultlen;
3664   unsigned char short_apdu_buffer[5+256+1];
3665   unsigned char *apdu_buffer = NULL;
3666   size_t apdu_buffer_size;
3667   unsigned char *apdu;
3668   size_t apdulen;
3669   int sw;
3670   long rc; /* We need a long here due to PC/SC. */
3671   int did_exact_length_hack = 0;
3672   int use_chaining = 0;
3673   int use_extended_length = 0;
3674   int lc_chunk;
3675
3676   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3677     return SW_HOST_NO_DRIVER;
3678
3679   if (DBG_CARD_IO)
3680     log_debug ("send apdu: c=%02X i=%02X p1=%02X p2=%02X lc=%d le=%d em=%d\n",
3681                class, ins, p0, p1, lc, le, extended_mode);
3682
3683   if (lc != -1 && (lc > 255 || lc < 0))
3684     {
3685       /* Data does not fit into an APDU.  What we do now depends on
3686          the EXTENDED_MODE parameter.  */
3687       if (!extended_mode)
3688         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
3689       else if (extended_mode > 0)
3690         use_extended_length = 1;
3691       else if (extended_mode < 0)
3692         {
3693           /* Send APDU using chaining mode.  */
3694           if (lc > 16384)
3695             return SW_WRONG_LENGTH;   /* Sanity check.  */
3696           if ((class&0xf0) != 0)
3697             return SW_HOST_INV_VALUE; /* Upper 4 bits need to be 0.  */
3698           use_chaining = extended_mode == -1? 255 : -extended_mode;
3699           use_chaining &= 0xff;
3700         }
3701       else
3702         return SW_HOST_INV_VALUE;
3703     }
3704   else if (lc == -1 && extended_mode > 0)
3705     use_extended_length = 1;
3706
3707   if (le != -1 && (le > (extended_mode > 0? 255:256) || le < 0))
3708     {
3709       /* Expected Data does not fit into an APDU.  What we do now
3710          depends on the EXTENDED_MODE parameter.  Note that a check
3711          for command chaining does not make sense because we are
3712          looking at Le.  */
3713       if (!extended_mode)
3714         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
3715       else if (use_extended_length)
3716         ; /* We are already using extended length.  */
3717       else if (extended_mode > 0)
3718         use_extended_length = 1;
3719       else
3720         return SW_HOST_INV_VALUE;
3721     }
3722
3723   if ((!data && lc != -1) || (data && lc == -1))
3724     return SW_HOST_INV_VALUE;
3725
3726   if (use_extended_length)
3727     {
3728       if (reader_table[slot].is_t0)
3729         return SW_HOST_NOT_SUPPORTED;
3730
3731       /* Space for: cls/ins/p1/p2+Z+2_byte_Lc+Lc+2_byte_Le.  */
3732       apdu_buffer_size = 4 + 1 + (lc >= 0? (2+lc):0) + 2;
3733       apdu_buffer = xtrymalloc (apdu_buffer_size + 10);
3734       if (!apdu_buffer)
3735         return SW_HOST_OUT_OF_CORE;
3736       apdu = apdu_buffer;
3737     }
3738   else
3739     {
3740       apdu_buffer_size = sizeof short_apdu_buffer;
3741       apdu = short_apdu_buffer;
3742     }
3743
3744   if (use_extended_length && (le > 256 || le < 0))
3745     {
3746       result_buffer_size = le < 0? 4096 : le;
3747       result_buffer = xtrymalloc (result_buffer_size + 10);
3748       if (!result_buffer)
3749         {
3750           xfree (apdu_buffer);
3751           return SW_HOST_OUT_OF_CORE;
3752         }
3753       result = result_buffer;
3754     }
3755   else
3756     {
3757       result_buffer_size = SHORT_RESULT_BUFFER_SIZE;
3758       result = short_result_buffer;
3759     }
3760 #undef SHORT_RESULT_BUFFER_SIZE
3761
3762   if ((sw = lock_slot (slot)))
3763     {
3764       xfree (apdu_buffer);
3765       xfree (result_buffer);
3766       return sw;
3767     }
3768
3769   do
3770     {
3771       if (use_extended_length)
3772         {
3773           use_chaining = 0;
3774           apdulen = 0;
3775           apdu[apdulen++] = class;
3776           apdu[apdulen++] = ins;
3777           apdu[apdulen++] = p0;
3778           apdu[apdulen++] = p1;
3779           apdu[apdulen++] = 0;  /* Z byte: Extended length marker.  */
3780           if (lc >= 0)
3781             {
3782               apdu[apdulen++] = ((lc >> 8) & 0xff);
3783               apdu[apdulen++] = (lc & 0xff);
3784               memcpy (apdu+apdulen, data, lc);
3785               data += lc;
3786               apdulen += lc;
3787             }
3788           if (le != -1)
3789             {
3790               apdu[apdulen++] = ((le >> 8) & 0xff);
3791               apdu[apdulen++] = (le & 0xff);
3792             }
3793         }
3794       else
3795         {
3796           apdulen = 0;
3797           apdu[apdulen] = class;
3798           if (use_chaining && lc > 255)
3799             {
3800               apdu[apdulen] |= 0x10;
3801               assert (use_chaining < 256);
3802               lc_chunk = use_chaining;
3803               lc -= use_chaining;
3804             }
3805           else
3806             {
3807               use_chaining = 0;
3808               lc_chunk = lc;
3809             }
3810           apdulen++;
3811           apdu[apdulen++] = ins;
3812           apdu[apdulen++] = p0;
3813           apdu[apdulen++] = p1;
3814           if (lc_chunk != -1)
3815             {
3816               apdu[apdulen++] = lc_chunk;
3817               memcpy (apdu+apdulen, data, lc_chunk);
3818               data += lc_chunk;
3819               apdulen += lc_chunk;
3820               /* T=0 does not allow the use of Lc together with Le;
3821                  thus disable Le in this case.  */
3822               if (reader_table[slot].is_t0)
3823                 le = -1;
3824             }
3825           if (le != -1 && !use_chaining)
3826             apdu[apdulen++] = le; /* Truncation is okay (0 means 256). */
3827         }
3828
3829     exact_length_hack:
3830       /* As a safeguard don't pass any garbage to the driver.  */
3831       assert (apdulen <= apdu_buffer_size);
3832       memset (apdu+apdulen, 0, apdu_buffer_size - apdulen);
3833       resultlen = result_buffer_size;
3834       rc = send_apdu (slot, apdu, apdulen, result, &resultlen, pininfo);
3835       if (rc || resultlen < 2)
3836         {
3837           log_info ("apdu_send_simple(%d) failed: %s\n",
3838                     slot, apdu_strerror (rc));
3839           unlock_slot (slot);
3840           xfree (apdu_buffer);
3841           xfree (result_buffer);
3842           return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
3843         }
3844       sw = (result[resultlen-2] << 8) | result[resultlen-1];
3845       if (!use_extended_length
3846           && !did_exact_length_hack && SW_EXACT_LENGTH_P (sw))
3847         {
3848           apdu[apdulen-1] = (sw & 0x00ff);
3849           did_exact_length_hack = 1;
3850           goto exact_length_hack;
3851         }
3852     }
3853   while (use_chaining && sw == SW_SUCCESS);
3854
3855   if (apdu_buffer)
3856     {
3857       xfree (apdu_buffer);
3858       apdu_buffer = NULL;
3859       apdu_buffer_size = 0;
3860     }
3861
3862   /* Store away the returned data but strip the statusword. */
3863   resultlen -= 2;
3864   if (DBG_CARD_IO)
3865     {
3866       log_debug (" response: sw=%04X  datalen=%d\n",
3867                  sw, (unsigned int)resultlen);
3868       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
3869         log_printhex ("    dump: ", result, resultlen);
3870     }
3871
3872   if (sw == SW_SUCCESS || sw == SW_EOF_REACHED)
3873     {
3874       if (retbuf)
3875         {
3876           *retbuf = xtrymalloc (resultlen? resultlen : 1);
3877           if (!*retbuf)
3878             {
3879               unlock_slot (slot);
3880               xfree (result_buffer);
3881               return SW_HOST_OUT_OF_CORE;
3882             }
3883           *retbuflen = resultlen;
3884           memcpy (*retbuf, result, resultlen);
3885         }
3886     }
3887   else if ((sw & 0xff00) == SW_MORE_DATA)
3888     {
3889       unsigned char *p = NULL, *tmp;
3890       size_t bufsize = 4096;
3891
3892       /* It is likely that we need to return much more data, so we
3893          start off with a large buffer. */
3894       if (retbuf)
3895         {
3896           *retbuf = p = xtrymalloc (bufsize);
3897           if (!*retbuf)
3898             {
3899               unlock_slot (slot);
3900               xfree (result_buffer);
3901               return SW_HOST_OUT_OF_CORE;
3902             }
3903           assert (resultlen < bufsize);
3904           memcpy (p, result, resultlen);
3905           p += resultlen;
3906         }
3907
3908       do
3909         {
3910           int len = (sw & 0x00ff);
3911
3912           if (DBG_CARD_IO)
3913             log_debug ("apdu_send_simple(%d): %d more bytes available\n",
3914                        slot, len);
3915           apdu_buffer_size = sizeof short_apdu_buffer;
3916           apdu = short_apdu_buffer;
3917           apdulen = 0;
3918           apdu[apdulen++] = class;
3919           apdu[apdulen++] = 0xC0;
3920           apdu[apdulen++] = 0;
3921           apdu[apdulen++] = 0;
3922           apdu[apdulen++] = len;
3923           assert (apdulen <= apdu_buffer_size);
3924           memset (apdu+apdulen, 0, apdu_buffer_size - apdulen);
3925           resultlen = result_buffer_size;
3926           rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
3927           if (rc || resultlen < 2)
3928             {
3929               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
3930                          slot, apdu_strerror (rc));
3931               unlock_slot (slot);
3932               xfree (result_buffer);
3933               return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
3934             }
3935           sw = (result[resultlen-2] << 8) | result[resultlen-1];
3936           resultlen -= 2;
3937           if (DBG_CARD_IO)
3938             {
3939               log_debug ("     more: sw=%04X  datalen=%d\n",
3940                          sw, (unsigned int)resultlen);
3941               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
3942                 log_printhex ("     dump: ", result, resultlen);
3943             }
3944
3945           if ((sw & 0xff00) == SW_MORE_DATA
3946               || sw == SW_SUCCESS
3947               || sw == SW_EOF_REACHED )
3948             {
3949               if (retbuf && resultlen)
3950                 {
3951                   if (p - *retbuf + resultlen > bufsize)
3952                     {
3953                       bufsize += resultlen > 4096? resultlen: 4096;
3954                       tmp = xtryrealloc (*retbuf, bufsize);
3955                       if (!tmp)
3956                         {
3957                           unlock_slot (slot);
3958                           xfree (result_buffer);
3959                           return SW_HOST_OUT_OF_CORE;
3960                         }
3961                       p = tmp + (p - *retbuf);
3962                       *retbuf = tmp;
3963                     }
3964                   memcpy (p, result, resultlen);
3965                   p += resultlen;
3966                 }
3967             }
3968           else
3969             log_info ("apdu_send_simple(%d) "
3970                       "got unexpected status %04X from get response\n",
3971                       slot, sw);
3972         }
3973       while ((sw & 0xff00) == SW_MORE_DATA);
3974
3975       if (retbuf)
3976         {
3977           *retbuflen = p - *retbuf;
3978           tmp = xtryrealloc (*retbuf, *retbuflen);
3979           if (tmp)
3980             *retbuf = tmp;
3981         }
3982     }
3983
3984   unlock_slot (slot);
3985   xfree (result_buffer);
3986
3987   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
3988     log_printhex ("      dump: ", *retbuf, *retbuflen);
3989
3990   return sw;
3991 }
3992
3993 /* Send an APDU to the card in SLOT.  The APDU is created from all
3994    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
3995    for LC won't sent this field and the data field; in this case DATA
3996    must also be passed as NULL.  If EXTENDED_MODE is not 0 command
3997    chaining or extended length will be used; see send_le for details.
3998    The return value is the status word or -1 for an invalid SLOT or
3999    other non card related error.  If RETBUF is not NULL, it will
4000    receive an allocated buffer with the returned data.  The length of
4001    that data will be put into *RETBUFLEN.  The caller is reponsible
4002    for releasing the buffer even in case of errors.  */
4003 int
4004 apdu_send_le(int slot, int extended_mode,
4005              int class, int ins, int p0, int p1,
4006              int lc, const char *data, int le,
4007              unsigned char **retbuf, size_t *retbuflen)
4008 {
4009   return send_le (slot, class, ins, p0, p1,
4010                   lc, data, le,
4011                   retbuf, retbuflen,
4012                   NULL, extended_mode);
4013 }
4014
4015
4016 /* Send an APDU to the card in SLOT.  The APDU is created from all
4017    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
4018    LC won't sent this field and the data field; in this case DATA must
4019    also be passed as NULL.  If EXTENDED_MODE is not 0 command chaining
4020    or extended length will be used; see send_le for details.  The
4021    return value is the status word or -1 for an invalid SLOT or other
4022    non card related error.  If RETBUF is not NULL, it will receive an
4023    allocated buffer with the returned data.  The length of that data
4024    will be put into *RETBUFLEN.  The caller is reponsible for
4025    releasing the buffer even in case of errors.  */
4026 int
4027 apdu_send (int slot, int extended_mode,
4028            int class, int ins, int p0, int p1,
4029            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
4030 {
4031   return send_le (slot, class, ins, p0, p1, lc, data, 256,
4032                   retbuf, retbuflen, NULL, extended_mode);
4033 }
4034
4035 /* Send an APDU to the card in SLOT.  The APDU is created from all
4036    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
4037    LC won't sent this field and the data field; in this case DATA must
4038    also be passed as NULL.  If EXTENDED_MODE is not 0 command chaining
4039    or extended length will be used; see send_le for details.  The
4040    return value is the status word or -1 for an invalid SLOT or other
4041    non card related error.  No data will be returned.  */
4042 int
4043 apdu_send_simple (int slot, int extended_mode,
4044                   int class, int ins, int p0, int p1,
4045                   int lc, const char *data)
4046 {
4047   return send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL, NULL,
4048                   extended_mode);
4049 }
4050
4051
4052 /* This is a more generic version of the apdu sending routine.  It
4053    takes an already formatted APDU in APDUDATA or length APDUDATALEN
4054    and returns with an APDU including the status word.  With
4055    HANDLE_MORE set to true this function will handle the MORE DATA
4056    status and return all APDUs concatenated with one status word at
4057    the end.  If EXTENDED_LENGTH is != 0 extended lengths are allowed
4058    with a max. result data length of EXTENDED_LENGTH bytes.  The
4059    function does not return a regular status word but 0 on success.
4060    If the slot is locked, the function returns immediately with an
4061    error.  */
4062 int
4063 apdu_send_direct (int slot, size_t extended_length,
4064                   const unsigned char *apdudata, size_t apdudatalen,
4065                   int handle_more,
4066                   unsigned char **retbuf, size_t *retbuflen)
4067 {
4068 #define SHORT_RESULT_BUFFER_SIZE 258
4069   unsigned char short_result_buffer[SHORT_RESULT_BUFFER_SIZE+10];
4070   unsigned char *result_buffer = NULL;
4071   size_t result_buffer_size;
4072   unsigned char *result;
4073   size_t resultlen;
4074   unsigned char short_apdu_buffer[5+256+10];
4075   unsigned char *apdu_buffer = NULL;
4076   unsigned char *apdu;
4077   size_t apdulen;
4078   int sw;
4079   long rc; /* we need a long here due to PC/SC. */
4080   int class;
4081
4082   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
4083     return SW_HOST_NO_DRIVER;
4084
4085   if (apdudatalen > 65535)
4086     return SW_HOST_INV_VALUE;
4087
4088   if (apdudatalen > sizeof short_apdu_buffer - 5)
4089     {
4090       apdu_buffer = xtrymalloc (apdudatalen + 5);
4091       if (!apdu_buffer)
4092         return SW_HOST_OUT_OF_CORE;
4093       apdu = apdu_buffer;
4094     }
4095   else
4096     {
4097       apdu = short_apdu_buffer;
4098     }
4099   apdulen = apdudatalen;
4100   memcpy (apdu, apdudata, apdudatalen);
4101   class = apdulen? *apdu : 0;
4102
4103   if (extended_length >= 256 && extended_length <= 65536)
4104     {
4105       result_buffer_size = extended_length;
4106       result_buffer = xtrymalloc (result_buffer_size + 10);
4107       if (!result_buffer)
4108         {
4109           xfree (apdu_buffer);
4110           return SW_HOST_OUT_OF_CORE;
4111         }
4112       result = result_buffer;
4113     }
4114   else
4115     {
4116       result_buffer_size = SHORT_RESULT_BUFFER_SIZE;
4117       result = short_result_buffer;
4118     }
4119 #undef SHORT_RESULT_BUFFER_SIZE
4120
4121   if ((sw = trylock_slot (slot)))
4122     {
4123       xfree (apdu_buffer);
4124       xfree (result_buffer);
4125       return sw;
4126     }
4127
4128   resultlen = result_buffer_size;
4129   rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
4130   xfree (apdu_buffer);
4131   apdu_buffer = NULL;
4132   if (rc || resultlen < 2)
4133     {
4134       log_error ("apdu_send_direct(%d) failed: %s\n",
4135                  slot, apdu_strerror (rc));
4136       unlock_slot (slot);
4137       xfree (result_buffer);
4138       return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
4139     }
4140   sw = (result[resultlen-2] << 8) | result[resultlen-1];
4141   /* Store away the returned data but strip the statusword. */
4142   resultlen -= 2;
4143   if (DBG_CARD_IO)
4144     {
4145       log_debug (" response: sw=%04X  datalen=%d\n",
4146                  sw, (unsigned int)resultlen);
4147       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
4148         log_printhex ("     dump: ", result, resultlen);
4149     }
4150
4151   if (handle_more && (sw & 0xff00) == SW_MORE_DATA)
4152     {
4153       unsigned char *p = NULL, *tmp;
4154       size_t bufsize = 4096;
4155
4156       /* It is likely that we need to return much more data, so we
4157          start off with a large buffer. */
4158       if (retbuf)
4159         {
4160           *retbuf = p = xtrymalloc (bufsize + 2);
4161           if (!*retbuf)
4162             {
4163               unlock_slot (slot);
4164               xfree (result_buffer);
4165               return SW_HOST_OUT_OF_CORE;
4166             }
4167           assert (resultlen < bufsize);
4168           memcpy (p, result, resultlen);
4169           p += resultlen;
4170         }
4171
4172       do
4173         {
4174           int len = (sw & 0x00ff);
4175
4176           if (DBG_CARD_IO)
4177             log_debug ("apdu_send_direct(%d): %d more bytes available\n",
4178                        slot, len);
4179           apdu = short_apdu_buffer;
4180           apdulen = 0;
4181           apdu[apdulen++] = class;
4182           apdu[apdulen++] = 0xC0;
4183           apdu[apdulen++] = 0;
4184           apdu[apdulen++] = 0;
4185           apdu[apdulen++] = len;
4186           memset (apdu+apdulen, 0, sizeof (short_apdu_buffer) - apdulen);
4187           resultlen = result_buffer_size;
4188           rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
4189           if (rc || resultlen < 2)
4190             {
4191               log_error ("apdu_send_direct(%d) for get response failed: %s\n",
4192                          slot, apdu_strerror (rc));
4193               unlock_slot (slot);
4194               xfree (result_buffer);
4195               return rc ? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
4196             }
4197           sw = (result[resultlen-2] << 8) | result[resultlen-1];
4198           resultlen -= 2;
4199           if (DBG_CARD_IO)
4200             {
4201               log_debug ("     more: sw=%04X  datalen=%d\n",
4202                          sw, (unsigned int)resultlen);
4203               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
4204                 log_printhex ("     dump: ", result, resultlen);
4205             }
4206
4207           if ((sw & 0xff00) == SW_MORE_DATA
4208               || sw == SW_SUCCESS
4209               || sw == SW_EOF_REACHED )
4210             {
4211               if (retbuf && resultlen)
4212                 {
4213                   if (p - *retbuf + resultlen > bufsize)
4214                     {
4215                       bufsize += resultlen > 4096? resultlen: 4096;
4216                       tmp = xtryrealloc (*retbuf, bufsize + 2);
4217                       if (!tmp)
4218                         {
4219                           unlock_slot (slot);
4220                           xfree (result_buffer);
4221                           return SW_HOST_OUT_OF_CORE;
4222                         }
4223                       p = tmp + (p - *retbuf);
4224                       *retbuf = tmp;
4225                     }
4226                   memcpy (p, result, resultlen);
4227                   p += resultlen;
4228                 }
4229             }
4230           else
4231             log_info ("apdu_send_direct(%d) "
4232                       "got unexpected status %04X from get response\n",
4233                       slot, sw);
4234         }
4235       while ((sw & 0xff00) == SW_MORE_DATA);
4236
4237       if (retbuf)
4238         {
4239           *retbuflen = p - *retbuf;
4240           tmp = xtryrealloc (*retbuf, *retbuflen + 2);
4241           if (tmp)
4242             *retbuf = tmp;
4243         }
4244     }
4245   else
4246     {
4247       if (retbuf)
4248         {
4249           *retbuf = xtrymalloc ((resultlen? resultlen : 1)+2);
4250           if (!*retbuf)
4251             {
4252               unlock_slot (slot);
4253               xfree (result_buffer);
4254               return SW_HOST_OUT_OF_CORE;
4255             }
4256           *retbuflen = resultlen;
4257           memcpy (*retbuf, result, resultlen);
4258         }
4259     }
4260
4261   unlock_slot (slot);
4262   xfree (result_buffer);
4263
4264   /* Append the status word.  Note that we reserved the two extra
4265      bytes while allocating the buffer.  */
4266   if (retbuf)
4267     {
4268       (*retbuf)[(*retbuflen)++] = (sw >> 8);
4269       (*retbuf)[(*retbuflen)++] = sw;
4270     }
4271
4272   if (DBG_CARD_IO && retbuf)
4273     log_printhex ("      dump: ", *retbuf, *retbuflen);
4274
4275   return 0;
4276 }