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