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