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