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