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