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