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