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