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