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