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