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