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