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