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