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