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