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