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