scd: remove pin length check.
[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   pin_verify = xtrymalloc (len);
2202   if (!pin_verify)
2203     return SW_HOST_OUT_OF_CORE;
2204
2205   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2206
2207   pin_verify[0] = 0x00; /* bTimeOut */
2208   pin_verify[1] = 0x00; /* bTimeOut2 */
2209   pin_verify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2210   pin_verify[3] = pininfo->fixedlen; /* bmPINBlockString */
2211   pin_verify[4] = 0x00; /* bmPINLengthFormat */
2212   pin_verify[5] = pininfo->maxlen; /* wPINMaxExtraDigit */
2213   pin_verify[6] = pininfo->minlen; /* wPINMaxExtraDigit */
2214   pin_verify[7] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2215   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2216     pin_verify[7] |= 0x01; /* Max size reached.  */
2217   pin_verify[8] = 0x01; /* bNumberMessage: One message */
2218   pin_verify[9] =  0x09; /* wLangId: 0x0409: US English */
2219   pin_verify[10] = 0x04; /* wLangId: 0x0409: US English */
2220   pin_verify[11] = 0x00; /* bMsgIndex */
2221   pin_verify[12] = 0x00; /* bTeoPrologue[0] */
2222   pin_verify[13] = 0x00; /* bTeoPrologue[1] */
2223   pin_verify[14] = pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2224   pin_verify[15] = pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2225   pin_verify[16] = 0x00; /* ulDataLength */
2226   pin_verify[17] = 0x00; /* ulDataLength */
2227   pin_verify[18] = 0x00; /* ulDataLength */
2228   pin_verify[19] = class; /* abData[0] */
2229   pin_verify[20] = ins; /* abData[1] */
2230   pin_verify[21] = p0; /* abData[2] */
2231   pin_verify[22] = p1; /* abData[3] */
2232   pin_verify[23] = pininfo->fixedlen; /* abData[4] */
2233   if (pininfo->fixedlen)
2234     memset (&pin_verify[24], 0xff, pininfo->fixedlen);
2235   else if (no_lc)
2236     len--;
2237
2238   if (DBG_CARD_IO)
2239     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2240                class, ins, p0, p1, len, pininfo->maxlen);
2241
2242   sw = control_pcsc (slot, reader_table[slot].pcsc.verify_ioctl,
2243                      pin_verify, len, result, &resultlen);
2244   xfree (pin_verify);
2245   if (sw || resultlen < 2)
2246     return sw? sw : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2247   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2248     {
2249       log_error ("control_pcsc failed: %d\n", sw);
2250       return sw? sw: SW_HOST_INCOMPLETE_CARD_RESPONSE;
2251     }
2252   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2253   if (DBG_CARD_IO)
2254     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2255   return sw;
2256 }
2257
2258
2259 #define PIN_MODIFY_STRUCTURE_SIZE 29
2260 static int
2261 pcsc_pinpad_modify (int slot, int class, int ins, int p0, int p1,
2262                     pininfo_t *pininfo)
2263 {
2264   int sw;
2265   unsigned char *pin_modify;
2266   int len = PIN_MODIFY_STRUCTURE_SIZE + 2 * pininfo->fixedlen;
2267   unsigned char result[2];
2268   pcsc_dword_t resultlen = 2;
2269   int no_lc;
2270
2271   if (!reader_table[slot].atrlen
2272       && (sw = reset_pcsc_reader (slot)))
2273     return sw;
2274
2275   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2276     return SW_NOT_SUPPORTED;
2277
2278   if (!pininfo->minlen)
2279     pininfo->minlen = 1;
2280   if (!pininfo->maxlen)
2281     pininfo->maxlen = 15;
2282
2283   /* Note that the 25 is the maximum value the SPR532 allows.  */
2284   if (pininfo->minlen < 1 || pininfo->minlen > 25
2285       || pininfo->maxlen < 1 || pininfo->maxlen > 25
2286       || pininfo->minlen > pininfo->maxlen)
2287     return SW_HOST_INV_VALUE;
2288
2289   pin_modify = xtrymalloc (len);
2290   if (!pin_modify)
2291     return SW_HOST_OUT_OF_CORE;
2292
2293   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2294
2295   pin_modify[0] = 0x00; /* bTimeOut */
2296   pin_modify[1] = 0x00; /* bTimeOut2 */
2297   pin_modify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2298   pin_modify[3] = pininfo->fixedlen; /* bmPINBlockString */
2299   pin_modify[4] = 0x00; /* bmPINLengthFormat */
2300   pin_modify[5] = 0x00; /* bInsertionOffsetOld */
2301   pin_modify[6] = pininfo->fixedlen; /* bInsertionOffsetNew */
2302   pin_modify[7] = pininfo->maxlen; /* wPINMaxExtraDigit */
2303   pin_modify[8] = pininfo->minlen; /* wPINMaxExtraDigit */
2304   pin_modify[9] = (p0 == 0 ? 0x03 : 0x01);
2305                   /* bConfirmPIN
2306                    *    0x00: new PIN once
2307                    *    0x01: new PIN twice (confirmation)
2308                    *    0x02: old PIN and new PIN once
2309                    *    0x03: old PIN and new PIN twice (confirmation)
2310                    */
2311   pin_modify[10] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2312   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2313     pin_modify[10] |= 0x01; /* Max size reached.  */
2314   pin_modify[11] = 0x03; /* bNumberMessage: Three messages */
2315   pin_modify[12] = 0x09; /* wLangId: 0x0409: US English */
2316   pin_modify[13] = 0x04; /* wLangId: 0x0409: US English */
2317   pin_modify[14] = 0x00; /* bMsgIndex1 */
2318   pin_modify[15] = 0x01; /* bMsgIndex2 */
2319   pin_modify[16] = 0x02; /* bMsgIndex3 */
2320   pin_modify[17] = 0x00; /* bTeoPrologue[0] */
2321   pin_modify[18] = 0x00; /* bTeoPrologue[1] */
2322   pin_modify[19] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2323   pin_modify[20] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2324   pin_modify[21] = 0x00; /* ulDataLength */
2325   pin_modify[22] = 0x00; /* ulDataLength */
2326   pin_modify[23] = 0x00; /* ulDataLength */
2327   pin_modify[24] = class; /* abData[0] */
2328   pin_modify[25] = ins; /* abData[1] */
2329   pin_modify[26] = p0; /* abData[2] */
2330   pin_modify[27] = p1; /* abData[3] */
2331   pin_modify[28] = 2 * pininfo->fixedlen; /* abData[4] */
2332   if (pininfo->fixedlen)
2333     memset (&pin_modify[29], 0xff, 2 * pininfo->fixedlen);
2334   else if (no_lc)
2335     len--;
2336
2337   if (DBG_CARD_IO)
2338     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2339                class, ins, p0, p1, len, (int)pininfo->maxlen);
2340
2341   sw = control_pcsc (slot, reader_table[slot].pcsc.modify_ioctl,
2342                      pin_modify, len, result, &resultlen);
2343   xfree (pin_modify);
2344   if (sw || resultlen < 2)
2345     {
2346       log_error ("control_pcsc failed: %d\n", sw);
2347       return sw? sw : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2348     }
2349   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2350   if (DBG_CARD_IO)
2351     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2352   return sw;
2353 }
2354 \f
2355 #ifdef HAVE_LIBUSB
2356 /*
2357      Internal CCID driver interface.
2358  */
2359
2360
2361 static void
2362 dump_ccid_reader_status (int slot)
2363 {
2364   log_info ("reader slot %d: using ccid driver\n", slot);
2365 }
2366
2367 static int
2368 close_ccid_reader (int slot)
2369 {
2370   ccid_close_reader (reader_table[slot].ccid.handle);
2371   reader_table[slot].used = 0;
2372   return 0;
2373 }
2374
2375
2376 static int
2377 shutdown_ccid_reader (int slot)
2378 {
2379   ccid_shutdown_reader (reader_table[slot].ccid.handle);
2380   return 0;
2381 }
2382
2383
2384 static int
2385 reset_ccid_reader (int slot)
2386 {
2387   int err;
2388   reader_table_t slotp = reader_table + slot;
2389   unsigned char atr[33];
2390   size_t atrlen;
2391
2392   err = ccid_get_atr (slotp->ccid.handle, atr, sizeof atr, &atrlen);
2393   if (err)
2394     return err;
2395   /* If the reset was successful, update the ATR. */
2396   assert (sizeof slotp->atr >= sizeof atr);
2397   slotp->atrlen = atrlen;
2398   memcpy (slotp->atr, atr, atrlen);
2399   dump_reader_status (slot);
2400   return 0;
2401 }
2402
2403
2404 static int
2405 set_progress_cb_ccid_reader (int slot, gcry_handler_progress_t cb, void *cb_arg)
2406 {
2407   reader_table_t slotp = reader_table + slot;
2408
2409   return ccid_set_progress_cb (slotp->ccid.handle, cb, cb_arg);
2410 }
2411
2412
2413 static int
2414 get_status_ccid (int slot, unsigned int *status)
2415 {
2416   int rc;
2417   int bits;
2418
2419   rc = ccid_slot_status (reader_table[slot].ccid.handle, &bits);
2420   if (rc)
2421     return rc;
2422
2423   if (bits == 0)
2424     *status = (APDU_CARD_USABLE|APDU_CARD_PRESENT|APDU_CARD_ACTIVE);
2425   else if (bits == 1)
2426     *status = APDU_CARD_PRESENT;
2427   else
2428     *status = 0;
2429
2430   return 0;
2431 }
2432
2433
2434 /* Actually send the APDU of length APDULEN to SLOT and return a
2435    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2436    set to BUFLEN.  Returns: Internal CCID driver error code. */
2437 static int
2438 send_apdu_ccid (int slot, unsigned char *apdu, size_t apdulen,
2439                 unsigned char *buffer, size_t *buflen,
2440                 pininfo_t *pininfo)
2441 {
2442   long err;
2443   size_t maxbuflen;
2444
2445   /* If we don't have an ATR, we need to reset the reader first. */
2446   if (!reader_table[slot].atrlen
2447       && (err = reset_ccid_reader (slot)))
2448     return err;
2449
2450   if (DBG_CARD_IO)
2451     log_printhex (" raw apdu:", apdu, apdulen);
2452
2453   maxbuflen = *buflen;
2454   if (pininfo)
2455     err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2456                                   apdu, apdulen, pininfo,
2457                                   buffer, maxbuflen, buflen);
2458   else
2459     err = ccid_transceive (reader_table[slot].ccid.handle,
2460                            apdu, apdulen,
2461                            buffer, maxbuflen, buflen);
2462   if (err)
2463     log_error ("ccid_transceive failed: (0x%lx)\n",
2464                err);
2465
2466   return err;
2467 }
2468
2469
2470 /* Check whether the CCID reader supports the ISO command code COMMAND
2471    on the pinpad.  Return 0 on success.  For a description of the pin
2472    parameters, see ccid-driver.c */
2473 static int
2474 check_ccid_pinpad (int slot, int command, pininfo_t *pininfo)
2475 {
2476   unsigned char apdu[] = { 0, 0, 0, 0x81 };
2477
2478   apdu[1] = command;
2479   return ccid_transceive_secure (reader_table[slot].ccid.handle, apdu,
2480                                  sizeof apdu, pininfo, NULL, 0, NULL);
2481 }
2482
2483
2484 static int
2485 ccid_pinpad_operation (int slot, int class, int ins, int p0, int p1,
2486                        pininfo_t *pininfo)
2487 {
2488   unsigned char apdu[4];
2489   int err, sw;
2490   unsigned char result[2];
2491   size_t resultlen = 2;
2492
2493   apdu[0] = class;
2494   apdu[1] = ins;
2495   apdu[2] = p0;
2496   apdu[3] = p1;
2497   err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2498                                 apdu, sizeof apdu, pininfo,
2499                                 result, 2, &resultlen);
2500   if (err)
2501     return err;
2502
2503   if (resultlen < 2)
2504     return SW_HOST_INCOMPLETE_CARD_RESPONSE;
2505
2506   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2507   return sw;
2508 }
2509
2510
2511 /* Open the reader and try to read an ATR.  */
2512 static int
2513 open_ccid_reader (const char *portstr)
2514 {
2515   int err;
2516   int slot;
2517   reader_table_t slotp;
2518
2519   slot = new_reader_slot ();
2520   if (slot == -1)
2521     return -1;
2522   slotp = reader_table + slot;
2523
2524   err = ccid_open_reader (&slotp->ccid.handle, portstr);
2525   if (err)
2526     {
2527       slotp->used = 0;
2528       return -1;
2529     }
2530
2531   err = ccid_get_atr (slotp->ccid.handle,
2532                       slotp->atr, sizeof slotp->atr, &slotp->atrlen);
2533   if (err)
2534     {
2535       slotp->atrlen = 0;
2536       err = 0;
2537     }
2538   else
2539     {
2540       /* If we got to here we know that a card is present
2541          and usable.  Thus remember this.  */
2542       reader_table[slot].last_status = (APDU_CARD_USABLE
2543                                         | APDU_CARD_PRESENT
2544                                         | APDU_CARD_ACTIVE);
2545     }
2546
2547   reader_table[slot].close_reader = close_ccid_reader;
2548   reader_table[slot].shutdown_reader = shutdown_ccid_reader;
2549   reader_table[slot].reset_reader = reset_ccid_reader;
2550   reader_table[slot].get_status_reader = get_status_ccid;
2551   reader_table[slot].send_apdu_reader = send_apdu_ccid;
2552   reader_table[slot].check_pinpad = check_ccid_pinpad;
2553   reader_table[slot].dump_status_reader = dump_ccid_reader_status;
2554   reader_table[slot].set_progress_cb = set_progress_cb_ccid_reader;
2555   reader_table[slot].pinpad_verify = ccid_pinpad_operation;
2556   reader_table[slot].pinpad_modify = ccid_pinpad_operation;
2557   /* Our CCID reader code does not support T=0 at all, thus reset the
2558      flag.  */
2559   reader_table[slot].is_t0 = 0;
2560
2561   dump_reader_status (slot);
2562   return slot;
2563 }
2564
2565
2566
2567 #endif /* HAVE_LIBUSB */
2568
2569
2570 \f
2571 #ifdef USE_G10CODE_RAPDU
2572 /*
2573      The Remote APDU Interface.
2574
2575      This uses the Remote APDU protocol to contact a reader.
2576
2577      The port number is actually an index into the list of ports as
2578      returned via the protocol.
2579  */
2580
2581
2582 static int
2583 rapdu_status_to_sw (int status)
2584 {
2585   int rc;
2586
2587   switch (status)
2588     {
2589     case RAPDU_STATUS_SUCCESS:  rc = 0; break;
2590
2591     case RAPDU_STATUS_INVCMD:
2592     case RAPDU_STATUS_INVPROT:
2593     case RAPDU_STATUS_INVSEQ:
2594     case RAPDU_STATUS_INVCOOKIE:
2595     case RAPDU_STATUS_INVREADER:  rc = SW_HOST_INV_VALUE;  break;
2596
2597     case RAPDU_STATUS_TIMEOUT:  rc = SW_HOST_CARD_IO_ERROR; break;
2598     case RAPDU_STATUS_CARDIO:   rc = SW_HOST_CARD_IO_ERROR; break;
2599     case RAPDU_STATUS_NOCARD:   rc = SW_HOST_NO_CARD; break;
2600     case RAPDU_STATUS_CARDCHG:  rc = SW_HOST_NO_CARD; break;
2601     case RAPDU_STATUS_BUSY:     rc = SW_HOST_BUSY; break;
2602     case RAPDU_STATUS_NEEDRESET: rc = SW_HOST_CARD_INACTIVE; break;
2603
2604     default: rc = SW_HOST_GENERAL_ERROR; break;
2605     }
2606
2607   return rc;
2608 }
2609
2610
2611
2612 static int
2613 close_rapdu_reader (int slot)
2614 {
2615   rapdu_release (reader_table[slot].rapdu.handle);
2616   reader_table[slot].used = 0;
2617   return 0;
2618 }
2619
2620
2621 static int
2622 reset_rapdu_reader (int slot)
2623 {
2624   int err;
2625   reader_table_t slotp;
2626   rapdu_msg_t msg = NULL;
2627
2628   slotp = reader_table + slot;
2629
2630   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2631   if (err)
2632     {
2633       log_error ("sending rapdu command RESET failed: %s\n",
2634                 err < 0 ? strerror (errno): rapdu_strerror (err));
2635       rapdu_msg_release (msg);
2636       return rapdu_status_to_sw (err);
2637     }
2638   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2639   if (err)
2640     {
2641       log_error ("receiving rapdu message failed: %s\n",
2642                 err < 0 ? strerror (errno): rapdu_strerror (err));
2643       rapdu_msg_release (msg);
2644       return rapdu_status_to_sw (err);
2645     }
2646   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2647     {
2648       int sw = rapdu_status_to_sw (msg->cmd);
2649       log_error ("rapdu command RESET failed: %s\n",
2650                  rapdu_strerror (msg->cmd));
2651       rapdu_msg_release (msg);
2652       return sw;
2653     }
2654   if (msg->datalen > DIM (slotp->atr))
2655     {
2656       log_error ("ATR returned by the RAPDU layer is too large\n");
2657       rapdu_msg_release (msg);
2658       return SW_HOST_INV_VALUE;
2659     }
2660   slotp->atrlen = msg->datalen;
2661   memcpy (slotp->atr, msg->data, msg->datalen);
2662
2663   rapdu_msg_release (msg);
2664   return 0;
2665 }
2666
2667
2668 static int
2669 my_rapdu_get_status (int slot, unsigned int *status)
2670 {
2671   int err;
2672   reader_table_t slotp;
2673   rapdu_msg_t msg = NULL;
2674   int oldslot;
2675
2676   slotp = reader_table + slot;
2677
2678   oldslot = rapdu_set_reader (slotp->rapdu.handle, slot);
2679   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_STATUS);
2680   rapdu_set_reader (slotp->rapdu.handle, oldslot);
2681   if (err)
2682     {
2683       log_error ("sending rapdu command GET_STATUS failed: %s\n",
2684                 err < 0 ? strerror (errno): rapdu_strerror (err));
2685       return rapdu_status_to_sw (err);
2686     }
2687   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2688   if (err)
2689     {
2690       log_error ("receiving rapdu message failed: %s\n",
2691                 err < 0 ? strerror (errno): rapdu_strerror (err));
2692       rapdu_msg_release (msg);
2693       return rapdu_status_to_sw (err);
2694     }
2695   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2696     {
2697       int sw = rapdu_status_to_sw (msg->cmd);
2698       log_error ("rapdu command GET_STATUS failed: %s\n",
2699                  rapdu_strerror (msg->cmd));
2700       rapdu_msg_release (msg);
2701       return sw;
2702     }
2703   *status = msg->data[0];
2704
2705   rapdu_msg_release (msg);
2706   return 0;
2707 }
2708
2709
2710 /* Actually send the APDU of length APDULEN to SLOT and return a
2711    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2712    set to BUFLEN.  Returns: APDU error code. */
2713 static int
2714 my_rapdu_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
2715                     unsigned char *buffer, size_t *buflen,
2716                     pininfo_t *pininfo)
2717 {
2718   int err;
2719   reader_table_t slotp;
2720   rapdu_msg_t msg = NULL;
2721   size_t maxlen = *buflen;
2722
2723   slotp = reader_table + slot;
2724
2725   *buflen = 0;
2726   if (DBG_CARD_IO)
2727     log_printhex ("  APDU_data:", apdu, apdulen);
2728
2729   if (apdulen < 4)
2730     {
2731       log_error ("rapdu_send_apdu: APDU is too short\n");
2732       return SW_HOST_INV_VALUE;
2733     }
2734
2735   err = rapdu_send_apdu (slotp->rapdu.handle, apdu, apdulen);
2736   if (err)
2737     {
2738       log_error ("sending rapdu command APDU failed: %s\n",
2739                 err < 0 ? strerror (errno): rapdu_strerror (err));
2740       rapdu_msg_release (msg);
2741       return rapdu_status_to_sw (err);
2742     }
2743   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2744   if (err)
2745     {
2746       log_error ("receiving rapdu message failed: %s\n",
2747                 err < 0 ? strerror (errno): rapdu_strerror (err));
2748       rapdu_msg_release (msg);
2749       return rapdu_status_to_sw (err);
2750     }
2751   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2752     {
2753       int sw = rapdu_status_to_sw (msg->cmd);
2754       log_error ("rapdu command APDU failed: %s\n",
2755                  rapdu_strerror (msg->cmd));
2756       rapdu_msg_release (msg);
2757       return sw;
2758     }
2759
2760   if (msg->datalen > maxlen)
2761     {
2762       log_error ("rapdu response apdu too large\n");
2763       rapdu_msg_release (msg);
2764       return SW_HOST_INV_VALUE;
2765     }
2766
2767   *buflen = msg->datalen;
2768   memcpy (buffer, msg->data, msg->datalen);
2769
2770   rapdu_msg_release (msg);
2771   return 0;
2772 }
2773
2774 static int
2775 open_rapdu_reader (int portno,
2776                    const unsigned char *cookie, size_t length,
2777                    int (*readfnc) (void *opaque,
2778                                    void *buffer, size_t size),
2779                    void *readfnc_value,
2780                    int (*writefnc) (void *opaque,
2781                                     const void *buffer, size_t size),
2782                    void *writefnc_value,
2783                    void (*closefnc) (void *opaque),
2784                    void *closefnc_value)
2785 {
2786   int err;
2787   int slot;
2788   reader_table_t slotp;
2789   rapdu_msg_t msg = NULL;
2790
2791   slot = new_reader_slot ();
2792   if (slot == -1)
2793     return -1;
2794   slotp = reader_table + slot;
2795
2796   slotp->rapdu.handle = rapdu_new ();
2797   if (!slotp->rapdu.handle)
2798     {
2799       slotp->used = 0;
2800       return -1;
2801     }
2802
2803   rapdu_set_reader (slotp->rapdu.handle, portno);
2804
2805   rapdu_set_iofunc (slotp->rapdu.handle,
2806                     readfnc, readfnc_value,
2807                     writefnc, writefnc_value,
2808                     closefnc, closefnc_value);
2809   rapdu_set_cookie (slotp->rapdu.handle, cookie, length);
2810
2811   /* First try to get the current ATR, but if the card is inactive
2812      issue a reset instead.  */
2813   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_ATR);
2814   if (err == RAPDU_STATUS_NEEDRESET)
2815     err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2816   if (err)
2817     {
2818       log_info ("sending rapdu command GET_ATR/RESET failed: %s\n",
2819                 err < 0 ? strerror (errno): rapdu_strerror (err));
2820       goto failure;
2821     }
2822   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2823   if (err)
2824     {
2825       log_info ("receiving rapdu message failed: %s\n",
2826                 err < 0 ? strerror (errno): rapdu_strerror (err));
2827       goto failure;
2828     }
2829   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2830     {
2831       log_info ("rapdu command GET ATR failed: %s\n",
2832                  rapdu_strerror (msg->cmd));
2833       goto failure;
2834     }
2835   if (msg->datalen > DIM (slotp->atr))
2836     {
2837       log_error ("ATR returned by the RAPDU layer is too large\n");
2838       goto failure;
2839     }
2840   slotp->atrlen = msg->datalen;
2841   memcpy (slotp->atr, msg->data, msg->datalen);
2842
2843   reader_table[slot].close_reader = close_rapdu_reader;
2844   reader_table[slot].reset_reader = reset_rapdu_reader;
2845   reader_table[slot].get_status_reader = my_rapdu_get_status;
2846   reader_table[slot].send_apdu_reader = my_rapdu_send_apdu;
2847   reader_table[slot].check_pinpad = NULL;
2848   reader_table[slot].dump_status_reader = NULL;
2849   reader_table[slot].pinpad_verify = NULL;
2850   reader_table[slot].pinpad_modify = NULL;
2851
2852   dump_reader_status (slot);
2853   rapdu_msg_release (msg);
2854   return slot;
2855
2856  failure:
2857   rapdu_msg_release (msg);
2858   rapdu_release (slotp->rapdu.handle);
2859   slotp->used = 0;
2860   return -1;
2861 }
2862
2863 #endif /*USE_G10CODE_RAPDU*/
2864
2865
2866 \f
2867 /*
2868        Driver Access
2869  */
2870
2871
2872 static int
2873 lock_slot (int slot)
2874 {
2875 #ifdef USE_NPTH
2876   int err;
2877
2878   err = npth_mutex_lock (&reader_table[slot].lock);
2879   if (err)
2880     {
2881       log_error ("failed to acquire apdu lock: %s\n", strerror (err));
2882       return SW_HOST_LOCKING_FAILED;
2883     }
2884 #endif /*USE_NPTH*/
2885   return 0;
2886 }
2887
2888 static int
2889 trylock_slot (int slot)
2890 {
2891 #ifdef USE_NPTH
2892   int err;
2893
2894   err = npth_mutex_trylock (&reader_table[slot].lock);
2895   if (err == EBUSY)
2896     return SW_HOST_BUSY;
2897   else if (err)
2898     {
2899       log_error ("failed to acquire apdu lock: %s\n", strerror (err));
2900       return SW_HOST_LOCKING_FAILED;
2901     }
2902 #endif /*USE_NPTH*/
2903   return 0;
2904 }
2905
2906 static void
2907 unlock_slot (int slot)
2908 {
2909 #ifdef USE_NPTH
2910   int err;
2911
2912   err = npth_mutex_unlock (&reader_table[slot].lock);
2913   if (err)
2914     log_error ("failed to release apdu lock: %s\n", strerror (errno));
2915 #endif /*USE_NPTH*/
2916 }
2917
2918
2919 /* Open the reader and return an internal slot number or -1 on
2920    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
2921    the first USB reader.  For PC/SC the first listed reader). */
2922 int
2923 apdu_open_reader (const char *portstr)
2924 {
2925   static int pcsc_api_loaded, ct_api_loaded;
2926   int slot;
2927
2928   if (DBG_READER)
2929     log_debug ("enter: apdu_open_reader: portstr=%s\n", portstr);
2930
2931 #ifdef HAVE_LIBUSB
2932   if (!opt.disable_ccid)
2933     {
2934       static int once_available;
2935       int i;
2936       const char *s;
2937
2938       slot = open_ccid_reader (portstr);
2939       if (slot != -1)
2940         {
2941           once_available = 1;
2942           if (DBG_READER)
2943             log_debug ("leave: apdu_open_reader => slot=%d [ccid]\n", slot);
2944           return slot; /* got one */
2945         }
2946
2947       /* If we ever loaded successfully loaded a CCID reader we never
2948          want to fallback to another driver.  This solves a problem
2949          where ccid was used, the card unplugged and then scdaemon
2950          tries to find a new reader and will eventually try PC/SC over
2951          and over again.  To reset this flag "gpgconf --kill scdaemon"
2952          can be used.  */
2953       if (once_available)
2954         {
2955           if (DBG_READER)
2956             log_debug ("leave: apdu_open_reader => slot=-1 (once_avail)\n");
2957           return -1;
2958         }
2959
2960       /* If a CCID reader specification has been given, the user does
2961          not want a fallback to other drivers. */
2962       if (portstr)
2963         for (s=portstr, i=0; *s; s++)
2964           if (*s == ':' && (++i == 3))
2965             {
2966               if (DBG_READER)
2967                 log_debug ("leave: apdu_open_reader => slot=-1 (no ccid)\n");
2968               return -1;
2969             }
2970     }
2971
2972 #endif /* HAVE_LIBUSB */
2973
2974   if (opt.ctapi_driver && *opt.ctapi_driver)
2975     {
2976       int port = portstr? atoi (portstr) : 32768;
2977
2978       if (!ct_api_loaded)
2979         {
2980           void *handle;
2981
2982           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
2983           if (!handle)
2984             {
2985               log_error ("apdu_open_reader: failed to open driver: %s\n",
2986                          dlerror ());
2987               return -1;
2988             }
2989           CT_init = dlsym (handle, "CT_init");
2990           CT_data = dlsym (handle, "CT_data");
2991           CT_close = dlsym (handle, "CT_close");
2992           if (!CT_init || !CT_data || !CT_close)
2993             {
2994               log_error ("apdu_open_reader: invalid CT-API driver\n");
2995               dlclose (handle);
2996               return -1;
2997             }
2998           ct_api_loaded = 1;
2999         }
3000       return open_ct_reader (port);
3001     }
3002
3003
3004   /* No ctAPI configured, so lets try the PC/SC API */
3005   if (!pcsc_api_loaded)
3006     {
3007 #ifndef NEED_PCSC_WRAPPER
3008       void *handle;
3009
3010       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
3011       if (!handle)
3012         {
3013           log_error ("apdu_open_reader: failed to open driver '%s': %s\n",
3014                      opt.pcsc_driver, dlerror ());
3015           return -1;
3016         }
3017
3018       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
3019       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
3020       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
3021 #if defined(_WIN32) || defined(__CYGWIN__)
3022       if (!pcsc_list_readers)
3023         pcsc_list_readers    = dlsym (handle, "SCardListReadersA");
3024 #endif
3025       pcsc_get_status_change = dlsym (handle, "SCardGetStatusChange");
3026 #if defined(_WIN32) || defined(__CYGWIN__)
3027       if (!pcsc_get_status_change)
3028         pcsc_get_status_change = dlsym (handle, "SCardGetStatusChangeA");
3029 #endif
3030       pcsc_connect           = dlsym (handle, "SCardConnect");
3031 #if defined(_WIN32) || defined(__CYGWIN__)
3032       if (!pcsc_connect)
3033         pcsc_connect         = dlsym (handle, "SCardConnectA");
3034 #endif
3035       pcsc_reconnect         = dlsym (handle, "SCardReconnect");
3036 #if defined(_WIN32) || defined(__CYGWIN__)
3037       if (!pcsc_reconnect)
3038         pcsc_reconnect       = dlsym (handle, "SCardReconnectA");
3039 #endif
3040       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
3041       pcsc_status            = dlsym (handle, "SCardStatus");
3042 #if defined(_WIN32) || defined(__CYGWIN__)
3043       if (!pcsc_status)
3044         pcsc_status          = dlsym (handle, "SCardStatusA");
3045 #endif
3046       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
3047       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
3048       pcsc_transmit          = dlsym (handle, "SCardTransmit");
3049       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
3050       pcsc_control           = dlsym (handle, "SCardControl");
3051
3052       if (!pcsc_establish_context
3053           || !pcsc_release_context
3054           || !pcsc_list_readers
3055           || !pcsc_get_status_change
3056           || !pcsc_connect
3057           || !pcsc_reconnect
3058           || !pcsc_disconnect
3059           || !pcsc_status
3060           || !pcsc_begin_transaction
3061           || !pcsc_end_transaction
3062           || !pcsc_transmit
3063           || !pcsc_control
3064           /* || !pcsc_set_timeout */)
3065         {
3066           /* Note that set_timeout is currently not used and also not
3067              available under Windows. */
3068           log_error ("apdu_open_reader: invalid PC/SC driver "
3069                      "(%d%d%d%d%d%d%d%d%d%d%d%d%d)\n",
3070                      !!pcsc_establish_context,
3071                      !!pcsc_release_context,
3072                      !!pcsc_list_readers,
3073                      !!pcsc_get_status_change,
3074                      !!pcsc_connect,
3075                      !!pcsc_reconnect,
3076                      !!pcsc_disconnect,
3077                      !!pcsc_status,
3078                      !!pcsc_begin_transaction,
3079                      !!pcsc_end_transaction,
3080                      !!pcsc_transmit,
3081                      !!pcsc_set_timeout,
3082                      !!pcsc_control );
3083           dlclose (handle);
3084           return -1;
3085         }
3086 #endif /*!NEED_PCSC_WRAPPER*/
3087       pcsc_api_loaded = 1;
3088     }
3089
3090   slot = open_pcsc_reader (portstr);
3091
3092   if (DBG_READER)
3093     log_debug ("leave: apdu_open_reader => slot=%d [pc/sc]\n", slot);
3094   return slot;
3095 }
3096
3097
3098 /* Open an remote reader and return an internal slot number or -1 on
3099    error. This function is an alternative to apdu_open_reader and used
3100    with remote readers only.  Note that the supplied CLOSEFNC will
3101    only be called once and the slot will not be valid afther this.
3102
3103    If PORTSTR is NULL we default to the first availabe port.
3104 */
3105 int
3106 apdu_open_remote_reader (const char *portstr,
3107                          const unsigned char *cookie, size_t length,
3108                          int (*readfnc) (void *opaque,
3109                                          void *buffer, size_t size),
3110                          void *readfnc_value,
3111                          int (*writefnc) (void *opaque,
3112                                           const void *buffer, size_t size),
3113                          void *writefnc_value,
3114                          void (*closefnc) (void *opaque),
3115                          void *closefnc_value)
3116 {
3117 #ifdef USE_G10CODE_RAPDU
3118   return open_rapdu_reader (portstr? atoi (portstr) : 0,
3119                             cookie, length,
3120                             readfnc, readfnc_value,
3121                             writefnc, writefnc_value,
3122                             closefnc, closefnc_value);
3123 #else
3124   (void)portstr;
3125   (void)cookie;
3126   (void)length;
3127   (void)readfnc;
3128   (void)readfnc_value;
3129   (void)writefnc;
3130   (void)writefnc_value;
3131   (void)closefnc;
3132   (void)closefnc_value;
3133 #ifdef _WIN32
3134   errno = ENOENT;
3135 #else
3136   errno = ENOSYS;
3137 #endif
3138   return -1;
3139 #endif
3140 }
3141
3142
3143 int
3144 apdu_close_reader (int slot)
3145 {
3146   int sw;
3147
3148   if (DBG_READER)
3149     log_debug ("enter: apdu_close_reader: slot=%d\n", slot);
3150
3151   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3152     {
3153       if (DBG_READER)
3154         log_debug ("leave: apdu_close_reader => SW_HOST_NO_DRIVER\n");
3155       return SW_HOST_NO_DRIVER;
3156     }
3157   sw = apdu_disconnect (slot);
3158   if (sw)
3159     {
3160       if (DBG_READER)
3161         log_debug ("leave: apdu_close_reader => 0x%x (apdu_disconnect)\n", sw);
3162       return sw;
3163     }
3164   if (reader_table[slot].close_reader)
3165     {
3166       sw = reader_table[slot].close_reader (slot);
3167       if (DBG_READER)
3168         log_debug ("leave: apdu_close_reader => 0x%x (close_reader)\n", sw);
3169       return sw;
3170     }
3171   if (DBG_READER)
3172     log_debug ("leave: apdu_close_reader => SW_HOST_NOT_SUPPORTED\n");
3173   return SW_HOST_NOT_SUPPORTED;
3174 }
3175
3176
3177 /* Function suitable for a cleanup function to close all reader.  It
3178    should not be used if the reader will be opened again.  The reason
3179    for implementing this to properly close USB devices so that they
3180    will startup the next time without error. */
3181 void
3182 apdu_prepare_exit (void)
3183 {
3184   static int sentinel;
3185   int slot;
3186
3187   if (!sentinel)
3188     {
3189       sentinel = 1;
3190       for (slot = 0; slot < MAX_READER; slot++)
3191         if (reader_table[slot].used)
3192           {
3193             apdu_disconnect (slot);
3194             if (reader_table[slot].close_reader)
3195               reader_table[slot].close_reader (slot);
3196             reader_table[slot].used = 0;
3197           }
3198       sentinel = 0;
3199     }
3200 }
3201
3202
3203 /* Shutdown a reader; that is basically the same as a close but keeps
3204    the handle ready for later use. A apdu_reset_reader or apdu_connect
3205    should be used to get it active again. */
3206 int
3207 apdu_shutdown_reader (int slot)
3208 {
3209   int sw;
3210
3211   if (DBG_READER)
3212     log_debug ("enter: apdu_shutdown_reader: slot=%d\n", slot);
3213
3214   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3215     {
3216       if (DBG_READER)
3217         log_debug ("leave: apdu_shutdown_reader => SW_HOST_NO_DRIVER\n");
3218       return SW_HOST_NO_DRIVER;
3219     }
3220   sw = apdu_disconnect (slot);
3221   if (sw)
3222     {
3223       if (DBG_READER)
3224         log_debug ("leave: apdu_shutdown_reader => 0x%x (apdu_disconnect)\n",
3225                    sw);
3226       return sw;
3227     }
3228   if (reader_table[slot].shutdown_reader)
3229     {
3230       sw = reader_table[slot].shutdown_reader (slot);
3231       if (DBG_READER)
3232         log_debug ("leave: apdu_shutdown_reader => 0x%x (close_reader)\n", sw);
3233       return sw;
3234     }
3235   if (DBG_READER)
3236     log_debug ("leave: apdu_shutdown_reader => SW_HOST_NOT_SUPPORTED\n");
3237   return SW_HOST_NOT_SUPPORTED;
3238 }
3239
3240 /* Enumerate all readers and return information on whether this reader
3241    is in use.  The caller should start with SLOT set to 0 and
3242    increment it with each call until an error is returned. */
3243 int
3244 apdu_enum_reader (int slot, int *used)
3245 {
3246   if (slot < 0 || slot >= MAX_READER)
3247     return SW_HOST_NO_DRIVER;
3248   *used = reader_table[slot].used;
3249   return 0;
3250 }
3251
3252
3253 /* Connect a card.  This is used to power up the card and make sure
3254    that an ATR is available.  Depending on the reader backend it may
3255    return an error for an inactive card or if no card is
3256    available.  */
3257 int
3258 apdu_connect (int slot)
3259 {
3260   int sw;
3261   unsigned int status;
3262
3263   if (DBG_READER)
3264     log_debug ("enter: apdu_connect: slot=%d\n", slot);
3265
3266   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3267     {
3268       if (DBG_READER)
3269         log_debug ("leave: apdu_connect => SW_HOST_NO_DRIVER\n");
3270       return SW_HOST_NO_DRIVER;
3271     }
3272
3273   /* Only if the access method provides a connect function we use it.
3274      If not, we expect that the card has been implicitly connected by
3275      apdu_open_reader.  */
3276   if (reader_table[slot].connect_card)
3277     {
3278       sw = lock_slot (slot);
3279       if (!sw)
3280         {
3281           sw = reader_table[slot].connect_card (slot);
3282           unlock_slot (slot);
3283         }
3284     }
3285   else
3286     sw = 0;
3287
3288   /* We need to call apdu_get_status_internal, so that the last-status
3289      machinery gets setup properly even if a card is inserted while
3290      scdaemon is fired up and apdu_get_status has not yet been called.
3291      Without that we would force a reset of the card with the next
3292      call to apdu_get_status.  */
3293   apdu_get_status_internal (slot, 1, 1, &status, NULL);
3294   if (sw)
3295     ;
3296   else if (!(status & APDU_CARD_PRESENT))
3297     sw = SW_HOST_NO_CARD;
3298   else if ((status & APDU_CARD_PRESENT) && !(status & APDU_CARD_ACTIVE))
3299     sw = SW_HOST_CARD_INACTIVE;
3300
3301   if (DBG_READER)
3302     log_debug ("leave: apdu_connect => sw=0x%x\n", sw);
3303
3304   return sw;
3305 }
3306
3307
3308 int
3309 apdu_disconnect (int slot)
3310 {
3311   int sw;
3312
3313   if (DBG_READER)
3314     log_debug ("enter: apdu_disconnect: slot=%d\n", slot);
3315
3316   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3317     {
3318       if (DBG_READER)
3319         log_debug ("leave: apdu_disconnect => SW_HOST_NO_DRIVER\n");
3320       return SW_HOST_NO_DRIVER;
3321     }
3322
3323   if (reader_table[slot].disconnect_card)
3324     {
3325       sw = lock_slot (slot);
3326       if (!sw)
3327         {
3328           sw = reader_table[slot].disconnect_card (slot);
3329           unlock_slot (slot);
3330         }
3331     }
3332   else
3333     sw = 0;
3334
3335   if (DBG_READER)
3336     log_debug ("leave: apdu_disconnect => sw=0x%x\n", sw);
3337   return sw;
3338 }
3339
3340
3341 /* Set the progress callback of SLOT to CB and its args to CB_ARG.  If
3342    CB is NULL the progress callback is removed.  */
3343 int
3344 apdu_set_progress_cb (int slot, gcry_handler_progress_t cb, void *cb_arg)
3345 {
3346   int sw;
3347
3348   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3349     return SW_HOST_NO_DRIVER;
3350
3351   if (reader_table[slot].set_progress_cb)
3352     {
3353       sw = lock_slot (slot);
3354       if (!sw)
3355         {
3356           sw = reader_table[slot].set_progress_cb (slot, cb, cb_arg);
3357           unlock_slot (slot);
3358         }
3359     }
3360   else
3361     sw = 0;
3362   return sw;
3363 }
3364
3365
3366 /* Do a reset for the card in reader at SLOT. */
3367 int
3368 apdu_reset (int slot)
3369 {
3370   int sw;
3371
3372   if (DBG_READER)
3373     log_debug ("enter: apdu_reset: slot=%d\n", slot);
3374
3375   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3376     {
3377       if (DBG_READER)
3378         log_debug ("leave: apdu_reset => SW_HOST_NO_DRIVER\n");
3379       return SW_HOST_NO_DRIVER;
3380     }
3381
3382   if ((sw = lock_slot (slot)))
3383     {
3384       if (DBG_READER)
3385         log_debug ("leave: apdu_reset => sw=0x%x (lock_slot)\n", sw);
3386       return sw;
3387     }
3388
3389   reader_table[slot].last_status = 0;
3390   if (reader_table[slot].reset_reader)
3391     sw = reader_table[slot].reset_reader (slot);
3392
3393   if (!sw)
3394     {
3395       /* If we got to here we know that a card is present
3396          and usable.  Thus remember this.  */
3397       reader_table[slot].last_status = (APDU_CARD_USABLE
3398                                         | APDU_CARD_PRESENT
3399                                         | APDU_CARD_ACTIVE);
3400     }
3401
3402   unlock_slot (slot);
3403   if (DBG_READER)
3404     log_debug ("leave: apdu_reset => sw=0x%x\n", sw);
3405   return sw;
3406 }
3407
3408
3409 /* Return the ATR or NULL if none is available.  On success the length
3410    of the ATR is stored at ATRLEN.  The caller must free the returned
3411    value.  */
3412 unsigned char *
3413 apdu_get_atr (int slot, size_t *atrlen)
3414 {
3415   unsigned char *buf;
3416
3417   if (DBG_READER)
3418     log_debug ("enter: apdu_get_atr: slot=%d\n", slot);
3419
3420   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3421     {
3422       if (DBG_READER)
3423         log_debug ("leave: apdu_get_atr => NULL (bad slot)\n");
3424       return NULL;
3425     }
3426   if (!reader_table[slot].atrlen)
3427     {
3428       if (DBG_READER)
3429         log_debug ("leave: apdu_get_atr => NULL (no ATR)\n");
3430       return NULL;
3431     }
3432
3433   buf = xtrymalloc (reader_table[slot].atrlen);
3434   if (!buf)
3435     {
3436       if (DBG_READER)
3437         log_debug ("leave: apdu_get_atr => NULL (out of core)\n");
3438       return NULL;
3439     }
3440   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
3441   *atrlen = reader_table[slot].atrlen;
3442   if (DBG_READER)
3443     log_debug ("leave: apdu_get_atr => atrlen=%zu\n", *atrlen);
3444   return buf;
3445 }
3446
3447
3448
3449 /* Retrieve the status for SLOT. The function does only wait for the
3450    card to become available if HANG is set to true. On success the
3451    bits in STATUS will be set to
3452
3453      APDU_CARD_USABLE  (bit 0) = card present and usable
3454      APDU_CARD_PRESENT (bit 1) = card present
3455      APDU_CARD_ACTIVE  (bit 2) = card active
3456                        (bit 3) = card access locked [not yet implemented]
3457
3458    For must applications, testing bit 0 is sufficient.
3459
3460    CHANGED will receive the value of the counter tracking the number
3461    of card insertions.  This value may be used to detect a card
3462    change.
3463 */
3464 static int
3465 apdu_get_status_internal (int slot, int hang, int no_atr_reset,
3466                           unsigned int *status, unsigned int *changed)
3467 {
3468   int sw;
3469   unsigned int s;
3470
3471   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3472     return SW_HOST_NO_DRIVER;
3473
3474   if ((sw = hang? lock_slot (slot) : trylock_slot (slot)))
3475     return sw;
3476
3477   if (reader_table[slot].get_status_reader)
3478     sw = reader_table[slot].get_status_reader (slot, &s);
3479
3480   unlock_slot (slot);
3481
3482   if (sw)
3483     {
3484       reader_table[slot].last_status = 0;
3485       return sw;
3486     }
3487
3488   /* Keep track of changes.  */
3489   if (s != reader_table[slot].last_status
3490       || !reader_table[slot].any_status )
3491     {
3492       reader_table[slot].change_counter++;
3493       /* Make sure that the ATR is invalid so that a reset will be
3494          triggered by apdu_activate.  */
3495       if (!no_atr_reset)
3496         reader_table[slot].atrlen = 0;
3497     }
3498   reader_table[slot].any_status = 1;
3499   reader_table[slot].last_status = s;
3500
3501   if (status)
3502     *status = s;
3503   if (changed)
3504     *changed = reader_table[slot].change_counter;
3505   return 0;
3506 }
3507
3508
3509 /* See above for a description.  */
3510 int
3511 apdu_get_status (int slot, int hang,
3512                  unsigned int *status, unsigned int *changed)
3513 {
3514   int sw;
3515
3516   if (DBG_READER)
3517     log_debug ("enter: apdu_get_status: slot=%d hang=%d\n", slot, hang);
3518   sw = apdu_get_status_internal (slot, hang, 0, status, changed);
3519   if (DBG_READER)
3520     {
3521       if (status && changed)
3522         log_debug ("leave: apdu_get_status => sw=0x%x status=%u changecnt=%u\n",
3523                    sw, *status, *changed);
3524       else if (status)
3525         log_debug ("leave: apdu_get_status => sw=0x%x status=%u\n",
3526                    sw, *status);
3527       else if (changed)
3528         log_debug ("leave: apdu_get_status => sw=0x%x changed=%u\n",
3529                    sw, *changed);
3530       else
3531         log_debug ("leave: apdu_get_status => sw=0x%x\n", sw);
3532     }
3533   return sw;
3534 }
3535
3536
3537 /* Check whether the reader supports the ISO command code COMMAND on
3538    the pinpad.  Return 0 on success.  For a description of the pin
3539    parameters, see ccid-driver.c */
3540 int
3541 apdu_check_pinpad (int slot, int command, pininfo_t *pininfo)
3542 {
3543   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3544     return SW_HOST_NO_DRIVER;
3545
3546   if (opt.enable_pinpad_varlen)
3547     pininfo->fixedlen = 0;
3548
3549   if (reader_table[slot].check_pinpad)
3550     {
3551       int sw;
3552
3553       if ((sw = lock_slot (slot)))
3554         return sw;
3555
3556       sw = reader_table[slot].check_pinpad (slot, command, pininfo);
3557       unlock_slot (slot);
3558       return sw;
3559     }
3560   else
3561     return SW_HOST_NOT_SUPPORTED;
3562 }
3563
3564
3565 int
3566 apdu_pinpad_verify (int slot, int class, int ins, int p0, int p1,
3567                     pininfo_t *pininfo)
3568 {
3569   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3570     return SW_HOST_NO_DRIVER;
3571
3572   if (reader_table[slot].pinpad_verify)
3573     {
3574       int sw;
3575
3576       if ((sw = lock_slot (slot)))
3577         return sw;
3578
3579       sw = reader_table[slot].pinpad_verify (slot, class, ins, p0, p1,
3580                                              pininfo);
3581       unlock_slot (slot);
3582       return sw;
3583     }
3584   else
3585     return SW_HOST_NOT_SUPPORTED;
3586 }
3587
3588
3589 int
3590 apdu_pinpad_modify (int slot, int class, int ins, int p0, int p1,
3591                     pininfo_t *pininfo)
3592 {
3593   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3594     return SW_HOST_NO_DRIVER;
3595
3596   if (reader_table[slot].pinpad_modify)
3597     {
3598       int sw;
3599
3600       if ((sw = lock_slot (slot)))
3601         return sw;
3602
3603       sw = reader_table[slot].pinpad_modify (slot, class, ins, p0, p1,
3604                                              pininfo);
3605       unlock_slot (slot);
3606       return sw;
3607     }
3608   else
3609     return SW_HOST_NOT_SUPPORTED;
3610 }
3611
3612
3613 /* Dispatcher for the actual send_apdu function. Note, that this
3614    function should be called in locked state. */
3615 static int
3616 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
3617            unsigned char *buffer, size_t *buflen, pininfo_t *pininfo)
3618 {
3619   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3620     return SW_HOST_NO_DRIVER;
3621
3622   if (reader_table[slot].send_apdu_reader)
3623     return reader_table[slot].send_apdu_reader (slot,
3624                                                 apdu, apdulen,
3625                                                 buffer, buflen,
3626                                                 pininfo);
3627   else
3628     return SW_HOST_NOT_SUPPORTED;
3629 }
3630
3631
3632 /* Core APDU tranceiver function. Parameters are described at
3633    apdu_send_le with the exception of PININFO which indicates pinpad
3634    related operations if not NULL.  If EXTENDED_MODE is not 0
3635    command chaining or extended length will be used according to these
3636    values:
3637        n < 0 := Use command chaining with the data part limited to -n
3638                 in each chunk.  If -1 is used a default value is used.
3639       n == 0 := No extended mode or command chaining.
3640       n == 1 := Use extended length for input and output without a
3641                 length limit.
3642        n > 1 := Use extended length with up to N bytes.
3643
3644 */
3645 static int
3646 send_le (int slot, int class, int ins, int p0, int p1,
3647          int lc, const char *data, int le,
3648          unsigned char **retbuf, size_t *retbuflen,
3649          pininfo_t *pininfo, int extended_mode)
3650 {
3651 #define SHORT_RESULT_BUFFER_SIZE 258
3652   /* We allocate 8 extra bytes as a safety margin towards a driver bug.  */
3653   unsigned char short_result_buffer[SHORT_RESULT_BUFFER_SIZE+10];
3654   unsigned char *result_buffer = NULL;
3655   size_t result_buffer_size;
3656   unsigned char *result;
3657   size_t resultlen;
3658   unsigned char short_apdu_buffer[5+256+1];
3659   unsigned char *apdu_buffer = NULL;
3660   size_t apdu_buffer_size;
3661   unsigned char *apdu;
3662   size_t apdulen;
3663   int sw;
3664   long rc; /* We need a long here due to PC/SC. */
3665   int did_exact_length_hack = 0;
3666   int use_chaining = 0;
3667   int use_extended_length = 0;
3668   int lc_chunk;
3669
3670   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3671     return SW_HOST_NO_DRIVER;
3672
3673   if (DBG_CARD_IO)
3674     log_debug ("send apdu: c=%02X i=%02X p1=%02X p2=%02X lc=%d le=%d em=%d\n",
3675                class, ins, p0, p1, lc, le, extended_mode);
3676
3677   if (lc != -1 && (lc > 255 || lc < 0))
3678     {
3679       /* Data does not fit into an APDU.  What we do now depends on
3680          the EXTENDED_MODE parameter.  */
3681       if (!extended_mode)
3682         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
3683       else if (extended_mode > 0)
3684         use_extended_length = 1;
3685       else if (extended_mode < 0)
3686         {
3687           /* Send APDU using chaining mode.  */
3688           if (lc > 16384)
3689             return SW_WRONG_LENGTH;   /* Sanity check.  */
3690           if ((class&0xf0) != 0)
3691             return SW_HOST_INV_VALUE; /* Upper 4 bits need to be 0.  */
3692           use_chaining = extended_mode == -1? 255 : -extended_mode;
3693           use_chaining &= 0xff;
3694         }
3695       else
3696         return SW_HOST_INV_VALUE;
3697     }
3698   else if (lc == -1 && extended_mode > 0)
3699     use_extended_length = 1;
3700
3701   if (le != -1 && (le > (extended_mode > 0? 255:256) || le < 0))
3702     {
3703       /* Expected Data does not fit into an APDU.  What we do now
3704          depends on the EXTENDED_MODE parameter.  Note that a check
3705          for command chaining does not make sense because we are
3706          looking at Le.  */
3707       if (!extended_mode)
3708         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
3709       else if (use_extended_length)
3710         ; /* We are already using extended length.  */
3711       else if (extended_mode > 0)
3712         use_extended_length = 1;
3713       else
3714         return SW_HOST_INV_VALUE;
3715     }
3716
3717   if ((!data && lc != -1) || (data && lc == -1))
3718     return SW_HOST_INV_VALUE;
3719
3720   if (use_extended_length)
3721     {
3722       if (reader_table[slot].is_t0)
3723         return SW_HOST_NOT_SUPPORTED;
3724
3725       /* Space for: cls/ins/p1/p2+Z+2_byte_Lc+Lc+2_byte_Le.  */
3726       apdu_buffer_size = 4 + 1 + (lc >= 0? (2+lc):0) + 2;
3727       apdu_buffer = xtrymalloc (apdu_buffer_size + 10);
3728       if (!apdu_buffer)
3729         return SW_HOST_OUT_OF_CORE;
3730       apdu = apdu_buffer;
3731     }
3732   else
3733     {
3734       apdu_buffer_size = sizeof short_apdu_buffer;
3735       apdu = short_apdu_buffer;
3736     }
3737
3738   if (use_extended_length && (le > 256 || le < 0))
3739     {
3740       result_buffer_size = le < 0? 4096 : le;
3741       result_buffer = xtrymalloc (result_buffer_size + 10);
3742       if (!result_buffer)
3743         {
3744           xfree (apdu_buffer);
3745           return SW_HOST_OUT_OF_CORE;
3746         }
3747       result = result_buffer;
3748     }
3749   else
3750     {
3751       result_buffer_size = SHORT_RESULT_BUFFER_SIZE;
3752       result = short_result_buffer;
3753     }
3754 #undef SHORT_RESULT_BUFFER_SIZE
3755
3756   if ((sw = lock_slot (slot)))
3757     {
3758       xfree (apdu_buffer);
3759       xfree (result_buffer);
3760       return sw;
3761     }
3762
3763   do
3764     {
3765       if (use_extended_length)
3766         {
3767           use_chaining = 0;
3768           apdulen = 0;
3769           apdu[apdulen++] = class;
3770           apdu[apdulen++] = ins;
3771           apdu[apdulen++] = p0;
3772           apdu[apdulen++] = p1;
3773           apdu[apdulen++] = 0;  /* Z byte: Extended length marker.  */
3774           if (lc >= 0)
3775             {
3776               apdu[apdulen++] = ((lc >> 8) & 0xff);
3777               apdu[apdulen++] = (lc & 0xff);
3778               memcpy (apdu+apdulen, data, lc);
3779               data += lc;
3780               apdulen += lc;
3781             }
3782           if (le != -1)
3783             {
3784               apdu[apdulen++] = ((le >> 8) & 0xff);
3785               apdu[apdulen++] = (le & 0xff);
3786             }
3787         }
3788       else
3789         {
3790           apdulen = 0;
3791           apdu[apdulen] = class;
3792           if (use_chaining && lc > 255)
3793             {
3794               apdu[apdulen] |= 0x10;
3795               assert (use_chaining < 256);
3796               lc_chunk = use_chaining;
3797               lc -= use_chaining;
3798             }
3799           else
3800             {
3801               use_chaining = 0;
3802               lc_chunk = lc;
3803             }
3804           apdulen++;
3805           apdu[apdulen++] = ins;
3806           apdu[apdulen++] = p0;
3807           apdu[apdulen++] = p1;
3808           if (lc_chunk != -1)
3809             {
3810               apdu[apdulen++] = lc_chunk;
3811               memcpy (apdu+apdulen, data, lc_chunk);
3812               data += lc_chunk;
3813               apdulen += lc_chunk;
3814               /* T=0 does not allow the use of Lc together with Le;
3815                  thus disable Le in this case.  */
3816               if (reader_table[slot].is_t0)
3817                 le = -1;
3818             }
3819           if (le != -1 && !use_chaining)
3820             apdu[apdulen++] = le; /* Truncation is okay (0 means 256). */
3821         }
3822
3823     exact_length_hack:
3824       /* As a safeguard don't pass any garbage to the driver.  */
3825       assert (apdulen <= apdu_buffer_size);
3826       memset (apdu+apdulen, 0, apdu_buffer_size - apdulen);
3827       resultlen = result_buffer_size;
3828       rc = send_apdu (slot, apdu, apdulen, result, &resultlen, pininfo);
3829       if (rc || resultlen < 2)
3830         {
3831           log_info ("apdu_send_simple(%d) failed: %s\n",
3832                     slot, apdu_strerror (rc));
3833           unlock_slot (slot);
3834           xfree (apdu_buffer);
3835           xfree (result_buffer);
3836           return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
3837         }
3838       sw = (result[resultlen-2] << 8) | result[resultlen-1];
3839       if (!use_extended_length
3840           && !did_exact_length_hack && SW_EXACT_LENGTH_P (sw))
3841         {
3842           apdu[apdulen-1] = (sw & 0x00ff);
3843           did_exact_length_hack = 1;
3844           goto exact_length_hack;
3845         }
3846     }
3847   while (use_chaining && sw == SW_SUCCESS);
3848
3849   if (apdu_buffer)
3850     {
3851       xfree (apdu_buffer);
3852       apdu_buffer = NULL;
3853       apdu_buffer_size = 0;
3854     }
3855
3856   /* Store away the returned data but strip the statusword. */
3857   resultlen -= 2;
3858   if (DBG_CARD_IO)
3859     {
3860       log_debug (" response: sw=%04X  datalen=%d\n",
3861                  sw, (unsigned int)resultlen);
3862       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
3863         log_printhex ("    dump: ", result, resultlen);
3864     }
3865
3866   if (sw == SW_SUCCESS || sw == SW_EOF_REACHED)
3867     {
3868       if (retbuf)
3869         {
3870           *retbuf = xtrymalloc (resultlen? resultlen : 1);
3871           if (!*retbuf)
3872             {
3873               unlock_slot (slot);
3874               xfree (result_buffer);
3875               return SW_HOST_OUT_OF_CORE;
3876             }
3877           *retbuflen = resultlen;
3878           memcpy (*retbuf, result, resultlen);
3879         }
3880     }
3881   else if ((sw & 0xff00) == SW_MORE_DATA)
3882     {
3883       unsigned char *p = NULL, *tmp;
3884       size_t bufsize = 4096;
3885
3886       /* It is likely that we need to return much more data, so we
3887          start off with a large buffer. */
3888       if (retbuf)
3889         {
3890           *retbuf = p = xtrymalloc (bufsize);
3891           if (!*retbuf)
3892             {
3893               unlock_slot (slot);
3894               xfree (result_buffer);
3895               return SW_HOST_OUT_OF_CORE;
3896             }
3897           assert (resultlen < bufsize);
3898           memcpy (p, result, resultlen);
3899           p += resultlen;
3900         }
3901
3902       do
3903         {
3904           int len = (sw & 0x00ff);
3905
3906           if (DBG_CARD_IO)
3907             log_debug ("apdu_send_simple(%d): %d more bytes available\n",
3908                        slot, len);
3909           apdu_buffer_size = sizeof short_apdu_buffer;
3910           apdu = short_apdu_buffer;
3911           apdulen = 0;
3912           apdu[apdulen++] = class;
3913           apdu[apdulen++] = 0xC0;
3914           apdu[apdulen++] = 0;
3915           apdu[apdulen++] = 0;
3916           apdu[apdulen++] = len;
3917           assert (apdulen <= apdu_buffer_size);
3918           memset (apdu+apdulen, 0, apdu_buffer_size - apdulen);
3919           resultlen = result_buffer_size;
3920           rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
3921           if (rc || resultlen < 2)
3922             {
3923               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
3924                          slot, apdu_strerror (rc));
3925               unlock_slot (slot);
3926               xfree (result_buffer);
3927               return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
3928             }
3929           sw = (result[resultlen-2] << 8) | result[resultlen-1];
3930           resultlen -= 2;
3931           if (DBG_CARD_IO)
3932             {
3933               log_debug ("     more: sw=%04X  datalen=%d\n",
3934                          sw, (unsigned int)resultlen);
3935               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
3936                 log_printhex ("     dump: ", result, resultlen);
3937             }
3938
3939           if ((sw & 0xff00) == SW_MORE_DATA
3940               || sw == SW_SUCCESS
3941               || sw == SW_EOF_REACHED )
3942             {
3943               if (retbuf && resultlen)
3944                 {
3945                   if (p - *retbuf + resultlen > bufsize)
3946                     {
3947                       bufsize += resultlen > 4096? resultlen: 4096;
3948                       tmp = xtryrealloc (*retbuf, bufsize);
3949                       if (!tmp)
3950                         {
3951                           unlock_slot (slot);
3952                           xfree (result_buffer);
3953                           return SW_HOST_OUT_OF_CORE;
3954                         }
3955                       p = tmp + (p - *retbuf);
3956                       *retbuf = tmp;
3957                     }
3958                   memcpy (p, result, resultlen);
3959                   p += resultlen;
3960                 }
3961             }
3962           else
3963             log_info ("apdu_send_simple(%d) "
3964                       "got unexpected status %04X from get response\n",
3965                       slot, sw);
3966         }
3967       while ((sw & 0xff00) == SW_MORE_DATA);
3968
3969       if (retbuf)
3970         {
3971           *retbuflen = p - *retbuf;
3972           tmp = xtryrealloc (*retbuf, *retbuflen);
3973           if (tmp)
3974             *retbuf = tmp;
3975         }
3976     }
3977
3978   unlock_slot (slot);
3979   xfree (result_buffer);
3980
3981   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
3982     log_printhex ("      dump: ", *retbuf, *retbuflen);
3983
3984   return sw;
3985 }
3986
3987 /* Send an APDU to the card in SLOT.  The APDU is created from all
3988    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
3989    for LC won't sent this field and the data field; in this case DATA
3990    must also be passed as NULL.  If EXTENDED_MODE is not 0 command
3991    chaining or extended length will be used; see send_le for details.
3992    The return value is the status word or -1 for an invalid SLOT or
3993    other non card related error.  If RETBUF is not NULL, it will
3994    receive an allocated buffer with the returned data.  The length of
3995    that data will be put into *RETBUFLEN.  The caller is reponsible
3996    for releasing the buffer even in case of errors.  */
3997 int
3998 apdu_send_le(int slot, int extended_mode,
3999              int class, int ins, int p0, int p1,
4000              int lc, const char *data, int le,
4001              unsigned char **retbuf, size_t *retbuflen)
4002 {
4003   return send_le (slot, class, ins, p0, p1,
4004                   lc, data, le,
4005                   retbuf, retbuflen,
4006                   NULL, extended_mode);
4007 }
4008
4009
4010 /* Send an APDU to the card in SLOT.  The APDU is created from all
4011    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
4012    LC won't sent this field and the data field; in this case DATA must
4013    also be passed as NULL.  If EXTENDED_MODE is not 0 command chaining
4014    or extended length will be used; see send_le for details.  The
4015    return value is the status word or -1 for an invalid SLOT or other
4016    non card related error.  If RETBUF is not NULL, it will receive an
4017    allocated buffer with the returned data.  The length of that data
4018    will be put into *RETBUFLEN.  The caller is reponsible for
4019    releasing the buffer even in case of errors.  */
4020 int
4021 apdu_send (int slot, int extended_mode,
4022            int class, int ins, int p0, int p1,
4023            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
4024 {
4025   return send_le (slot, class, ins, p0, p1, lc, data, 256,
4026                   retbuf, retbuflen, NULL, extended_mode);
4027 }
4028
4029 /* Send an APDU to the card in SLOT.  The APDU is created from all
4030    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
4031    LC won't sent this field and the data field; in this case DATA must
4032    also be passed as NULL.  If EXTENDED_MODE is not 0 command chaining
4033    or extended length will be used; see send_le for details.  The
4034    return value is the status word or -1 for an invalid SLOT or other
4035    non card related error.  No data will be returned.  */
4036 int
4037 apdu_send_simple (int slot, int extended_mode,
4038                   int class, int ins, int p0, int p1,
4039                   int lc, const char *data)
4040 {
4041   return send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL, NULL,
4042                   extended_mode);
4043 }
4044
4045
4046 /* This is a more generic version of the apdu sending routine.  It
4047    takes an already formatted APDU in APDUDATA or length APDUDATALEN
4048    and returns with an APDU including the status word.  With
4049    HANDLE_MORE set to true this function will handle the MORE DATA
4050    status and return all APDUs concatenated with one status word at
4051    the end.  If EXTENDED_LENGTH is != 0 extended lengths are allowed
4052    with a max. result data length of EXTENDED_LENGTH bytes.  The
4053    function does not return a regular status word but 0 on success.
4054    If the slot is locked, the function returns immediately with an
4055    error.  */
4056 int
4057 apdu_send_direct (int slot, size_t extended_length,
4058                   const unsigned char *apdudata, size_t apdudatalen,
4059                   int handle_more,
4060                   unsigned char **retbuf, size_t *retbuflen)
4061 {
4062 #define SHORT_RESULT_BUFFER_SIZE 258
4063   unsigned char short_result_buffer[SHORT_RESULT_BUFFER_SIZE+10];
4064   unsigned char *result_buffer = NULL;
4065   size_t result_buffer_size;
4066   unsigned char *result;
4067   size_t resultlen;
4068   unsigned char short_apdu_buffer[5+256+10];
4069   unsigned char *apdu_buffer = NULL;
4070   unsigned char *apdu;
4071   size_t apdulen;
4072   int sw;
4073   long rc; /* we need a long here due to PC/SC. */
4074   int class;
4075
4076   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
4077     return SW_HOST_NO_DRIVER;
4078
4079   if (apdudatalen > 65535)
4080     return SW_HOST_INV_VALUE;
4081
4082   if (apdudatalen > sizeof short_apdu_buffer - 5)
4083     {
4084       apdu_buffer = xtrymalloc (apdudatalen + 5);
4085       if (!apdu_buffer)
4086         return SW_HOST_OUT_OF_CORE;
4087       apdu = apdu_buffer;
4088     }
4089   else
4090     {
4091       apdu = short_apdu_buffer;
4092     }
4093   apdulen = apdudatalen;
4094   memcpy (apdu, apdudata, apdudatalen);
4095   class = apdulen? *apdu : 0;
4096
4097   if (extended_length >= 256 && extended_length <= 65536)
4098     {
4099       result_buffer_size = extended_length;
4100       result_buffer = xtrymalloc (result_buffer_size + 10);
4101       if (!result_buffer)
4102         {
4103           xfree (apdu_buffer);
4104           return SW_HOST_OUT_OF_CORE;
4105         }
4106       result = result_buffer;
4107     }
4108   else
4109     {
4110       result_buffer_size = SHORT_RESULT_BUFFER_SIZE;
4111       result = short_result_buffer;
4112     }
4113 #undef SHORT_RESULT_BUFFER_SIZE
4114
4115   if ((sw = trylock_slot (slot)))
4116     {
4117       xfree (apdu_buffer);
4118       xfree (result_buffer);
4119       return sw;
4120     }
4121
4122   resultlen = result_buffer_size;
4123   rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
4124   xfree (apdu_buffer);
4125   apdu_buffer = NULL;
4126   if (rc || resultlen < 2)
4127     {
4128       log_error ("apdu_send_direct(%d) failed: %s\n",
4129                  slot, apdu_strerror (rc));
4130       unlock_slot (slot);
4131       xfree (result_buffer);
4132       return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
4133     }
4134   sw = (result[resultlen-2] << 8) | result[resultlen-1];
4135   /* Store away the returned data but strip the statusword. */
4136   resultlen -= 2;
4137   if (DBG_CARD_IO)
4138     {
4139       log_debug (" response: sw=%04X  datalen=%d\n",
4140                  sw, (unsigned int)resultlen);
4141       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
4142         log_printhex ("     dump: ", result, resultlen);
4143     }
4144
4145   if (handle_more && (sw & 0xff00) == SW_MORE_DATA)
4146     {
4147       unsigned char *p = NULL, *tmp;
4148       size_t bufsize = 4096;
4149
4150       /* It is likely that we need to return much more data, so we
4151          start off with a large buffer. */
4152       if (retbuf)
4153         {
4154           *retbuf = p = xtrymalloc (bufsize + 2);
4155           if (!*retbuf)
4156             {
4157               unlock_slot (slot);
4158               xfree (result_buffer);
4159               return SW_HOST_OUT_OF_CORE;
4160             }
4161           assert (resultlen < bufsize);
4162           memcpy (p, result, resultlen);
4163           p += resultlen;
4164         }
4165
4166       do
4167         {
4168           int len = (sw & 0x00ff);
4169
4170           if (DBG_CARD_IO)
4171             log_debug ("apdu_send_direct(%d): %d more bytes available\n",
4172                        slot, len);
4173           apdu = short_apdu_buffer;
4174           apdulen = 0;
4175           apdu[apdulen++] = class;
4176           apdu[apdulen++] = 0xC0;
4177           apdu[apdulen++] = 0;
4178           apdu[apdulen++] = 0;
4179           apdu[apdulen++] = len;
4180           memset (apdu+apdulen, 0, sizeof (short_apdu_buffer) - apdulen);
4181           resultlen = result_buffer_size;
4182           rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
4183           if (rc || resultlen < 2)
4184             {
4185               log_error ("apdu_send_direct(%d) for get response failed: %s\n",
4186                          slot, apdu_strerror (rc));
4187               unlock_slot (slot);
4188               xfree (result_buffer);
4189               return rc ? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
4190             }
4191           sw = (result[resultlen-2] << 8) | result[resultlen-1];
4192           resultlen -= 2;
4193           if (DBG_CARD_IO)
4194             {
4195               log_debug ("     more: sw=%04X  datalen=%d\n",
4196                          sw, (unsigned int)resultlen);
4197               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
4198                 log_printhex ("     dump: ", result, resultlen);
4199             }
4200
4201           if ((sw & 0xff00) == SW_MORE_DATA
4202               || sw == SW_SUCCESS
4203               || sw == SW_EOF_REACHED )
4204             {
4205               if (retbuf && resultlen)
4206                 {
4207                   if (p - *retbuf + resultlen > bufsize)
4208                     {
4209                       bufsize += resultlen > 4096? resultlen: 4096;
4210                       tmp = xtryrealloc (*retbuf, bufsize + 2);
4211                       if (!tmp)
4212                         {
4213                           unlock_slot (slot);
4214                           xfree (result_buffer);
4215                           return SW_HOST_OUT_OF_CORE;
4216                         }
4217                       p = tmp + (p - *retbuf);
4218                       *retbuf = tmp;
4219                     }
4220                   memcpy (p, result, resultlen);
4221                   p += resultlen;
4222                 }
4223             }
4224           else
4225             log_info ("apdu_send_direct(%d) "
4226                       "got unexpected status %04X from get response\n",
4227                       slot, sw);
4228         }
4229       while ((sw & 0xff00) == SW_MORE_DATA);
4230
4231       if (retbuf)
4232         {
4233           *retbuflen = p - *retbuf;
4234           tmp = xtryrealloc (*retbuf, *retbuflen + 2);
4235           if (tmp)
4236             *retbuf = tmp;
4237         }
4238     }
4239   else
4240     {
4241       if (retbuf)
4242         {
4243           *retbuf = xtrymalloc ((resultlen? resultlen : 1)+2);
4244           if (!*retbuf)
4245             {
4246               unlock_slot (slot);
4247               xfree (result_buffer);
4248               return SW_HOST_OUT_OF_CORE;
4249             }
4250           *retbuflen = resultlen;
4251           memcpy (*retbuf, result, resultlen);
4252         }
4253     }
4254
4255   unlock_slot (slot);
4256   xfree (result_buffer);
4257
4258   /* Append the status word.  Note that we reserved the two extra
4259      bytes while allocating the buffer.  */
4260   if (retbuf)
4261     {
4262       (*retbuf)[(*retbuflen)++] = (sw >> 8);
4263       (*retbuf)[(*retbuflen)++] = sw;
4264     }
4265
4266   if (DBG_CARD_IO && retbuf)
4267     log_printhex ("      dump: ", *retbuf, *retbuflen);
4268
4269   return 0;
4270 }