Signing using Netkey 3 cards does now work.
[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   /* Our CCID reader code does not support T=0 at all, thus reset the
1955      flag.  */
1956   reader_table[slot].is_t0 = 0;
1957
1958   dump_reader_status (slot);
1959   return slot;
1960 }
1961
1962
1963
1964 #endif /* HAVE_LIBUSB */
1965
1966
1967 \f
1968 #ifdef USE_G10CODE_RAPDU
1969 /*
1970      The Remote APDU Interface.
1971
1972      This uses the Remote APDU protocol to contact a reader.
1973
1974      The port number is actually an index into the list of ports as
1975      returned via the protocol.
1976  */
1977
1978
1979 static int
1980 rapdu_status_to_sw (int status)
1981 {
1982   int rc;
1983
1984   switch (status)
1985     {
1986     case RAPDU_STATUS_SUCCESS:  rc = 0; break;
1987
1988     case RAPDU_STATUS_INVCMD:
1989     case RAPDU_STATUS_INVPROT:
1990     case RAPDU_STATUS_INVSEQ:
1991     case RAPDU_STATUS_INVCOOKIE:
1992     case RAPDU_STATUS_INVREADER:  rc = SW_HOST_INV_VALUE;  break;
1993
1994     case RAPDU_STATUS_TIMEOUT:  rc = SW_HOST_CARD_IO_ERROR; break;
1995     case RAPDU_STATUS_CARDIO:   rc = SW_HOST_CARD_IO_ERROR; break;
1996     case RAPDU_STATUS_NOCARD:   rc = SW_HOST_NO_CARD; break;
1997     case RAPDU_STATUS_CARDCHG:  rc = SW_HOST_NO_CARD; break;
1998     case RAPDU_STATUS_BUSY:     rc = SW_HOST_BUSY; break;
1999     case RAPDU_STATUS_NEEDRESET: rc = SW_HOST_CARD_INACTIVE; break;
2000
2001     default: rc = SW_HOST_GENERAL_ERROR; break;
2002     }
2003
2004   return rc;
2005 }
2006
2007
2008
2009 static int
2010 close_rapdu_reader (int slot)
2011 {
2012   rapdu_release (reader_table[slot].rapdu.handle);
2013   reader_table[slot].used = 0;
2014   return 0;
2015 }
2016
2017
2018 static int
2019 reset_rapdu_reader (int slot)
2020 {
2021   int err;
2022   reader_table_t slotp;
2023   rapdu_msg_t msg = NULL;
2024
2025   slotp = reader_table + slot;
2026
2027   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2028   if (err)
2029     {
2030       log_error ("sending rapdu command RESET failed: %s\n",
2031                 err < 0 ? strerror (errno): rapdu_strerror (err));
2032       rapdu_msg_release (msg);
2033       return rapdu_status_to_sw (err);
2034     }
2035   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2036   if (err)
2037     {
2038       log_error ("receiving rapdu message failed: %s\n",
2039                 err < 0 ? strerror (errno): rapdu_strerror (err));
2040       rapdu_msg_release (msg);
2041       return rapdu_status_to_sw (err);
2042     }
2043   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2044     {
2045       int sw = rapdu_status_to_sw (msg->cmd);
2046       log_error ("rapdu command RESET failed: %s\n",
2047                  rapdu_strerror (msg->cmd));
2048       rapdu_msg_release (msg);
2049       return sw;
2050     }
2051   if (msg->datalen > DIM (slotp->atr))
2052     {
2053       log_error ("ATR returned by the RAPDU layer is too large\n");
2054       rapdu_msg_release (msg);
2055       return SW_HOST_INV_VALUE;
2056     }
2057   slotp->atrlen = msg->datalen;
2058   memcpy (slotp->atr, msg->data, msg->datalen);
2059
2060   rapdu_msg_release (msg);
2061   return 0;
2062 }
2063
2064
2065 static int
2066 my_rapdu_get_status (int slot, unsigned int *status)
2067 {
2068   int err;
2069   reader_table_t slotp;
2070   rapdu_msg_t msg = NULL;
2071   int oldslot;
2072
2073   slotp = reader_table + slot;
2074
2075   oldslot = rapdu_set_reader (slotp->rapdu.handle, slot);
2076   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_STATUS);
2077   rapdu_set_reader (slotp->rapdu.handle, oldslot);
2078   if (err)
2079     {
2080       log_error ("sending rapdu command GET_STATUS failed: %s\n",
2081                 err < 0 ? strerror (errno): rapdu_strerror (err));
2082       return rapdu_status_to_sw (err);
2083     }
2084   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2085   if (err)
2086     {
2087       log_error ("receiving rapdu message failed: %s\n",
2088                 err < 0 ? strerror (errno): rapdu_strerror (err));
2089       rapdu_msg_release (msg);
2090       return rapdu_status_to_sw (err);
2091     }
2092   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2093     {
2094       int sw = rapdu_status_to_sw (msg->cmd);
2095       log_error ("rapdu command GET_STATUS failed: %s\n",
2096                  rapdu_strerror (msg->cmd));
2097       rapdu_msg_release (msg);
2098       return sw;
2099     }
2100   *status = msg->data[0];
2101
2102   rapdu_msg_release (msg);
2103   return 0;
2104 }
2105
2106
2107 /* Actually send the APDU of length APDULEN to SLOT and return a
2108    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2109    set to BUFLEN.  Returns: APDU error code. */
2110 static int
2111 my_rapdu_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
2112                     unsigned char *buffer, size_t *buflen,
2113                     struct pininfo_s *pininfo)
2114 {
2115   int err;
2116   reader_table_t slotp;
2117   rapdu_msg_t msg = NULL;
2118   size_t maxlen = *buflen;
2119
2120   slotp = reader_table + slot;
2121
2122   *buflen = 0;
2123   if (DBG_CARD_IO)
2124     log_printhex ("  APDU_data:", apdu, apdulen);
2125
2126   if (apdulen < 4)
2127     {
2128       log_error ("rapdu_send_apdu: APDU is too short\n");
2129       return SW_HOST_INV_VALUE;
2130     }
2131
2132   err = rapdu_send_apdu (slotp->rapdu.handle, apdu, apdulen);
2133   if (err)
2134     {
2135       log_error ("sending rapdu command APDU failed: %s\n",
2136                 err < 0 ? strerror (errno): rapdu_strerror (err));
2137       rapdu_msg_release (msg);
2138       return rapdu_status_to_sw (err);
2139     }
2140   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2141   if (err)
2142     {
2143       log_error ("receiving rapdu message failed: %s\n",
2144                 err < 0 ? strerror (errno): rapdu_strerror (err));
2145       rapdu_msg_release (msg);
2146       return rapdu_status_to_sw (err);
2147     }
2148   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2149     {
2150       int sw = rapdu_status_to_sw (msg->cmd);
2151       log_error ("rapdu command APDU failed: %s\n",
2152                  rapdu_strerror (msg->cmd));
2153       rapdu_msg_release (msg);
2154       return sw;
2155     }
2156
2157   if (msg->datalen > maxlen)
2158     {
2159       log_error ("rapdu response apdu too large\n");
2160       rapdu_msg_release (msg);
2161       return SW_HOST_INV_VALUE;
2162     }
2163
2164   *buflen = msg->datalen;
2165   memcpy (buffer, msg->data, msg->datalen);
2166
2167   rapdu_msg_release (msg);
2168   return 0;
2169 }
2170
2171 static int
2172 open_rapdu_reader (int portno,
2173                    const unsigned char *cookie, size_t length,
2174                    int (*readfnc) (void *opaque,
2175                                    void *buffer, size_t size),
2176                    void *readfnc_value,
2177                    int (*writefnc) (void *opaque,
2178                                     const void *buffer, size_t size),
2179                    void *writefnc_value,
2180                    void (*closefnc) (void *opaque),
2181                    void *closefnc_value)
2182 {
2183   int err;
2184   int slot;
2185   reader_table_t slotp;
2186   rapdu_msg_t msg = NULL;
2187
2188   slot = new_reader_slot ();
2189   if (slot == -1)
2190     return -1;
2191   slotp = reader_table + slot;
2192
2193   slotp->rapdu.handle = rapdu_new ();
2194   if (!slotp->rapdu.handle)
2195     {
2196       slotp->used = 0;
2197       return -1;
2198     }
2199
2200   rapdu_set_reader (slotp->rapdu.handle, portno);
2201
2202   rapdu_set_iofunc (slotp->rapdu.handle,
2203                     readfnc, readfnc_value,
2204                     writefnc, writefnc_value,
2205                     closefnc, closefnc_value);
2206   rapdu_set_cookie (slotp->rapdu.handle, cookie, length);
2207
2208   /* First try to get the current ATR, but if the card is inactive
2209      issue a reset instead.  */
2210   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_ATR);
2211   if (err == RAPDU_STATUS_NEEDRESET)
2212     err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2213   if (err)
2214     {
2215       log_info ("sending rapdu command GET_ATR/RESET failed: %s\n",
2216                 err < 0 ? strerror (errno): rapdu_strerror (err));
2217       goto failure;
2218     }
2219   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2220   if (err)
2221     {
2222       log_info ("receiving rapdu message failed: %s\n",
2223                 err < 0 ? strerror (errno): rapdu_strerror (err));
2224       goto failure;
2225     }
2226   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2227     {
2228       log_info ("rapdu command GET ATR failed: %s\n",
2229                  rapdu_strerror (msg->cmd));
2230       goto failure;
2231     }
2232   if (msg->datalen > DIM (slotp->atr))
2233     {
2234       log_error ("ATR returned by the RAPDU layer is too large\n");
2235       goto failure;
2236     }
2237   slotp->atrlen = msg->datalen;
2238   memcpy (slotp->atr, msg->data, msg->datalen);
2239
2240   reader_table[slot].close_reader = close_rapdu_reader;
2241   reader_table[slot].reset_reader = reset_rapdu_reader;
2242   reader_table[slot].get_status_reader = my_rapdu_get_status;
2243   reader_table[slot].send_apdu_reader = my_rapdu_send_apdu;
2244   reader_table[slot].check_keypad = NULL;
2245   reader_table[slot].dump_status_reader = NULL;
2246
2247   dump_reader_status (slot);
2248   rapdu_msg_release (msg);
2249   return slot;
2250
2251  failure:
2252   rapdu_msg_release (msg);
2253   rapdu_release (slotp->rapdu.handle);
2254   slotp->used = 0;
2255   return -1;
2256 }
2257
2258 #endif /*USE_G10CODE_RAPDU*/
2259
2260
2261 \f
2262 /*
2263        Driver Access
2264  */
2265
2266
2267 static int
2268 lock_slot (int slot)
2269 {
2270 #ifdef USE_GNU_PTH
2271   if (!pth_mutex_acquire (&reader_table[slot].lock, 0, NULL))
2272     {
2273       log_error ("failed to acquire apdu lock: %s\n", strerror (errno));
2274       return SW_HOST_LOCKING_FAILED;
2275     }
2276 #endif /*USE_GNU_PTH*/
2277   return 0;
2278 }
2279
2280 static int
2281 trylock_slot (int slot)
2282 {
2283 #ifdef USE_GNU_PTH
2284   if (!pth_mutex_acquire (&reader_table[slot].lock, TRUE, NULL))
2285     {
2286       if (errno == EBUSY)
2287         return SW_HOST_BUSY;
2288       log_error ("failed to acquire apdu lock: %s\n", strerror (errno));
2289       return SW_HOST_LOCKING_FAILED;
2290     }
2291 #endif /*USE_GNU_PTH*/
2292   return 0;
2293 }
2294
2295 static void
2296 unlock_slot (int slot)
2297 {
2298 #ifdef USE_GNU_PTH
2299   if (!pth_mutex_release (&reader_table[slot].lock))
2300     log_error ("failed to release apdu lock: %s\n", strerror (errno));
2301 #endif /*USE_GNU_PTH*/
2302 }
2303
2304
2305 /* Open the reader and return an internal slot number or -1 on
2306    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
2307    the first USB reader.  For PC/SC the first listed reader). */
2308 int
2309 apdu_open_reader (const char *portstr)
2310 {
2311   static int pcsc_api_loaded, ct_api_loaded;
2312
2313 #ifdef HAVE_LIBUSB
2314   if (!opt.disable_ccid)
2315     {
2316       int slot, i;
2317       const char *s;
2318
2319       slot = open_ccid_reader (portstr);
2320       if (slot != -1)
2321         return slot; /* got one */
2322
2323       /* If a CCID reader specification has been given, the user does
2324          not want a fallback to other drivers. */
2325       if (portstr)
2326         for (s=portstr, i=0; *s; s++)
2327           if (*s == ':' && (++i == 3))
2328             return -1;
2329     }
2330
2331 #endif /* HAVE_LIBUSB */
2332
2333   if (opt.ctapi_driver && *opt.ctapi_driver)
2334     {
2335       int port = portstr? atoi (portstr) : 32768;
2336
2337       if (!ct_api_loaded)
2338         {
2339           void *handle;
2340
2341           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
2342           if (!handle)
2343             {
2344               log_error ("apdu_open_reader: failed to open driver: %s\n",
2345                          dlerror ());
2346               return -1;
2347             }
2348           CT_init = dlsym (handle, "CT_init");
2349           CT_data = dlsym (handle, "CT_data");
2350           CT_close = dlsym (handle, "CT_close");
2351           if (!CT_init || !CT_data || !CT_close)
2352             {
2353               log_error ("apdu_open_reader: invalid CT-API driver\n");
2354               dlclose (handle);
2355               return -1;
2356             }
2357           ct_api_loaded = 1;
2358         }
2359       return open_ct_reader (port);
2360     }
2361
2362
2363   /* No ctAPI configured, so lets try the PC/SC API */
2364   if (!pcsc_api_loaded)
2365     {
2366 #ifndef NEED_PCSC_WRAPPER
2367       void *handle;
2368
2369       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
2370       if (!handle)
2371         {
2372           log_error ("apdu_open_reader: failed to open driver `%s': %s\n",
2373                      opt.pcsc_driver, dlerror ());
2374           return -1;
2375         }
2376
2377       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
2378       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
2379       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
2380 #if defined(_WIN32) || defined(__CYGWIN__)
2381       if (!pcsc_list_readers)
2382         pcsc_list_readers    = dlsym (handle, "SCardListReadersA");
2383 #endif
2384       pcsc_get_status_change = dlsym (handle, "SCardGetStatusChange");
2385 #if defined(_WIN32) || defined(__CYGWIN__)
2386       if (!pcsc_get_status_change)
2387         pcsc_get_status_change = dlsym (handle, "SCardGetStatusChangeA");
2388 #endif
2389       pcsc_connect           = dlsym (handle, "SCardConnect");
2390 #if defined(_WIN32) || defined(__CYGWIN__)
2391       if (!pcsc_connect)
2392         pcsc_connect         = dlsym (handle, "SCardConnectA");
2393 #endif
2394       pcsc_reconnect         = dlsym (handle, "SCardReconnect");
2395 #if defined(_WIN32) || defined(__CYGWIN__)
2396       if (!pcsc_reconnect)
2397         pcsc_reconnect       = dlsym (handle, "SCardReconnectA");
2398 #endif
2399       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
2400       pcsc_status            = dlsym (handle, "SCardStatus");
2401 #if defined(_WIN32) || defined(__CYGWIN__)
2402       if (!pcsc_status)
2403         pcsc_status          = dlsym (handle, "SCardStatusA");
2404 #endif
2405       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
2406       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
2407       pcsc_transmit          = dlsym (handle, "SCardTransmit");
2408       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
2409
2410       if (!pcsc_establish_context
2411           || !pcsc_release_context
2412           || !pcsc_list_readers
2413           || !pcsc_get_status_change
2414           || !pcsc_connect
2415           || !pcsc_reconnect
2416           || !pcsc_disconnect
2417           || !pcsc_status
2418           || !pcsc_begin_transaction
2419           || !pcsc_end_transaction
2420           || !pcsc_transmit
2421           /* || !pcsc_set_timeout */)
2422         {
2423           /* Note that set_timeout is currently not used and also not
2424              available under Windows. */
2425           log_error ("apdu_open_reader: invalid PC/SC driver "
2426                      "(%d%d%d%d%d%d%d%d%d%d%d%d)\n",
2427                      !!pcsc_establish_context,
2428                      !!pcsc_release_context,
2429                      !!pcsc_list_readers,
2430                      !!pcsc_get_status_change,
2431                      !!pcsc_connect,
2432                      !!pcsc_reconnect,
2433                      !!pcsc_disconnect,
2434                      !!pcsc_status,
2435                      !!pcsc_begin_transaction,
2436                      !!pcsc_end_transaction,
2437                      !!pcsc_transmit,
2438                      !!pcsc_set_timeout );
2439           dlclose (handle);
2440           return -1;
2441         }
2442 #endif /*!NEED_PCSC_WRAPPER*/
2443       pcsc_api_loaded = 1;
2444     }
2445
2446   return open_pcsc_reader (portstr);
2447 }
2448
2449
2450 /* Open an remote reader and return an internal slot number or -1 on
2451    error. This function is an alternative to apdu_open_reader and used
2452    with remote readers only.  Note that the supplied CLOSEFNC will
2453    only be called once and the slot will not be valid afther this.
2454
2455    If PORTSTR is NULL we default to the first availabe port.
2456 */
2457 int
2458 apdu_open_remote_reader (const char *portstr,
2459                          const unsigned char *cookie, size_t length,
2460                          int (*readfnc) (void *opaque,
2461                                          void *buffer, size_t size),
2462                          void *readfnc_value,
2463                          int (*writefnc) (void *opaque,
2464                                           const void *buffer, size_t size),
2465                          void *writefnc_value,
2466                          void (*closefnc) (void *opaque),
2467                          void *closefnc_value)
2468 {
2469 #ifdef USE_G10CODE_RAPDU
2470   return open_rapdu_reader (portstr? atoi (portstr) : 0,
2471                             cookie, length,
2472                             readfnc, readfnc_value,
2473                             writefnc, writefnc_value,
2474                             closefnc, closefnc_value);
2475 #else
2476   (void)portstr;
2477   (void)cookie;
2478   (void)length;
2479   (void)readfnc;
2480   (void)readfnc_value;
2481   (void)writefnc;
2482   (void)writefnc_value;
2483   (void)closefnc;
2484   (void)closefnc_value;
2485 #ifdef _WIN32
2486   errno = ENOENT;
2487 #else
2488   errno = ENOSYS;
2489 #endif
2490   return -1;
2491 #endif
2492 }
2493
2494
2495 int
2496 apdu_close_reader (int slot)
2497 {
2498   int sw;
2499
2500   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2501     return SW_HOST_NO_DRIVER;
2502   sw = apdu_disconnect (slot);
2503   if (sw)
2504     return sw;
2505   if (reader_table[slot].close_reader)
2506     return reader_table[slot].close_reader (slot);
2507   return SW_HOST_NOT_SUPPORTED;
2508 }
2509
2510 /* Shutdown a reader; that is basically the same as a close but keeps
2511    the handle ready for later use. A apdu_reset_reader or apdu_connect
2512    should be used to get it active again. */
2513 int
2514 apdu_shutdown_reader (int slot)
2515 {
2516   int sw;
2517
2518   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2519     return SW_HOST_NO_DRIVER;
2520   sw = apdu_disconnect (slot);
2521   if (sw)
2522     return sw;
2523   if (reader_table[slot].shutdown_reader)
2524     return reader_table[slot].shutdown_reader (slot);
2525   return SW_HOST_NOT_SUPPORTED;
2526 }
2527
2528 /* Enumerate all readers and return information on whether this reader
2529    is in use.  The caller should start with SLOT set to 0 and
2530    increment it with each call until an error is returned. */
2531 int
2532 apdu_enum_reader (int slot, int *used)
2533 {
2534   if (slot < 0 || slot >= MAX_READER)
2535     return SW_HOST_NO_DRIVER;
2536   *used = reader_table[slot].used;
2537   return 0;
2538 }
2539
2540
2541 /* Connect a card.  This is used to power up the card and make sure
2542    that an ATR is available.  */
2543 int
2544 apdu_connect (int slot)
2545 {
2546   int sw;
2547
2548   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2549     return SW_HOST_NO_DRIVER;
2550
2551   /* Only if the access method provides a connect function we use it.
2552      If not, we expect that the card has been implicitly connected by
2553      apdu_open_reader.  */
2554   if (reader_table[slot].connect_card)
2555     {
2556       sw = lock_slot (slot);
2557       if (!sw)
2558         {
2559           sw = reader_table[slot].connect_card (slot);
2560           unlock_slot (slot);
2561         }
2562     }
2563   else
2564     sw = 0;
2565   
2566   /* We need to call apdu_get_status_internal, so that the last-status
2567      machinery gets setup properly even if a card is inserted while
2568      scdaemon is fired up and apdu_get_status has not yet been called.
2569      Without that we would force a reset of the card with the next
2570      call to apdu_get_status.  */
2571   apdu_get_status_internal (slot, 1, 1, NULL, NULL);
2572
2573   return sw;
2574 }
2575
2576
2577 int
2578 apdu_disconnect (int slot)
2579 {
2580   int sw;
2581
2582   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2583     return SW_HOST_NO_DRIVER;
2584
2585   if (reader_table[slot].disconnect_card)
2586     {
2587       sw = lock_slot (slot);
2588       if (!sw)
2589         {
2590           sw = reader_table[slot].disconnect_card (slot);
2591           unlock_slot (slot);
2592         }
2593     }
2594   else
2595     sw = 0;
2596   return sw;
2597 }
2598
2599
2600
2601 /* Do a reset for the card in reader at SLOT. */
2602 int
2603 apdu_reset (int slot)
2604 {
2605   int sw;
2606
2607   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2608     return SW_HOST_NO_DRIVER;
2609
2610   if ((sw = lock_slot (slot)))
2611     return sw;
2612
2613   reader_table[slot].last_status = 0;
2614   if (reader_table[slot].reset_reader)
2615     sw = reader_table[slot].reset_reader (slot);
2616
2617   if (!sw)
2618     {
2619       /* If we got to here we know that a card is present
2620          and usable.  Thus remember this.  */
2621       reader_table[slot].last_status = (APDU_CARD_USABLE
2622                                         | APDU_CARD_PRESENT
2623                                         | APDU_CARD_ACTIVE);
2624     }
2625
2626   unlock_slot (slot);
2627   return sw;
2628 }
2629
2630
2631 /* Activate a card if it has not yet been done.  This is a kind of
2632    reset-if-required.  It is useful to test for presence of a card
2633    before issuing a bunch of apdu commands.  It does not wait on a
2634    locked card. */
2635 int
2636 apdu_activate (int slot)
2637 {
2638   int sw;
2639   unsigned int s;
2640
2641   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2642     return SW_HOST_NO_DRIVER;
2643
2644   if ((sw = trylock_slot (slot)))
2645     return sw;
2646
2647   if (reader_table[slot].get_status_reader)
2648     sw = reader_table[slot].get_status_reader (slot, &s);
2649
2650   if (!sw)
2651     {
2652       if (!(s & 2))  /* Card not present.  */
2653         sw = SW_HOST_NO_CARD;
2654       else if ( ((s & 2) && !(s & 4))
2655                 || !reader_table[slot].atrlen )
2656         {
2657           /* We don't have an ATR or a card is present though inactive:
2658              do a reset now. */
2659           if (reader_table[slot].reset_reader)
2660             {
2661               reader_table[slot].last_status = 0;
2662               sw = reader_table[slot].reset_reader (slot);
2663               if (!sw)
2664                 {
2665                   /* If we got to here we know that a card is present
2666                      and usable.  Thus remember this.  */
2667                   reader_table[slot].last_status = (APDU_CARD_USABLE
2668                                                     | APDU_CARD_PRESENT
2669                                                     | APDU_CARD_ACTIVE);
2670                 }
2671             }
2672         }
2673     }
2674
2675   unlock_slot (slot);
2676   return sw;
2677 }
2678
2679
2680
2681 unsigned char *
2682 apdu_get_atr (int slot, size_t *atrlen)
2683 {
2684   unsigned char *buf;
2685
2686   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2687     return NULL;
2688   if (!reader_table[slot].atrlen)
2689     return NULL;
2690   buf = xtrymalloc (reader_table[slot].atrlen);
2691   if (!buf)
2692     return NULL;
2693   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
2694   *atrlen = reader_table[slot].atrlen;
2695   return buf;
2696 }
2697
2698
2699
2700 /* Retrieve the status for SLOT. The function does only wait for the
2701    card to become available if HANG is set to true. On success the
2702    bits in STATUS will be set to
2703
2704      APDU_CARD_USABLE  (bit 0) = card present and usable
2705      APDU_CARD_PRESENT (bit 1) = card present
2706      APDU_CARD_ACTIVE  (bit 2) = card active
2707                        (bit 3) = card access locked [not yet implemented]
2708
2709    For must applications, testing bit 0 is sufficient.
2710
2711    CHANGED will receive the value of the counter tracking the number
2712    of card insertions.  This value may be used to detect a card
2713    change.
2714 */
2715 static int
2716 apdu_get_status_internal (int slot, int hang, int no_atr_reset,
2717                           unsigned int *status, unsigned int *changed)
2718 {
2719   int sw;
2720   unsigned int s;
2721
2722   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2723     return SW_HOST_NO_DRIVER;
2724
2725   if ((sw = hang? lock_slot (slot) : trylock_slot (slot)))
2726     return sw;
2727
2728   if (reader_table[slot].get_status_reader)
2729     sw = reader_table[slot].get_status_reader (slot, &s);
2730
2731   unlock_slot (slot);
2732
2733   if (sw)
2734     {
2735       reader_table[slot].last_status = 0;
2736       return sw;
2737     }
2738
2739   /* Keep track of changes.  */
2740   if (s != reader_table[slot].last_status
2741       || !reader_table[slot].any_status )
2742     {
2743       reader_table[slot].change_counter++;
2744       /* Make sure that the ATR is invalid so that a reset will be
2745          triggered by apdu_activate.  */
2746       if (!no_atr_reset)
2747         reader_table[slot].atrlen = 0;
2748     }
2749   reader_table[slot].any_status = 1;
2750   reader_table[slot].last_status = s;
2751
2752   if (status)
2753     *status = s;
2754   if (changed)
2755     *changed = reader_table[slot].change_counter;
2756   return 0;
2757 }
2758
2759
2760 /* See above for a description.  */
2761 int
2762 apdu_get_status (int slot, int hang,
2763                  unsigned int *status, unsigned int *changed)
2764 {
2765   return apdu_get_status_internal (slot, hang, 0, status, changed);
2766 }
2767
2768
2769 /* Check whether the reader supports the ISO command code COMMAND on
2770    the keypad.  Return 0 on success.  For a description of the pin
2771    parameters, see ccid-driver.c */
2772 int
2773 apdu_check_keypad (int slot, int command, int pin_mode,
2774                    int pinlen_min, int pinlen_max, int pin_padlen)
2775 {
2776   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2777     return SW_HOST_NO_DRIVER;
2778
2779   if (reader_table[slot].check_keypad)
2780     return reader_table[slot].check_keypad (slot, command,
2781                                             pin_mode, pinlen_min, pinlen_max,
2782                                             pin_padlen);
2783   else
2784     return SW_HOST_NOT_SUPPORTED;
2785 }
2786
2787
2788 /* Dispatcher for the actual send_apdu function. Note, that this
2789    function should be called in locked state. */
2790 static int
2791 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
2792            unsigned char *buffer, size_t *buflen, struct pininfo_s *pininfo)
2793 {
2794   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2795     return SW_HOST_NO_DRIVER;
2796
2797   if (reader_table[slot].send_apdu_reader)
2798     return reader_table[slot].send_apdu_reader (slot,
2799                                                 apdu, apdulen,
2800                                                 buffer, buflen, 
2801                                                 pininfo);
2802   else
2803     return SW_HOST_NOT_SUPPORTED;
2804 }
2805
2806
2807 /* Core APDU tranceiver function. Parameters are described at
2808    apdu_send_le with the exception of PININFO which indicates keypad
2809    related operations if not NULL.  If EXTENDED_MODE is not NULL
2810    command chaining or extended length will be used according to these
2811    values:
2812        n < 0 := Use command chaining with the data part limited to -n
2813                 in each chunk.  If -1 is used a default value is used.
2814       n == 1 := Use extended length for input and output without a
2815                 length limit.
2816        n > 1 := Use extended length with up to N bytes.
2817 */
2818 static int
2819 send_le (int slot, int class, int ins, int p0, int p1,
2820          int lc, const char *data, int le,
2821          unsigned char **retbuf, size_t *retbuflen,
2822          struct pininfo_s *pininfo, int extended_mode)
2823 {
2824 #define RESULTLEN 258
2825   unsigned char result[RESULTLEN+10]; /* 10 extra in case of bugs in
2826                                          the driver. */
2827   size_t resultlen;
2828   unsigned char apdu[5+256+1];
2829   size_t apdulen;
2830   int sw;
2831   long rc; /* We need a long here due to PC/SC. */
2832   int did_exact_length_hack = 0;
2833   int use_chaining = 0;
2834   int lc_chunk;
2835
2836   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2837     return SW_HOST_NO_DRIVER;
2838
2839   if (DBG_CARD_IO)
2840     log_debug ("send apdu: c=%02X i=%02X p0=%02X p1=%02X lc=%d le=%d em=%d\n",
2841                class, ins, p0, p1, lc, le, extended_mode);
2842
2843   if (lc != -1 && (lc > 255 || lc < 0))
2844     {
2845       /* Data does not fit into an APDU.  What we do now depends on
2846          the EXTENDED_MODE parameter.  */
2847       if (!extended_mode)
2848         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
2849       else if (extended_mode > 0)
2850         return SW_HOST_NOT_SUPPORTED; /* FIXME.  */
2851       else if (extended_mode < 0)
2852         {
2853           /* Send APDU using chaining mode.  */
2854           if (lc > 16384)
2855             return SW_WRONG_LENGTH;   /* Sanity check.  */
2856           if ((class&0xf0) != 0)
2857             return SW_HOST_INV_VALUE; /* Upper 4 bits need to be 0.  */ 
2858           use_chaining = extended_mode == -1? 255 : -extended_mode;  
2859           use_chaining &= 0xff;
2860         }
2861       else 
2862         return SW_HOST_INV_VALUE;
2863     }
2864   if (le != -1 && (le > 256 || le < 0))
2865     return SW_WRONG_LENGTH;
2866   if ((!data && lc != -1) || (data && lc == -1))
2867     return SW_HOST_INV_VALUE;
2868
2869   if ((sw = lock_slot (slot)))
2870     return sw;
2871
2872   do
2873     {
2874       apdulen = 0;
2875       apdu[apdulen] = class;
2876       if (use_chaining && lc > 255)
2877         {
2878           apdu[apdulen] |= 0x10;
2879           assert (use_chaining < 256);
2880           lc_chunk = use_chaining;
2881           lc -= use_chaining;
2882         }
2883       else
2884         {
2885           use_chaining = 0;
2886           lc_chunk = lc;
2887         }
2888       apdulen++;
2889       apdu[apdulen++] = ins;
2890       apdu[apdulen++] = p0;
2891       apdu[apdulen++] = p1;
2892       if (lc_chunk != -1)
2893         {
2894           apdu[apdulen++] = lc_chunk;
2895           memcpy (apdu+apdulen, data, lc_chunk);
2896           data += lc_chunk;
2897           apdulen += lc_chunk;
2898           /* T=0 does not allow the use of Lc together with Le; thus
2899              disable Le in this case.  */
2900           if (reader_table[slot].is_t0)
2901             le = -1;
2902         }
2903       if (le != -1)
2904         apdu[apdulen++] = le; /* Truncation is okay because 0 means 256. */
2905       /* As safeguard don't pass any garbage from the stack to the driver. */
2906       assert (sizeof (apdu) >= apdulen);
2907       memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
2908     exact_length_hack:
2909       resultlen = RESULTLEN;
2910       rc = send_apdu (slot, apdu, apdulen, result, &resultlen, pininfo);
2911       if (rc || resultlen < 2)
2912         {
2913           log_error ("apdu_send_simple(%d) failed: %s\n",
2914                      slot, apdu_strerror (rc));
2915           unlock_slot (slot);
2916           return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2917         }
2918       sw = (result[resultlen-2] << 8) | result[resultlen-1];
2919       if (!did_exact_length_hack && SW_EXACT_LENGTH_P (sw))
2920         {
2921           apdu[apdulen-1] = (sw & 0x00ff);
2922           did_exact_length_hack = 1;
2923           goto exact_length_hack;
2924         }
2925     }
2926   while (use_chaining && sw == SW_SUCCESS);
2927
2928   /* Store away the returned data but strip the statusword. */
2929   resultlen -= 2;
2930   if (DBG_CARD_IO)
2931     {
2932       log_debug (" response: sw=%04X  datalen=%d\n",
2933                  sw, (unsigned int)resultlen);
2934       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
2935         log_printhex ("     dump: ", result, resultlen);
2936     }
2937
2938   if (sw == SW_SUCCESS || sw == SW_EOF_REACHED)
2939     {
2940       if (retbuf)
2941         {
2942           *retbuf = xtrymalloc (resultlen? resultlen : 1);
2943           if (!*retbuf)
2944             {
2945               unlock_slot (slot);
2946               return SW_HOST_OUT_OF_CORE;
2947             }
2948           *retbuflen = resultlen;
2949           memcpy (*retbuf, result, resultlen);
2950         }
2951     }
2952   else if ((sw & 0xff00) == SW_MORE_DATA)
2953     {
2954       unsigned char *p = NULL, *tmp;
2955       size_t bufsize = 4096;
2956
2957       /* It is likely that we need to return much more data, so we
2958          start off with a large buffer. */
2959       if (retbuf)
2960         {
2961           *retbuf = p = xtrymalloc (bufsize);
2962           if (!*retbuf)
2963             {
2964               unlock_slot (slot);
2965               return SW_HOST_OUT_OF_CORE;
2966             }
2967           assert (resultlen < bufsize);
2968           memcpy (p, result, resultlen);
2969           p += resultlen;
2970         }
2971
2972       do
2973         {
2974           int len = (sw & 0x00ff);
2975
2976           if (DBG_CARD_IO)
2977             log_debug ("apdu_send_simple(%d): %d more bytes available\n",
2978                        slot, len);
2979           apdulen = 0;
2980           apdu[apdulen++] = class;
2981           apdu[apdulen++] = 0xC0;
2982           apdu[apdulen++] = 0;
2983           apdu[apdulen++] = 0;
2984           apdu[apdulen++] = len;
2985           memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
2986           resultlen = RESULTLEN;
2987           rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
2988           if (rc || resultlen < 2)
2989             {
2990               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
2991                          slot, apdu_strerror (rc));
2992               unlock_slot (slot);
2993               return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2994             }
2995           sw = (result[resultlen-2] << 8) | result[resultlen-1];
2996           resultlen -= 2;
2997           if (DBG_CARD_IO)
2998             {
2999               log_debug ("     more: sw=%04X  datalen=%d\n",
3000                          sw, (unsigned int)resultlen);
3001               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
3002                 log_printhex ("     dump: ", result, resultlen);
3003             }
3004
3005           if ((sw & 0xff00) == SW_MORE_DATA
3006               || sw == SW_SUCCESS
3007               || sw == SW_EOF_REACHED )
3008             {
3009               if (retbuf && resultlen)
3010                 {
3011                   if (p - *retbuf + resultlen > bufsize)
3012                     {
3013                       bufsize += resultlen > 4096? resultlen: 4096;
3014                       tmp = xtryrealloc (*retbuf, bufsize);
3015                       if (!tmp)
3016                         {
3017                           unlock_slot (slot);
3018                           return SW_HOST_OUT_OF_CORE;
3019                         }
3020                       p = tmp + (p - *retbuf);
3021                       *retbuf = tmp;
3022                     }
3023                   memcpy (p, result, resultlen);
3024                   p += resultlen;
3025                 }
3026             }
3027           else
3028             log_info ("apdu_send_simple(%d) "
3029                       "got unexpected status %04X from get response\n",
3030                       slot, sw);
3031         }
3032       while ((sw & 0xff00) == SW_MORE_DATA);
3033
3034       if (retbuf)
3035         {
3036           *retbuflen = p - *retbuf;
3037           tmp = xtryrealloc (*retbuf, *retbuflen);
3038           if (tmp)
3039             *retbuf = tmp;
3040         }
3041     }
3042
3043   unlock_slot (slot);
3044
3045   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
3046     log_printhex ("      dump: ", *retbuf, *retbuflen);
3047
3048   return sw;
3049 #undef RESULTLEN
3050 }
3051
3052 /* Send an APDU to the card in SLOT.  The APDU is created from all
3053    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
3054    for LC won't sent this field and the data field; in this case DATA
3055    must also be passed as NULL.  The return value is the status word
3056    or -1 for an invalid SLOT or other non card related error.  If
3057    RETBUF is not NULL, it will receive an allocated buffer with the
3058    returned data.  The length of that data will be put into
3059    *RETBUFLEN.  The caller is reponsible for releasing the buffer even
3060    in case of errors.  */
3061 int
3062 apdu_send_le(int slot, int class, int ins, int p0, int p1,
3063              int lc, const char *data, int le,
3064              unsigned char **retbuf, size_t *retbuflen)
3065 {
3066   return send_le (slot, class, ins, p0, p1,
3067                   lc, data, le,
3068                   retbuf, retbuflen,
3069                   NULL, 0);
3070 }
3071
3072
3073 /* Send an APDU to the card in SLOT.  The APDU is created from all
3074    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
3075    LC won't sent this field and the data field; in this case DATA must
3076    also be passed as NULL. The return value is the status word or -1
3077    for an invalid SLOT or other non card related error.  If RETBUF is
3078    not NULL, it will receive an allocated buffer with the returned
3079    data.  The length of that data will be put into *RETBUFLEN.  The
3080    caller is reponsible for releasing the buffer even in case of
3081    errors.  */
3082 int
3083 apdu_send (int slot, int class, int ins, int p0, int p1,
3084            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
3085 {
3086   return send_le (slot, class, ins, p0, p1, lc, data, 256,
3087                   retbuf, retbuflen, NULL, 0);
3088 }
3089
3090 /* Send an APDU to the card in SLOT.  The APDU is created from all
3091    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
3092    LC won't sent this field and the data field; in this case DATA must
3093    also be passed as NULL. The return value is the status word or -1
3094    for an invalid SLOT or other non card related error.  No data will be
3095    returned. */
3096 int
3097 apdu_send_simple (int slot, int extended_mode,
3098                   int class, int ins, int p0, int p1,
3099                   int lc, const char *data)
3100 {
3101   return send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL, NULL, 
3102                   extended_mode);
3103 }
3104
3105
3106 /* Same as apdu_send_simple but uses the keypad of the reader. */
3107 int
3108 apdu_send_simple_kp (int slot, int class, int ins, int p0, int p1,
3109                      int lc, const char *data,  
3110                      int pin_mode,
3111                      int pinlen_min, int pinlen_max, int pin_padlen)
3112 {
3113   struct pininfo_s pininfo;
3114
3115   pininfo.mode = pin_mode;
3116   pininfo.minlen = pinlen_min;
3117   pininfo.maxlen = pinlen_max;
3118   pininfo.padlen = pin_padlen;
3119   return send_le (slot, class, ins, p0, p1, lc, data, -1,
3120                   NULL, NULL, &pininfo, 0);
3121 }
3122
3123
3124 /* This is a more generic version of the apdu sending routine.  It
3125    takes an already formatted APDU in APDUDATA or length APDUDATALEN
3126    and returns with an APDU including the status word.  With
3127    HANDLE_MORE set to true this function will handle the MORE DATA
3128    status and return all APDUs concatenated with one status word at
3129    the end.  The function does not return a regular status word but 0
3130    on success.  If the slot is locked, the function returns
3131    immediately with an error.  */
3132 int
3133 apdu_send_direct (int slot, const unsigned char *apdudata, size_t apdudatalen,
3134                   int handle_more,
3135                   unsigned char **retbuf, size_t *retbuflen)
3136 {
3137 #define RESULTLEN 258
3138   unsigned char apdu[5+256+1];
3139   size_t apdulen;
3140   unsigned char result[RESULTLEN+10]; /* 10 extra in case of bugs in
3141                                          the driver. */
3142   size_t resultlen;
3143   int sw;
3144   long rc; /* we need a long here due to PC/SC. */
3145   int class;
3146
3147   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3148     return SW_HOST_NO_DRIVER;
3149
3150   if ((sw = trylock_slot (slot)))
3151     return sw;
3152
3153   /* We simply trunctate a too long APDU.  */
3154   if (apdudatalen > sizeof apdu)
3155     apdudatalen = sizeof apdu;
3156   apdulen = apdudatalen;
3157   memcpy (apdu, apdudata, apdudatalen);
3158   class = apdulen? *apdu : 0;
3159
3160   resultlen = RESULTLEN;
3161   rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
3162   if (rc || resultlen < 2)
3163     {
3164       log_error ("apdu_send_direct(%d) failed: %s\n",
3165                  slot, apdu_strerror (rc));
3166       unlock_slot (slot);
3167       return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
3168     }
3169   sw = (result[resultlen-2] << 8) | result[resultlen-1];
3170   /* Store away the returned data but strip the statusword. */
3171   resultlen -= 2;
3172   if (DBG_CARD_IO)
3173     {
3174       log_debug (" response: sw=%04X  datalen=%d\n",
3175                  sw, (unsigned int)resultlen);
3176       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
3177         log_printhex ("     dump: ", result, resultlen);
3178     }
3179
3180   if (handle_more && (sw & 0xff00) == SW_MORE_DATA)
3181     {
3182       unsigned char *p = NULL, *tmp;
3183       size_t bufsize = 4096;
3184
3185       /* It is likely that we need to return much more data, so we
3186          start off with a large buffer. */
3187       if (retbuf)
3188         {
3189           *retbuf = p = xtrymalloc (bufsize + 2);
3190           if (!*retbuf)
3191             {
3192               unlock_slot (slot);
3193               return SW_HOST_OUT_OF_CORE;
3194             }
3195           assert (resultlen < bufsize);
3196           memcpy (p, result, resultlen);
3197           p += resultlen;
3198         }
3199
3200       do
3201         {
3202           int len = (sw & 0x00ff);
3203
3204           if (DBG_CARD_IO)
3205             log_debug ("apdu_send_direct(%d): %d more bytes available\n",
3206                        slot, len);
3207           apdulen = 0;
3208           apdu[apdulen++] = class;
3209           apdu[apdulen++] = 0xC0;
3210           apdu[apdulen++] = 0;
3211           apdu[apdulen++] = 0;
3212           apdu[apdulen++] = len;
3213           memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
3214           resultlen = RESULTLEN;
3215           rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
3216           if (rc || resultlen < 2)
3217             {
3218               log_error ("apdu_send_direct(%d) for get response failed: %s\n",
3219                          slot, apdu_strerror (rc));
3220               unlock_slot (slot);
3221               return rc ? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
3222             }
3223           sw = (result[resultlen-2] << 8) | result[resultlen-1];
3224           resultlen -= 2;
3225           if (DBG_CARD_IO)
3226             {
3227               log_debug ("     more: sw=%04X  datalen=%d\n",
3228                          sw, (unsigned int)resultlen);
3229               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
3230                 log_printhex ("     dump: ", result, resultlen);
3231             }
3232
3233           if ((sw & 0xff00) == SW_MORE_DATA
3234               || sw == SW_SUCCESS
3235               || sw == SW_EOF_REACHED )
3236             {
3237               if (retbuf && resultlen)
3238                 {
3239                   if (p - *retbuf + resultlen > bufsize)
3240                     {
3241                       bufsize += resultlen > 4096? resultlen: 4096;
3242                       tmp = xtryrealloc (*retbuf, bufsize + 2);
3243                       if (!tmp)
3244                         {
3245                           unlock_slot (slot);
3246                           return SW_HOST_OUT_OF_CORE;
3247                         }
3248                       p = tmp + (p - *retbuf);
3249                       *retbuf = tmp;
3250                     }
3251                   memcpy (p, result, resultlen);
3252                   p += resultlen;
3253                 }
3254             }
3255           else
3256             log_info ("apdu_send_direct(%d) "
3257                       "got unexpected status %04X from get response\n",
3258                       slot, sw);
3259         }
3260       while ((sw & 0xff00) == SW_MORE_DATA);
3261
3262       if (retbuf)
3263         {
3264           *retbuflen = p - *retbuf;
3265           tmp = xtryrealloc (*retbuf, *retbuflen + 2);
3266           if (tmp)
3267             *retbuf = tmp;
3268         }
3269     }
3270   else
3271     {
3272       if (retbuf)
3273         {
3274           *retbuf = xtrymalloc ((resultlen? resultlen : 1)+2);
3275           if (!*retbuf)
3276             {
3277               unlock_slot (slot);
3278               return SW_HOST_OUT_OF_CORE;
3279             }
3280           *retbuflen = resultlen;
3281           memcpy (*retbuf, result, resultlen);
3282         }
3283     }
3284
3285   unlock_slot (slot);
3286
3287   /* Append the status word.  Note that we reserved the two extra
3288      bytes while allocating the buffer.  */
3289   if (retbuf)
3290     {
3291       (*retbuf)[(*retbuflen)++] = (sw >> 8);
3292       (*retbuf)[(*retbuflen)++] = sw;
3293     }
3294
3295   if (DBG_CARD_IO && retbuf)
3296     log_printhex ("      dump: ", *retbuf, *retbuflen);
3297
3298   return 0;
3299 #undef RESULTLEN
3300 }