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