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