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