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