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