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