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