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