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