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