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