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