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