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