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