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