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