570e1501a72e753d177aac548551a12a6f537a80
[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 && product == 0x003e) /* Cherry ST-2xxx */
1859     {
1860       reader_table[slot].pcsc.pinmax = 15;
1861       reader_table[slot].pinpad_varlen_supported = 1;
1862     }
1863   else if (vendor == 0x0c4b /* Tested with Reiner cyberJack GO */
1864            || vendor == 0x1a44 /* Tested with Vasco DIGIPASS 920 */
1865            || vendor == 0x234b /* Tested with FSIJ Gnuk Token */
1866            || vendor == 0x0d46 /* Tested with KAAN Advanced??? */)
1867     reader_table[slot].pinpad_varlen_supported = 1;
1868
1869   return 0;
1870 }
1871
1872
1873 /* Open the PC/SC reader without using the wrapper.  Returns -1 on
1874    error or a slot number for the reader.  */
1875 #ifndef NEED_PCSC_WRAPPER
1876 static int
1877 open_pcsc_reader_direct (const char *portstr)
1878 {
1879   long err;
1880   int slot;
1881   char *list = NULL;
1882   char *rdrname = NULL;
1883   pcsc_dword_t nreader;
1884   char *p;
1885
1886   slot = new_reader_slot ();
1887   if (slot == -1)
1888     return -1;
1889
1890   /* Fixme: Allocating a context for each slot is not required.  One
1891      global context should be sufficient.  */
1892   err = pcsc_establish_context (PCSC_SCOPE_SYSTEM, NULL, NULL,
1893                                 &reader_table[slot].pcsc.context);
1894   if (err)
1895     {
1896       log_error ("pcsc_establish_context failed: %s (0x%lx)\n",
1897                  pcsc_error_string (err), err);
1898       reader_table[slot].used = 0;
1899       unlock_slot (slot);
1900       return -1;
1901     }
1902
1903   err = pcsc_list_readers (reader_table[slot].pcsc.context,
1904                            NULL, NULL, &nreader);
1905   if (!err)
1906     {
1907       list = xtrymalloc (nreader+1); /* Better add 1 for safety reasons. */
1908       if (!list)
1909         {
1910           log_error ("error allocating memory for reader list\n");
1911           pcsc_release_context (reader_table[slot].pcsc.context);
1912           reader_table[slot].used = 0;
1913           unlock_slot (slot);
1914           return -1 /*SW_HOST_OUT_OF_CORE*/;
1915         }
1916       err = pcsc_list_readers (reader_table[slot].pcsc.context,
1917                                NULL, list, &nreader);
1918     }
1919   if (err)
1920     {
1921       log_error ("pcsc_list_readers failed: %s (0x%lx)\n",
1922                  pcsc_error_string (err), err);
1923       pcsc_release_context (reader_table[slot].pcsc.context);
1924       reader_table[slot].used = 0;
1925       xfree (list);
1926       unlock_slot (slot);
1927       return -1;
1928     }
1929
1930   p = list;
1931   while (nreader)
1932     {
1933       if (!*p && !p[1])
1934         break;
1935       log_info ("detected reader `%s'\n", p);
1936       if (nreader < (strlen (p)+1))
1937         {
1938           log_error ("invalid response from pcsc_list_readers\n");
1939           break;
1940         }
1941       if (!rdrname && portstr && !strncmp (p, portstr, strlen (portstr)))
1942         rdrname = p;
1943       nreader -= strlen (p)+1;
1944       p += strlen (p) + 1;
1945     }
1946
1947   if (!rdrname)
1948     rdrname = list;
1949
1950   reader_table[slot].rdrname = xtrystrdup (rdrname);
1951   if (!reader_table[slot].rdrname)
1952     {
1953       log_error ("error allocating memory for reader name\n");
1954       pcsc_release_context (reader_table[slot].pcsc.context);
1955       reader_table[slot].used = 0;
1956       unlock_slot (slot);
1957       return -1;
1958     }
1959   xfree (list);
1960   list = NULL;
1961
1962   reader_table[slot].pcsc.card = 0;
1963   reader_table[slot].atrlen = 0;
1964   reader_table[slot].last_status = 0;
1965
1966   reader_table[slot].connect_card = connect_pcsc_card;
1967   reader_table[slot].disconnect_card = disconnect_pcsc_card;
1968   reader_table[slot].close_reader = close_pcsc_reader;
1969   reader_table[slot].reset_reader = reset_pcsc_reader;
1970   reader_table[slot].get_status_reader = pcsc_get_status;
1971   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
1972   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
1973
1974   dump_reader_status (slot);
1975   unlock_slot (slot);
1976   return slot;
1977 }
1978 #endif /*!NEED_PCSC_WRAPPER */
1979
1980
1981 /* Open the PC/SC reader using the pcsc_wrapper program.  This is
1982    needed to cope with different thread models and other peculiarities
1983    of libpcsclite. */
1984 #ifdef NEED_PCSC_WRAPPER
1985 static int
1986 open_pcsc_reader_wrapped (const char *portstr)
1987 {
1988   int slot;
1989   reader_table_t slotp;
1990   int fd, rp[2], wp[2];
1991   int n, i;
1992   pid_t pid;
1993   size_t len;
1994   unsigned char msgbuf[9];
1995   int err;
1996   unsigned int dummy_status;
1997   /*int sw = SW_HOST_CARD_IO_ERROR;*/
1998
1999   /* Note that we use the constant and not the fucntion because this
2000      code won't be be used under Windows.  */
2001   const char *wrapperpgm = GNUPG_LIBEXECDIR "/gnupg-pcsc-wrapper";
2002
2003   if (access (wrapperpgm, X_OK))
2004     {
2005       log_error ("can't run PC/SC access module `%s': %s\n",
2006                  wrapperpgm, strerror (errno));
2007       return -1;
2008     }
2009
2010   slot = new_reader_slot ();
2011   if (slot == -1)
2012     return -1;
2013   slotp = reader_table + slot;
2014
2015   /* Fire up the PC/SCc wrapper.  We don't use any fork/exec code from
2016      the common directy but implement it directly so that this file
2017      may still be source copied. */
2018
2019   if (pipe (rp) == -1)
2020     {
2021       log_error ("error creating a pipe: %s\n", strerror (errno));
2022       slotp->used = 0;
2023       unlock_slot (slot);
2024       return -1;
2025     }
2026   if (pipe (wp) == -1)
2027     {
2028       log_error ("error creating a pipe: %s\n", strerror (errno));
2029       close (rp[0]);
2030       close (rp[1]);
2031       slotp->used = 0;
2032       unlock_slot (slot);
2033       return -1;
2034     }
2035
2036   pid = fork ();
2037   if (pid == -1)
2038     {
2039       log_error ("error forking process: %s\n", strerror (errno));
2040       close (rp[0]);
2041       close (rp[1]);
2042       close (wp[0]);
2043       close (wp[1]);
2044       slotp->used = 0;
2045       unlock_slot (slot);
2046       return -1;
2047     }
2048   slotp->pcsc.pid = pid;
2049
2050   if (!pid)
2051     { /*
2052          === Child ===
2053        */
2054
2055       /* Double fork. */
2056       pid = fork ();
2057       if (pid == -1)
2058         _exit (31);
2059       if (pid)
2060         _exit (0); /* Immediate exit this parent, so that the child
2061                       gets cleaned up by the init process. */
2062
2063       /* Connect our pipes. */
2064       if (wp[0] != 0 && dup2 (wp[0], 0) == -1)
2065         log_fatal ("dup2 stdin failed: %s\n", strerror (errno));
2066       if (rp[1] != 1 && dup2 (rp[1], 1) == -1)
2067         log_fatal ("dup2 stdout failed: %s\n", strerror (errno));
2068
2069       /* Send stderr to the bit bucket. */
2070       fd = open ("/dev/null", O_WRONLY);
2071       if (fd == -1)
2072         log_fatal ("can't open `/dev/null': %s", strerror (errno));
2073       if (fd != 2 && dup2 (fd, 2) == -1)
2074         log_fatal ("dup2 stderr failed: %s\n", strerror (errno));
2075
2076       /* Close all other files. */
2077       close_all_fds (3, NULL);
2078
2079       execl (wrapperpgm,
2080              "pcsc-wrapper",
2081              "--",
2082              "1", /* API version */
2083              opt.pcsc_driver, /* Name of the PC/SC library. */
2084               NULL);
2085       _exit (31);
2086     }
2087
2088   /*
2089      === Parent ===
2090    */
2091   close (wp[0]);
2092   close (rp[1]);
2093   slotp->pcsc.req_fd = wp[1];
2094   slotp->pcsc.rsp_fd = rp[0];
2095
2096   /* Wait for the intermediate child to terminate. */
2097 #ifdef USE_GNU_PTH
2098 #define WAIT pth_waitpid
2099 #else
2100 #define WAIT waitpid
2101 #endif
2102   while ( (i=WAIT (pid, NULL, 0)) == -1 && errno == EINTR)
2103     ;
2104 #undef WAIT
2105
2106   /* Now send the open request. */
2107   msgbuf[0] = 0x01; /* OPEN command. */
2108   len = portstr? strlen (portstr):0;
2109   msgbuf[1] = (len >> 24);
2110   msgbuf[2] = (len >> 16);
2111   msgbuf[3] = (len >>  8);
2112   msgbuf[4] = (len      );
2113   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
2114        || (portstr && writen (slotp->pcsc.req_fd, portstr, len)))
2115     {
2116       log_error ("error sending PC/SC OPEN request: %s\n",
2117                  strerror (errno));
2118       goto command_failed;
2119     }
2120   /* Read the response. */
2121   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
2122     {
2123       log_error ("error receiving PC/SC OPEN response: %s\n",
2124                  i? strerror (errno) : "premature EOF");
2125       goto command_failed;
2126     }
2127   len = buf32_to_size_t (msgbuf+1);
2128   if (msgbuf[0] != 0x81 || len < 4)
2129     {
2130       log_error ("invalid response header from PC/SC received\n");
2131       goto command_failed;
2132     }
2133   len -= 4; /* Already read the error code. */
2134   if (len > DIM (slotp->atr))
2135     {
2136       log_error ("PC/SC returned a too large ATR (len=%lx)\n",
2137                  (unsigned long)len);
2138       goto command_failed;
2139     }
2140   err = PCSC_ERR_MASK (buf32_to_ulong (msgbuf+5));
2141
2142   if (err)
2143     {
2144       log_error ("PC/SC OPEN failed: %s (0x%08x)\n",
2145                  pcsc_error_string (err), err);
2146       /*sw = pcsc_error_to_sw (err);*/
2147       goto command_failed;
2148     }
2149
2150   slotp->last_status = 0;
2151
2152   /* The open request may return a zero for the ATR length to
2153      indicate that no card is present.  */
2154   n = len;
2155   if (n)
2156     {
2157       if ((i=readn (slotp->pcsc.rsp_fd, slotp->atr, n, &len)) || len != n)
2158         {
2159           log_error ("error receiving PC/SC OPEN response: %s\n",
2160                      i? strerror (errno) : "premature EOF");
2161           goto command_failed;
2162         }
2163       /* If we got to here we know that a card is present
2164          and usable.  Thus remember this.  */
2165       slotp->last_status = (  APDU_CARD_USABLE
2166                             | APDU_CARD_PRESENT
2167                             | APDU_CARD_ACTIVE);
2168     }
2169   slotp->atrlen = len;
2170
2171   reader_table[slot].close_reader = close_pcsc_reader;
2172   reader_table[slot].reset_reader = reset_pcsc_reader;
2173   reader_table[slot].get_status_reader = pcsc_get_status;
2174   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
2175   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
2176
2177   pcsc_vendor_specific_init (slot);
2178
2179   /* Read the status so that IS_T0 will be set. */
2180   pcsc_get_status (slot, &dummy_status);
2181
2182   dump_reader_status (slot);
2183   unlock_slot (slot);
2184   return slot;
2185
2186  command_failed:
2187   close (slotp->pcsc.req_fd);
2188   close (slotp->pcsc.rsp_fd);
2189   slotp->pcsc.req_fd = -1;
2190   slotp->pcsc.rsp_fd = -1;
2191   kill (slotp->pcsc.pid, SIGTERM);
2192   slotp->pcsc.pid = (pid_t)(-1);
2193   slotp->used = 0;
2194   unlock_slot (slot);
2195   /* There is no way to return SW. */
2196   return -1;
2197
2198 }
2199 #endif /*NEED_PCSC_WRAPPER*/
2200
2201
2202 static int
2203 open_pcsc_reader (const char *portstr)
2204 {
2205 #ifdef NEED_PCSC_WRAPPER
2206   return open_pcsc_reader_wrapped (portstr);
2207 #else
2208   return open_pcsc_reader_direct (portstr);
2209 #endif
2210 }
2211
2212
2213 /* Check whether the reader supports the ISO command code COMMAND
2214    on the pinpad.  Return 0 on success.  */
2215 static int
2216 check_pcsc_pinpad (int slot, int command, pininfo_t *pininfo)
2217 {
2218   int r;
2219
2220   if (reader_table[slot].pcsc.pinmin >= 0)
2221     pininfo->minlen = reader_table[slot].pcsc.pinmin;
2222
2223   if (reader_table[slot].pcsc.pinmax >= 0)
2224     pininfo->maxlen = reader_table[slot].pcsc.pinmax;
2225
2226   if (!pininfo->minlen)
2227     pininfo->minlen = 1;
2228   if (!pininfo->maxlen)
2229     pininfo->maxlen = 15;
2230
2231   if ((command == ISO7816_VERIFY && reader_table[slot].pcsc.verify_ioctl != 0)
2232       || (command == ISO7816_CHANGE_REFERENCE_DATA
2233           && reader_table[slot].pcsc.modify_ioctl != 0))
2234     r = 0;                       /* Success */
2235   else
2236     r = SW_NOT_SUPPORTED;
2237
2238   if (DBG_CARD_IO)
2239     log_debug ("check_pcsc_pinpad: command=%02X, r=%d\n",
2240                (unsigned int)command, r);
2241
2242   if (reader_table[slot].pinpad_varlen_supported)
2243     pininfo->fixedlen = 0;
2244
2245   return r;
2246 }
2247
2248 #define PIN_VERIFY_STRUCTURE_SIZE 24
2249 static int
2250 pcsc_pinpad_verify (int slot, int class, int ins, int p0, int p1,
2251                     pininfo_t *pininfo)
2252 {
2253   int sw;
2254   unsigned char *pin_verify;
2255   int len = PIN_VERIFY_STRUCTURE_SIZE + pininfo->fixedlen;
2256   /*
2257    * The result buffer is only expected to have two-byte result on
2258    * return.  However, some implementation uses this buffer for lower
2259    * layer too and it assumes that there is enough space for lower
2260    * layer communication.  Such an implementation fails for TPDU
2261    * readers with "insufficient buffer", as it needs header and
2262    * trailer.  Six is the number for header + result + trailer (TPDU).
2263    */
2264   unsigned char result[6];
2265   pcsc_dword_t resultlen = 6;
2266   int no_lc;
2267
2268   if (!reader_table[slot].atrlen
2269       && (sw = reset_pcsc_reader (slot)))
2270     return sw;
2271
2272   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2273     return SW_NOT_SUPPORTED;
2274
2275   pin_verify = xtrymalloc (len);
2276   if (!pin_verify)
2277     return SW_HOST_OUT_OF_CORE;
2278
2279   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2280
2281   pin_verify[0] = 0x00; /* bTimeOut */
2282   pin_verify[1] = 0x00; /* bTimeOut2 */
2283   pin_verify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2284   pin_verify[3] = pininfo->fixedlen; /* bmPINBlockString */
2285   pin_verify[4] = 0x00; /* bmPINLengthFormat */
2286   pin_verify[5] = pininfo->maxlen; /* wPINMaxExtraDigit */
2287   pin_verify[6] = pininfo->minlen; /* wPINMaxExtraDigit */
2288   pin_verify[7] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2289   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2290     pin_verify[7] |= 0x01; /* Max size reached.  */
2291   pin_verify[8] = 0x01; /* bNumberMessage: One message */
2292   pin_verify[9] =  0x09; /* wLangId: 0x0409: US English */
2293   pin_verify[10] = 0x04; /* wLangId: 0x0409: US English */
2294   pin_verify[11] = 0x00; /* bMsgIndex */
2295   pin_verify[12] = 0x00; /* bTeoPrologue[0] */
2296   pin_verify[13] = 0x00; /* bTeoPrologue[1] */
2297   pin_verify[14] = pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2298   pin_verify[15] = pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2299   pin_verify[16] = 0x00; /* ulDataLength */
2300   pin_verify[17] = 0x00; /* ulDataLength */
2301   pin_verify[18] = 0x00; /* ulDataLength */
2302   pin_verify[19] = class; /* abData[0] */
2303   pin_verify[20] = ins; /* abData[1] */
2304   pin_verify[21] = p0; /* abData[2] */
2305   pin_verify[22] = p1; /* abData[3] */
2306   pin_verify[23] = pininfo->fixedlen; /* abData[4] */
2307   if (pininfo->fixedlen)
2308     memset (&pin_verify[24], 0xff, pininfo->fixedlen);
2309   else if (no_lc)
2310     len--;
2311
2312   if (DBG_CARD_IO)
2313     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2314                class, ins, p0, p1, len, pininfo->maxlen);
2315
2316   sw = control_pcsc (slot, reader_table[slot].pcsc.verify_ioctl,
2317                      pin_verify, len, result, &resultlen);
2318   xfree (pin_verify);
2319   if (sw || resultlen < 2)
2320     {
2321       log_error ("control_pcsc failed: %d\n", sw);
2322       return sw? sw: SW_HOST_INCOMPLETE_CARD_RESPONSE;
2323     }
2324   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2325   if (DBG_CARD_IO)
2326     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2327   return sw;
2328 }
2329
2330
2331 #define PIN_MODIFY_STRUCTURE_SIZE 29
2332 static int
2333 pcsc_pinpad_modify (int slot, int class, int ins, int p0, int p1,
2334                     pininfo_t *pininfo)
2335 {
2336   int sw;
2337   unsigned char *pin_modify;
2338   int len = PIN_MODIFY_STRUCTURE_SIZE + 2 * pininfo->fixedlen;
2339   unsigned char result[6];      /* See the comment at pinpad_verify.  */
2340   pcsc_dword_t resultlen = 6;
2341   int no_lc;
2342
2343   if (!reader_table[slot].atrlen
2344       && (sw = reset_pcsc_reader (slot)))
2345     return sw;
2346
2347   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
2348     return SW_NOT_SUPPORTED;
2349
2350   pin_modify = xtrymalloc (len);
2351   if (!pin_modify)
2352     return SW_HOST_OUT_OF_CORE;
2353
2354   no_lc = (!pininfo->fixedlen && reader_table[slot].is_spr532);
2355
2356   pin_modify[0] = 0x00; /* bTimeOut */
2357   pin_modify[1] = 0x00; /* bTimeOut2 */
2358   pin_modify[2] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2359   pin_modify[3] = pininfo->fixedlen; /* bmPINBlockString */
2360   pin_modify[4] = 0x00; /* bmPINLengthFormat */
2361   pin_modify[5] = 0x00; /* bInsertionOffsetOld */
2362   pin_modify[6] = pininfo->fixedlen; /* bInsertionOffsetNew */
2363   pin_modify[7] = pininfo->maxlen; /* wPINMaxExtraDigit */
2364   pin_modify[8] = pininfo->minlen; /* wPINMaxExtraDigit */
2365   pin_modify[9] = (p0 == 0 ? 0x03 : 0x01);
2366                   /* bConfirmPIN
2367                    *    0x00: new PIN once
2368                    *    0x01: new PIN twice (confirmation)
2369                    *    0x02: old PIN and new PIN once
2370                    *    0x03: old PIN and new PIN twice (confirmation)
2371                    */
2372   pin_modify[10] = 0x02; /* bEntryValidationCondition: Validation key pressed */
2373   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
2374     pin_modify[10] |= 0x01; /* Max size reached.  */
2375   pin_modify[11] = 0x03; /* bNumberMessage: Three messages */
2376   pin_modify[12] = 0x09; /* wLangId: 0x0409: US English */
2377   pin_modify[13] = 0x04; /* wLangId: 0x0409: US English */
2378   pin_modify[14] = 0x00; /* bMsgIndex1 */
2379   pin_modify[15] = 0x01; /* bMsgIndex2 */
2380   pin_modify[16] = 0x02; /* bMsgIndex3 */
2381   pin_modify[17] = 0x00; /* bTeoPrologue[0] */
2382   pin_modify[18] = 0x00; /* bTeoPrologue[1] */
2383   pin_modify[19] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* bTeoPrologue[2] */
2384   pin_modify[20] = 2 * pininfo->fixedlen + 0x05 - no_lc; /* ulDataLength */
2385   pin_modify[21] = 0x00; /* ulDataLength */
2386   pin_modify[22] = 0x00; /* ulDataLength */
2387   pin_modify[23] = 0x00; /* ulDataLength */
2388   pin_modify[24] = class; /* abData[0] */
2389   pin_modify[25] = ins; /* abData[1] */
2390   pin_modify[26] = p0; /* abData[2] */
2391   pin_modify[27] = p1; /* abData[3] */
2392   pin_modify[28] = 2 * pininfo->fixedlen; /* abData[4] */
2393   if (pininfo->fixedlen)
2394     memset (&pin_modify[29], 0xff, 2 * pininfo->fixedlen);
2395   else if (no_lc)
2396     len--;
2397
2398   if (DBG_CARD_IO)
2399     log_debug ("send secure: c=%02X i=%02X p1=%02X p2=%02X len=%d pinmax=%d\n",
2400                class, ins, p0, p1, len, (int)pininfo->maxlen);
2401
2402   sw = control_pcsc (slot, reader_table[slot].pcsc.modify_ioctl,
2403                      pin_modify, len, result, &resultlen);
2404   xfree (pin_modify);
2405   if (sw || resultlen < 2)
2406     {
2407       log_error ("control_pcsc failed: %d\n", sw);
2408       return sw? sw : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2409     }
2410   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2411   if (DBG_CARD_IO)
2412     log_debug (" response: sw=%04X  datalen=%d\n", sw, (unsigned int)resultlen);
2413   return sw;
2414 }
2415 \f
2416 #ifdef HAVE_LIBUSB
2417 /*
2418      Internal CCID driver interface.
2419  */
2420
2421
2422 static void
2423 dump_ccid_reader_status (int slot)
2424 {
2425   log_info ("reader slot %d: using ccid driver\n", slot);
2426 }
2427
2428 static int
2429 close_ccid_reader (int slot)
2430 {
2431   ccid_close_reader (reader_table[slot].ccid.handle);
2432   reader_table[slot].used = 0;
2433   return 0;
2434 }
2435
2436
2437 static int
2438 reset_ccid_reader (int slot)
2439 {
2440   int err;
2441   reader_table_t slotp = reader_table + slot;
2442   unsigned char atr[33];
2443   size_t atrlen;
2444
2445   err = ccid_get_atr (slotp->ccid.handle, atr, sizeof atr, &atrlen);
2446   if (err)
2447     return err;
2448   /* If the reset was successful, update the ATR. */
2449   assert (sizeof slotp->atr >= sizeof atr);
2450   slotp->atrlen = atrlen;
2451   memcpy (slotp->atr, atr, atrlen);
2452   dump_reader_status (slot);
2453   return 0;
2454 }
2455
2456
2457 static int
2458 set_progress_cb_ccid_reader (int slot, gcry_handler_progress_t cb, void *cb_arg)
2459 {
2460   reader_table_t slotp = reader_table + slot;
2461
2462   return ccid_set_progress_cb (slotp->ccid.handle, cb, cb_arg);
2463 }
2464
2465
2466 static int
2467 get_status_ccid (int slot, unsigned int *status)
2468 {
2469   int rc;
2470   int bits;
2471
2472   rc = ccid_slot_status (reader_table[slot].ccid.handle, &bits);
2473   if (rc)
2474     return rc;
2475
2476   if (bits == 0)
2477     *status = (APDU_CARD_USABLE|APDU_CARD_PRESENT|APDU_CARD_ACTIVE);
2478   else if (bits == 1)
2479     *status = APDU_CARD_PRESENT;
2480   else
2481     *status = 0;
2482
2483   return 0;
2484 }
2485
2486
2487 /* Actually send the APDU of length APDULEN to SLOT and return a
2488    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2489    set to BUFLEN.  Returns: Internal CCID driver error code. */
2490 static int
2491 send_apdu_ccid (int slot, unsigned char *apdu, size_t apdulen,
2492                 unsigned char *buffer, size_t *buflen,
2493                 pininfo_t *pininfo)
2494 {
2495   long err;
2496   size_t maxbuflen;
2497
2498   /* If we don't have an ATR, we need to reset the reader first. */
2499   if (!reader_table[slot].atrlen
2500       && (err = reset_ccid_reader (slot)))
2501     return err;
2502
2503   if (DBG_CARD_IO)
2504     log_printhex (" raw apdu:", apdu, apdulen);
2505
2506   maxbuflen = *buflen;
2507   if (pininfo)
2508     err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2509                                   apdu, apdulen, pininfo,
2510                                   buffer, maxbuflen, buflen);
2511   else
2512     err = ccid_transceive (reader_table[slot].ccid.handle,
2513                            apdu, apdulen,
2514                            buffer, maxbuflen, buflen);
2515   if (err)
2516     log_error ("ccid_transceive failed: (0x%lx)\n",
2517                err);
2518
2519   return err;
2520 }
2521
2522
2523 /* Check whether the CCID reader supports the ISO command code COMMAND
2524    on the pinpad.  Return 0 on success.  For a description of the pin
2525    parameters, see ccid-driver.c */
2526 static int
2527 check_ccid_pinpad (int slot, int command, pininfo_t *pininfo)
2528 {
2529   unsigned char apdu[] = { 0, 0, 0, 0x81 };
2530
2531   apdu[1] = command;
2532   return ccid_transceive_secure (reader_table[slot].ccid.handle, apdu,
2533                                  sizeof apdu, pininfo, NULL, 0, NULL);
2534 }
2535
2536
2537 static int
2538 ccid_pinpad_operation (int slot, int class, int ins, int p0, int p1,
2539                        pininfo_t *pininfo)
2540 {
2541   unsigned char apdu[4];
2542   int err, sw;
2543   unsigned char result[2];
2544   size_t resultlen = 2;
2545
2546   apdu[0] = class;
2547   apdu[1] = ins;
2548   apdu[2] = p0;
2549   apdu[3] = p1;
2550   err = ccid_transceive_secure (reader_table[slot].ccid.handle,
2551                                 apdu, sizeof apdu, pininfo,
2552                                 result, 2, &resultlen);
2553   if (err)
2554     return err;
2555
2556   if (resultlen < 2)
2557     return SW_HOST_INCOMPLETE_CARD_RESPONSE;
2558
2559   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2560   return sw;
2561 }
2562
2563
2564 /* Open the reader and try to read an ATR.  */
2565 static int
2566 open_ccid_reader (const char *portstr)
2567 {
2568   int err;
2569   int slot;
2570   reader_table_t slotp;
2571
2572   slot = new_reader_slot ();
2573   if (slot == -1)
2574     return -1;
2575   slotp = reader_table + slot;
2576
2577   err = ccid_open_reader (&slotp->ccid.handle, portstr);
2578   if (err)
2579     {
2580       slotp->used = 0;
2581       unlock_slot (slot);
2582       return -1;
2583     }
2584
2585   err = ccid_get_atr (slotp->ccid.handle,
2586                       slotp->atr, sizeof slotp->atr, &slotp->atrlen);
2587   if (err)
2588     {
2589       slotp->atrlen = 0;
2590       err = 0;
2591     }
2592   else
2593     {
2594       /* If we got to here we know that a card is present
2595          and usable.  Thus remember this.  */
2596       reader_table[slot].last_status = (APDU_CARD_USABLE
2597                                         | APDU_CARD_PRESENT
2598                                         | APDU_CARD_ACTIVE);
2599     }
2600
2601   reader_table[slot].close_reader = close_ccid_reader;
2602   reader_table[slot].reset_reader = reset_ccid_reader;
2603   reader_table[slot].get_status_reader = get_status_ccid;
2604   reader_table[slot].send_apdu_reader = send_apdu_ccid;
2605   reader_table[slot].check_pinpad = check_ccid_pinpad;
2606   reader_table[slot].dump_status_reader = dump_ccid_reader_status;
2607   reader_table[slot].set_progress_cb = set_progress_cb_ccid_reader;
2608   reader_table[slot].pinpad_verify = ccid_pinpad_operation;
2609   reader_table[slot].pinpad_modify = ccid_pinpad_operation;
2610   /* Our CCID reader code does not support T=0 at all, thus reset the
2611      flag.  */
2612   reader_table[slot].is_t0 = 0;
2613
2614   dump_reader_status (slot);
2615   unlock_slot (slot);
2616   return slot;
2617 }
2618
2619
2620
2621 #endif /* HAVE_LIBUSB */
2622
2623
2624 \f
2625 #ifdef USE_G10CODE_RAPDU
2626 /*
2627      The Remote APDU Interface.
2628
2629      This uses the Remote APDU protocol to contact a reader.
2630
2631      The port number is actually an index into the list of ports as
2632      returned via the protocol.
2633  */
2634
2635
2636 static int
2637 rapdu_status_to_sw (int status)
2638 {
2639   int rc;
2640
2641   switch (status)
2642     {
2643     case RAPDU_STATUS_SUCCESS:  rc = 0; break;
2644
2645     case RAPDU_STATUS_INVCMD:
2646     case RAPDU_STATUS_INVPROT:
2647     case RAPDU_STATUS_INVSEQ:
2648     case RAPDU_STATUS_INVCOOKIE:
2649     case RAPDU_STATUS_INVREADER:  rc = SW_HOST_INV_VALUE;  break;
2650
2651     case RAPDU_STATUS_TIMEOUT:  rc = SW_HOST_CARD_IO_ERROR; break;
2652     case RAPDU_STATUS_CARDIO:   rc = SW_HOST_CARD_IO_ERROR; break;
2653     case RAPDU_STATUS_NOCARD:   rc = SW_HOST_NO_CARD; break;
2654     case RAPDU_STATUS_CARDCHG:  rc = SW_HOST_NO_CARD; break;
2655     case RAPDU_STATUS_BUSY:     rc = SW_HOST_BUSY; break;
2656     case RAPDU_STATUS_NEEDRESET: rc = SW_HOST_CARD_INACTIVE; break;
2657
2658     default: rc = SW_HOST_GENERAL_ERROR; break;
2659     }
2660
2661   return rc;
2662 }
2663
2664
2665
2666 static int
2667 close_rapdu_reader (int slot)
2668 {
2669   rapdu_release (reader_table[slot].rapdu.handle);
2670   reader_table[slot].used = 0;
2671   return 0;
2672 }
2673
2674
2675 static int
2676 reset_rapdu_reader (int slot)
2677 {
2678   int err;
2679   reader_table_t slotp;
2680   rapdu_msg_t msg = NULL;
2681
2682   slotp = reader_table + slot;
2683
2684   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2685   if (err)
2686     {
2687       log_error ("sending rapdu command RESET failed: %s\n",
2688                 err < 0 ? strerror (errno): rapdu_strerror (err));
2689       rapdu_msg_release (msg);
2690       return rapdu_status_to_sw (err);
2691     }
2692   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2693   if (err)
2694     {
2695       log_error ("receiving rapdu message failed: %s\n",
2696                 err < 0 ? strerror (errno): rapdu_strerror (err));
2697       rapdu_msg_release (msg);
2698       return rapdu_status_to_sw (err);
2699     }
2700   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2701     {
2702       int sw = rapdu_status_to_sw (msg->cmd);
2703       log_error ("rapdu command RESET failed: %s\n",
2704                  rapdu_strerror (msg->cmd));
2705       rapdu_msg_release (msg);
2706       return sw;
2707     }
2708   if (msg->datalen > DIM (slotp->atr))
2709     {
2710       log_error ("ATR returned by the RAPDU layer is too large\n");
2711       rapdu_msg_release (msg);
2712       return SW_HOST_INV_VALUE;
2713     }
2714   slotp->atrlen = msg->datalen;
2715   memcpy (slotp->atr, msg->data, msg->datalen);
2716
2717   rapdu_msg_release (msg);
2718   return 0;
2719 }
2720
2721
2722 static int
2723 my_rapdu_get_status (int slot, unsigned int *status)
2724 {
2725   int err;
2726   reader_table_t slotp;
2727   rapdu_msg_t msg = NULL;
2728   int oldslot;
2729
2730   slotp = reader_table + slot;
2731
2732   oldslot = rapdu_set_reader (slotp->rapdu.handle, slot);
2733   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_STATUS);
2734   rapdu_set_reader (slotp->rapdu.handle, oldslot);
2735   if (err)
2736     {
2737       log_error ("sending rapdu command GET_STATUS failed: %s\n",
2738                 err < 0 ? strerror (errno): rapdu_strerror (err));
2739       return rapdu_status_to_sw (err);
2740     }
2741   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2742   if (err)
2743     {
2744       log_error ("receiving rapdu message failed: %s\n",
2745                 err < 0 ? strerror (errno): rapdu_strerror (err));
2746       rapdu_msg_release (msg);
2747       return rapdu_status_to_sw (err);
2748     }
2749   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2750     {
2751       int sw = rapdu_status_to_sw (msg->cmd);
2752       log_error ("rapdu command GET_STATUS failed: %s\n",
2753                  rapdu_strerror (msg->cmd));
2754       rapdu_msg_release (msg);
2755       return sw;
2756     }
2757   *status = msg->data[0];
2758
2759   rapdu_msg_release (msg);
2760   return 0;
2761 }
2762
2763
2764 /* Actually send the APDU of length APDULEN to SLOT and return a
2765    maximum of *BUFLEN data in BUFFER, the actual returned size will be
2766    set to BUFLEN.  Returns: APDU error code. */
2767 static int
2768 my_rapdu_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
2769                     unsigned char *buffer, size_t *buflen,
2770                     pininfo_t *pininfo)
2771 {
2772   int err;
2773   reader_table_t slotp;
2774   rapdu_msg_t msg = NULL;
2775   size_t maxlen = *buflen;
2776
2777   slotp = reader_table + slot;
2778
2779   *buflen = 0;
2780   if (DBG_CARD_IO)
2781     log_printhex ("  APDU_data:", apdu, apdulen);
2782
2783   if (apdulen < 4)
2784     {
2785       log_error ("rapdu_send_apdu: APDU is too short\n");
2786       return SW_HOST_INV_VALUE;
2787     }
2788
2789   err = rapdu_send_apdu (slotp->rapdu.handle, apdu, apdulen);
2790   if (err)
2791     {
2792       log_error ("sending rapdu command APDU failed: %s\n",
2793                 err < 0 ? strerror (errno): rapdu_strerror (err));
2794       rapdu_msg_release (msg);
2795       return rapdu_status_to_sw (err);
2796     }
2797   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2798   if (err)
2799     {
2800       log_error ("receiving rapdu message failed: %s\n",
2801                 err < 0 ? strerror (errno): rapdu_strerror (err));
2802       rapdu_msg_release (msg);
2803       return rapdu_status_to_sw (err);
2804     }
2805   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2806     {
2807       int sw = rapdu_status_to_sw (msg->cmd);
2808       log_error ("rapdu command APDU failed: %s\n",
2809                  rapdu_strerror (msg->cmd));
2810       rapdu_msg_release (msg);
2811       return sw;
2812     }
2813
2814   if (msg->datalen > maxlen)
2815     {
2816       log_error ("rapdu response apdu too large\n");
2817       rapdu_msg_release (msg);
2818       return SW_HOST_INV_VALUE;
2819     }
2820
2821   *buflen = msg->datalen;
2822   memcpy (buffer, msg->data, msg->datalen);
2823
2824   rapdu_msg_release (msg);
2825   return 0;
2826 }
2827
2828 static int
2829 open_rapdu_reader (int portno,
2830                    const unsigned char *cookie, size_t length,
2831                    int (*readfnc) (void *opaque,
2832                                    void *buffer, size_t size),
2833                    void *readfnc_value,
2834                    int (*writefnc) (void *opaque,
2835                                     const void *buffer, size_t size),
2836                    void *writefnc_value,
2837                    void (*closefnc) (void *opaque),
2838                    void *closefnc_value)
2839 {
2840   int err;
2841   int slot;
2842   reader_table_t slotp;
2843   rapdu_msg_t msg = NULL;
2844
2845   slot = new_reader_slot ();
2846   if (slot == -1)
2847     return -1;
2848   slotp = reader_table + slot;
2849
2850   slotp->rapdu.handle = rapdu_new ();
2851   if (!slotp->rapdu.handle)
2852     {
2853       slotp->used = 0;
2854       unlock_slot (slot);
2855       return -1;
2856     }
2857
2858   rapdu_set_reader (slotp->rapdu.handle, portno);
2859
2860   rapdu_set_iofunc (slotp->rapdu.handle,
2861                     readfnc, readfnc_value,
2862                     writefnc, writefnc_value,
2863                     closefnc, closefnc_value);
2864   rapdu_set_cookie (slotp->rapdu.handle, cookie, length);
2865
2866   /* First try to get the current ATR, but if the card is inactive
2867      issue a reset instead.  */
2868   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_ATR);
2869   if (err == RAPDU_STATUS_NEEDRESET)
2870     err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
2871   if (err)
2872     {
2873       log_info ("sending rapdu command GET_ATR/RESET failed: %s\n",
2874                 err < 0 ? strerror (errno): rapdu_strerror (err));
2875       goto failure;
2876     }
2877   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
2878   if (err)
2879     {
2880       log_info ("receiving rapdu message failed: %s\n",
2881                 err < 0 ? strerror (errno): rapdu_strerror (err));
2882       goto failure;
2883     }
2884   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
2885     {
2886       log_info ("rapdu command GET ATR failed: %s\n",
2887                  rapdu_strerror (msg->cmd));
2888       goto failure;
2889     }
2890   if (msg->datalen > DIM (slotp->atr))
2891     {
2892       log_error ("ATR returned by the RAPDU layer is too large\n");
2893       goto failure;
2894     }
2895   slotp->atrlen = msg->datalen;
2896   memcpy (slotp->atr, msg->data, msg->datalen);
2897
2898   reader_table[slot].close_reader = close_rapdu_reader;
2899   reader_table[slot].reset_reader = reset_rapdu_reader;
2900   reader_table[slot].get_status_reader = my_rapdu_get_status;
2901   reader_table[slot].send_apdu_reader = my_rapdu_send_apdu;
2902   reader_table[slot].check_pinpad = NULL;
2903   reader_table[slot].dump_status_reader = NULL;
2904   reader_table[slot].pinpad_verify = NULL;
2905   reader_table[slot].pinpad_modify = NULL;
2906
2907   dump_reader_status (slot);
2908   rapdu_msg_release (msg);
2909   unlock_slot (slot);
2910   return slot;
2911
2912  failure:
2913   rapdu_msg_release (msg);
2914   rapdu_release (slotp->rapdu.handle);
2915   slotp->used = 0;
2916   unlock_slot (slot);
2917   return -1;
2918 }
2919
2920 #endif /*USE_G10CODE_RAPDU*/
2921
2922
2923 \f
2924 /*
2925        Driver Access
2926  */
2927
2928
2929 /* Open the reader and return an internal slot number or -1 on
2930    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
2931    the first USB reader.  For PC/SC the first listed reader). */
2932 int
2933 apdu_open_reader (const char *portstr)
2934 {
2935   static int pcsc_api_loaded, ct_api_loaded;
2936
2937 #ifdef HAVE_LIBUSB
2938   if (!opt.disable_ccid)
2939     {
2940       int slot, i;
2941       const char *s;
2942
2943       slot = open_ccid_reader (portstr);
2944       if (slot != -1)
2945         return slot; /* got one */
2946
2947       /* If a CCID reader specification has been given, the user does
2948          not want a fallback to other drivers. */
2949       if (portstr)
2950         for (s=portstr, i=0; *s; s++)
2951           if (*s == ':' && (++i == 3))
2952             return -1;
2953     }
2954
2955 #endif /* HAVE_LIBUSB */
2956
2957   if (opt.ctapi_driver && *opt.ctapi_driver)
2958     {
2959       int port = portstr? atoi (portstr) : 32768;
2960
2961       if (!ct_api_loaded)
2962         {
2963           void *handle;
2964
2965           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
2966           if (!handle)
2967             {
2968               log_error ("apdu_open_reader: failed to open driver: %s\n",
2969                          dlerror ());
2970               return -1;
2971             }
2972           CT_init = dlsym (handle, "CT_init");
2973           CT_data = dlsym (handle, "CT_data");
2974           CT_close = dlsym (handle, "CT_close");
2975           if (!CT_init || !CT_data || !CT_close)
2976             {
2977               log_error ("apdu_open_reader: invalid CT-API driver\n");
2978               dlclose (handle);
2979               return -1;
2980             }
2981           ct_api_loaded = 1;
2982         }
2983       return open_ct_reader (port);
2984     }
2985
2986
2987   /* No ctAPI configured, so lets try the PC/SC API */
2988   if (!pcsc_api_loaded)
2989     {
2990 #ifndef NEED_PCSC_WRAPPER
2991       void *handle;
2992
2993       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
2994       if (!handle)
2995         {
2996           log_error ("apdu_open_reader: failed to open driver `%s': %s\n",
2997                      opt.pcsc_driver, dlerror ());
2998           return -1;
2999         }
3000
3001       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
3002       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
3003       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
3004 #if defined(_WIN32) || defined(__CYGWIN__)
3005       if (!pcsc_list_readers)
3006         pcsc_list_readers    = dlsym (handle, "SCardListReadersA");
3007 #endif
3008       pcsc_get_status_change = dlsym (handle, "SCardGetStatusChange");
3009 #if defined(_WIN32) || defined(__CYGWIN__)
3010       if (!pcsc_get_status_change)
3011         pcsc_get_status_change = dlsym (handle, "SCardGetStatusChangeA");
3012 #endif
3013       pcsc_connect           = dlsym (handle, "SCardConnect");
3014 #if defined(_WIN32) || defined(__CYGWIN__)
3015       if (!pcsc_connect)
3016         pcsc_connect         = dlsym (handle, "SCardConnectA");
3017 #endif
3018       pcsc_reconnect         = dlsym (handle, "SCardReconnect");
3019 #if defined(_WIN32) || defined(__CYGWIN__)
3020       if (!pcsc_reconnect)
3021         pcsc_reconnect       = dlsym (handle, "SCardReconnectA");
3022 #endif
3023       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
3024       pcsc_status            = dlsym (handle, "SCardStatus");
3025 #if defined(_WIN32) || defined(__CYGWIN__)
3026       if (!pcsc_status)
3027         pcsc_status          = dlsym (handle, "SCardStatusA");
3028 #endif
3029       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
3030       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
3031       pcsc_transmit          = dlsym (handle, "SCardTransmit");
3032       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
3033       pcsc_control           = dlsym (handle, "SCardControl");
3034
3035       if (!pcsc_establish_context
3036           || !pcsc_release_context
3037           || !pcsc_list_readers
3038           || !pcsc_get_status_change
3039           || !pcsc_connect
3040           || !pcsc_reconnect
3041           || !pcsc_disconnect
3042           || !pcsc_status
3043           || !pcsc_begin_transaction
3044           || !pcsc_end_transaction
3045           || !pcsc_transmit
3046           || !pcsc_control
3047           /* || !pcsc_set_timeout */)
3048         {
3049           /* Note that set_timeout is currently not used and also not
3050              available under Windows. */
3051           log_error ("apdu_open_reader: invalid PC/SC driver "
3052                      "(%d%d%d%d%d%d%d%d%d%d%d%d%d)\n",
3053                      !!pcsc_establish_context,
3054                      !!pcsc_release_context,
3055                      !!pcsc_list_readers,
3056                      !!pcsc_get_status_change,
3057                      !!pcsc_connect,
3058                      !!pcsc_reconnect,
3059                      !!pcsc_disconnect,
3060                      !!pcsc_status,
3061                      !!pcsc_begin_transaction,
3062                      !!pcsc_end_transaction,
3063                      !!pcsc_transmit,
3064                      !!pcsc_set_timeout,
3065                      !!pcsc_control );
3066           dlclose (handle);
3067           return -1;
3068         }
3069 #endif /*!NEED_PCSC_WRAPPER*/
3070       pcsc_api_loaded = 1;
3071     }
3072
3073   return open_pcsc_reader (portstr);
3074 }
3075
3076
3077 /* Open an remote reader and return an internal slot number or -1 on
3078    error. This function is an alternative to apdu_open_reader and used
3079    with remote readers only.  Note that the supplied CLOSEFNC will
3080    only be called once and the slot will not be valid afther this.
3081
3082    If PORTSTR is NULL we default to the first availabe port.
3083 */
3084 int
3085 apdu_open_remote_reader (const char *portstr,
3086                          const unsigned char *cookie, size_t length,
3087                          int (*readfnc) (void *opaque,
3088                                          void *buffer, size_t size),
3089                          void *readfnc_value,
3090                          int (*writefnc) (void *opaque,
3091                                           const void *buffer, size_t size),
3092                          void *writefnc_value,
3093                          void (*closefnc) (void *opaque),
3094                          void *closefnc_value)
3095 {
3096 #ifdef USE_G10CODE_RAPDU
3097   return open_rapdu_reader (portstr? atoi (portstr) : 0,
3098                             cookie, length,
3099                             readfnc, readfnc_value,
3100                             writefnc, writefnc_value,
3101                             closefnc, closefnc_value);
3102 #else
3103   (void)portstr;
3104   (void)cookie;
3105   (void)length;
3106   (void)readfnc;
3107   (void)readfnc_value;
3108   (void)writefnc;
3109   (void)writefnc_value;
3110   (void)closefnc;
3111   (void)closefnc_value;
3112 #ifdef _WIN32
3113   errno = ENOENT;
3114 #else
3115   errno = ENOSYS;
3116 #endif
3117   return -1;
3118 #endif
3119 }
3120
3121
3122 int
3123 apdu_close_reader (int slot)
3124 {
3125   int sw;
3126
3127   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3128     return SW_HOST_NO_DRIVER;
3129   sw = apdu_disconnect (slot);
3130   if (sw)
3131     {
3132       /*
3133        * When the reader/token was removed it might come here.
3134        * It should go through to call CLOSE_READER even if we got an error.
3135        */
3136       log_debug ("apdu_close_reader => 0x%x (apdu_disconnect)\n", sw);
3137     }
3138   if (reader_table[slot].close_reader)
3139     return reader_table[slot].close_reader (slot);
3140   return SW_HOST_NOT_SUPPORTED;
3141 }
3142
3143
3144 /* Function suitable for a cleanup function to close all reader.  It
3145    should not be used if the reader will be opened again.  The reason
3146    for implementing this to properly close USB devices so that they
3147    will startup the next time without error. */
3148 void
3149 apdu_prepare_exit (void)
3150 {
3151   static int sentinel;
3152   int slot;
3153
3154   if (!sentinel)
3155     {
3156       sentinel = 1;
3157       for (slot = 0; slot < MAX_READER; slot++)
3158         if (reader_table[slot].used)
3159           {
3160             apdu_disconnect (slot);
3161             if (reader_table[slot].close_reader)
3162               reader_table[slot].close_reader (slot);
3163             reader_table[slot].used = 0;
3164           }
3165       sentinel = 0;
3166     }
3167 }
3168
3169
3170 /* Enumerate all readers and return information on whether this reader
3171    is in use.  The caller should start with SLOT set to 0 and
3172    increment it with each call until an error is returned. */
3173 int
3174 apdu_enum_reader (int slot, int *used)
3175 {
3176   if (slot < 0 || slot >= MAX_READER)
3177     return SW_HOST_NO_DRIVER;
3178   *used = reader_table[slot].used;
3179   return 0;
3180 }
3181
3182
3183 /* Connect a card.  This is used to power up the card and make sure
3184    that an ATR is available.  Depending on the reader backend it may
3185    return an error for an inactive card or if no card is
3186    available.  */
3187 int
3188 apdu_connect (int slot)
3189 {
3190   int sw = 0;
3191   unsigned int status = 0;
3192
3193   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3194     return SW_HOST_NO_DRIVER;
3195
3196   /* Only if the access method provides a connect function we use it.
3197      If not, we expect that the card has been implicitly connected by
3198      apdu_open_reader.  */
3199   if (reader_table[slot].connect_card)
3200     {
3201       sw = lock_slot (slot);
3202       if (!sw)
3203         {
3204           sw = reader_table[slot].connect_card (slot);
3205           unlock_slot (slot);
3206         }
3207     }
3208
3209   /* We need to call apdu_get_status_internal, so that the last-status
3210      machinery gets setup properly even if a card is inserted while
3211      scdaemon is fired up and apdu_get_status has not yet been called.
3212      Without that we would force a reset of the card with the next
3213      call to apdu_get_status.  */
3214   if (!sw)
3215     sw = apdu_get_status_internal (slot, 1, 1, &status, NULL);
3216
3217   if (sw)
3218     ;
3219   else if (!(status & APDU_CARD_PRESENT))
3220     sw = SW_HOST_NO_CARD;
3221   else if ((status & APDU_CARD_PRESENT) && !(status & APDU_CARD_ACTIVE))
3222     sw = SW_HOST_CARD_INACTIVE;
3223
3224
3225   return sw;
3226 }
3227
3228
3229 int
3230 apdu_disconnect (int slot)
3231 {
3232   int sw;
3233
3234   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3235     return SW_HOST_NO_DRIVER;
3236
3237   if (reader_table[slot].disconnect_card)
3238     {
3239       sw = lock_slot (slot);
3240       if (!sw)
3241         {
3242           sw = reader_table[slot].disconnect_card (slot);
3243           unlock_slot (slot);
3244         }
3245     }
3246   else
3247     sw = 0;
3248   return sw;
3249 }
3250
3251
3252 /* Set the progress callback of SLOT to CB and its args to CB_ARG.  If
3253    CB is NULL the progress callback is removed.  */
3254 int
3255 apdu_set_progress_cb (int slot, gcry_handler_progress_t cb, void *cb_arg)
3256 {
3257   int sw;
3258
3259   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3260     return SW_HOST_NO_DRIVER;
3261
3262   if (reader_table[slot].set_progress_cb)
3263     {
3264       sw = lock_slot (slot);
3265       if (!sw)
3266         {
3267           sw = reader_table[slot].set_progress_cb (slot, cb, cb_arg);
3268           unlock_slot (slot);
3269         }
3270     }
3271   else
3272     sw = 0;
3273   return sw;
3274 }
3275
3276
3277 /* Do a reset for the card in reader at SLOT. */
3278 int
3279 apdu_reset (int slot)
3280 {
3281   int sw;
3282
3283   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3284     return SW_HOST_NO_DRIVER;
3285
3286   if ((sw = lock_slot (slot)))
3287     return sw;
3288
3289   reader_table[slot].last_status = 0;
3290   if (reader_table[slot].reset_reader)
3291     sw = reader_table[slot].reset_reader (slot);
3292
3293   if (!sw)
3294     {
3295       /* If we got to here we know that a card is present
3296          and usable.  Thus remember this.  */
3297       reader_table[slot].last_status = (APDU_CARD_USABLE
3298                                         | APDU_CARD_PRESENT
3299                                         | APDU_CARD_ACTIVE);
3300     }
3301
3302   unlock_slot (slot);
3303   return sw;
3304 }
3305
3306
3307 /* Activate a card if it has not yet been done.  This is a kind of
3308    reset-if-required.  It is useful to test for presence of a card
3309    before issuing a bunch of apdu commands.  It does not wait on a
3310    locked card. */
3311 int
3312 apdu_activate (int slot)
3313 {
3314   int sw;
3315   unsigned int s;
3316
3317   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3318     return SW_HOST_NO_DRIVER;
3319
3320   if ((sw = trylock_slot (slot)))
3321     return sw;
3322
3323   if (reader_table[slot].get_status_reader)
3324     sw = reader_table[slot].get_status_reader (slot, &s);
3325
3326   if (!sw)
3327     {
3328       if (!(s & 2))  /* Card not present.  */
3329         sw = SW_HOST_NO_CARD;
3330       else if ( ((s & 2) && !(s & 4))
3331                 || !reader_table[slot].atrlen )
3332         {
3333           /* We don't have an ATR or a card is present though inactive:
3334              do a reset now. */
3335           if (reader_table[slot].reset_reader)
3336             {
3337               reader_table[slot].last_status = 0;
3338               sw = reader_table[slot].reset_reader (slot);
3339               if (!sw)
3340                 {
3341                   /* If we got to here we know that a card is present
3342                      and usable.  Thus remember this.  */
3343                   reader_table[slot].last_status = (APDU_CARD_USABLE
3344                                                     | APDU_CARD_PRESENT
3345                                                     | APDU_CARD_ACTIVE);
3346                 }
3347             }
3348         }
3349     }
3350
3351   unlock_slot (slot);
3352   return sw;
3353 }
3354
3355
3356 unsigned char *
3357 apdu_get_atr (int slot, size_t *atrlen)
3358 {
3359   unsigned char *buf;
3360
3361   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3362     return NULL;
3363   if (!reader_table[slot].atrlen)
3364     return NULL;
3365   buf = xtrymalloc (reader_table[slot].atrlen);
3366   if (!buf)
3367     return NULL;
3368   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
3369   *atrlen = reader_table[slot].atrlen;
3370   return buf;
3371 }
3372
3373
3374
3375 /* Retrieve the status for SLOT. The function does only wait for the
3376    card to become available if HANG is set to true. On success the
3377    bits in STATUS will be set to
3378
3379      APDU_CARD_USABLE  (bit 0) = card present and usable
3380      APDU_CARD_PRESENT (bit 1) = card present
3381      APDU_CARD_ACTIVE  (bit 2) = card active
3382                        (bit 3) = card access locked [not yet implemented]
3383
3384    For must applications, testing bit 0 is sufficient.
3385
3386    CHANGED will receive the value of the counter tracking the number
3387    of card insertions.  This value may be used to detect a card
3388    change.
3389 */
3390 static int
3391 apdu_get_status_internal (int slot, int hang, int no_atr_reset,
3392                           unsigned int *status, unsigned int *changed)
3393 {
3394   int sw;
3395   unsigned int s;
3396
3397   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3398     return SW_HOST_NO_DRIVER;
3399
3400   if ((sw = hang? lock_slot (slot) : trylock_slot (slot)))
3401     return sw;
3402
3403   if (reader_table[slot].get_status_reader)
3404     sw = reader_table[slot].get_status_reader (slot, &s);
3405
3406   unlock_slot (slot);
3407
3408   if (sw)
3409     {
3410       reader_table[slot].last_status = 0;
3411       return sw;
3412     }
3413
3414   /* Keep track of changes.  */
3415   if (s != reader_table[slot].last_status
3416       || !reader_table[slot].any_status )
3417     {
3418       reader_table[slot].change_counter++;
3419       /* Make sure that the ATR is invalid so that a reset will be
3420          triggered by apdu_activate.  */
3421       if (!no_atr_reset)
3422         reader_table[slot].atrlen = 0;
3423     }
3424   reader_table[slot].any_status = 1;
3425   reader_table[slot].last_status = s;
3426
3427   if (status)
3428     *status = s;
3429   if (changed)
3430     *changed = reader_table[slot].change_counter;
3431   return 0;
3432 }
3433
3434
3435 /* See above for a description.  */
3436 int
3437 apdu_get_status (int slot, int hang,
3438                  unsigned int *status, unsigned int *changed)
3439 {
3440   return apdu_get_status_internal (slot, hang, 0, status, changed);
3441 }
3442
3443
3444 /* Check whether the reader supports the ISO command code COMMAND on
3445    the pinpad.  Return 0 on success.  For a description of the pin
3446    parameters, see ccid-driver.c */
3447 int
3448 apdu_check_pinpad (int slot, int command, pininfo_t *pininfo)
3449 {
3450   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3451     return SW_HOST_NO_DRIVER;
3452
3453   if (opt.enable_pinpad_varlen)
3454     pininfo->fixedlen = 0;
3455
3456   if (reader_table[slot].check_pinpad)
3457     {
3458       int sw;
3459
3460       if ((sw = lock_slot (slot)))
3461         return sw;
3462
3463       sw = reader_table[slot].check_pinpad (slot, command, pininfo);
3464       unlock_slot (slot);
3465       return sw;
3466     }
3467   else
3468     return SW_HOST_NOT_SUPPORTED;
3469 }
3470
3471
3472 int
3473 apdu_pinpad_verify (int slot, int class, int ins, int p0, int p1,
3474                     pininfo_t *pininfo)
3475 {
3476   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3477     return SW_HOST_NO_DRIVER;
3478
3479   if (reader_table[slot].pinpad_verify)
3480     {
3481       int sw;
3482
3483       if ((sw = lock_slot (slot)))
3484         return sw;
3485
3486       sw = reader_table[slot].pinpad_verify (slot, class, ins, p0, p1,
3487                                              pininfo);
3488       unlock_slot (slot);
3489       return sw;
3490     }
3491   else
3492     return SW_HOST_NOT_SUPPORTED;
3493 }
3494
3495
3496 int
3497 apdu_pinpad_modify (int slot, int class, int ins, int p0, int p1,
3498                     pininfo_t *pininfo)
3499 {
3500   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3501     return SW_HOST_NO_DRIVER;
3502
3503   if (reader_table[slot].pinpad_modify)
3504     {
3505       int sw;
3506
3507       if ((sw = lock_slot (slot)))
3508         return sw;
3509
3510       sw = reader_table[slot].pinpad_modify (slot, class, ins, p0, p1,
3511                                              pininfo);
3512       unlock_slot (slot);
3513       return sw;
3514     }
3515   else
3516     return SW_HOST_NOT_SUPPORTED;
3517 }
3518
3519
3520 /* Dispatcher for the actual send_apdu function. Note, that this
3521    function should be called in locked state. */
3522 static int
3523 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
3524            unsigned char *buffer, size_t *buflen, pininfo_t *pininfo)
3525 {
3526   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3527     return SW_HOST_NO_DRIVER;
3528
3529   if (reader_table[slot].send_apdu_reader)
3530     return reader_table[slot].send_apdu_reader (slot,
3531                                                 apdu, apdulen,
3532                                                 buffer, buflen,
3533                                                 pininfo);
3534   else
3535     return SW_HOST_NOT_SUPPORTED;
3536 }
3537
3538
3539 /* Core APDU tranceiver function. Parameters are described at
3540    apdu_send_le with the exception of PININFO which indicates pinpad
3541    related operations if not NULL.  If EXTENDED_MODE is not 0
3542    command chaining or extended length will be used according to these
3543    values:
3544        n < 0 := Use command chaining with the data part limited to -n
3545                 in each chunk.  If -1 is used a default value is used.
3546       n == 0 := No extended mode or command chaining.
3547       n == 1 := Use extended length for input and output without a
3548                 length limit.
3549        n > 1 := Use extended length with up to N bytes.
3550
3551 */
3552 static int
3553 send_le (int slot, int class, int ins, int p0, int p1,
3554          int lc, const char *data, int le,
3555          unsigned char **retbuf, size_t *retbuflen,
3556          pininfo_t *pininfo, int extended_mode)
3557 {
3558 #define SHORT_RESULT_BUFFER_SIZE 258
3559   /* We allocate 8 extra bytes as a safety margin towards a driver bug.  */
3560   unsigned char short_result_buffer[SHORT_RESULT_BUFFER_SIZE+10];
3561   unsigned char *result_buffer = NULL;
3562   size_t result_buffer_size;
3563   unsigned char *result;
3564   size_t resultlen;
3565   unsigned char short_apdu_buffer[5+256+1];
3566   unsigned char *apdu_buffer = NULL;
3567   size_t apdu_buffer_size;
3568   unsigned char *apdu;
3569   size_t apdulen;
3570   int sw;
3571   long rc; /* We need a long here due to PC/SC. */
3572   int did_exact_length_hack = 0;
3573   int use_chaining = 0;
3574   int use_extended_length = 0;
3575   int lc_chunk;
3576
3577   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3578     return SW_HOST_NO_DRIVER;
3579
3580   if (DBG_CARD_IO)
3581     log_debug ("send apdu: c=%02X i=%02X p1=%02X p2=%02X lc=%d le=%d em=%d\n",
3582                class, ins, p0, p1, lc, le, extended_mode);
3583
3584   if (lc != -1 && (lc > 255 || lc < 0))
3585     {
3586       /* Data does not fit into an APDU.  What we do now depends on
3587          the EXTENDED_MODE parameter.  */
3588       if (!extended_mode)
3589         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
3590       else if (extended_mode > 0)
3591         use_extended_length = 1;
3592       else if (extended_mode < 0)
3593         {
3594           /* Send APDU using chaining mode.  */
3595           if (lc > 16384)
3596             return SW_WRONG_LENGTH;   /* Sanity check.  */
3597           if ((class&0xf0) != 0)
3598             return SW_HOST_INV_VALUE; /* Upper 4 bits need to be 0.  */
3599           use_chaining = extended_mode == -1? 255 : -extended_mode;
3600           use_chaining &= 0xff;
3601         }
3602       else
3603         return SW_HOST_INV_VALUE;
3604     }
3605   else if (lc == -1 && extended_mode > 0)
3606     use_extended_length = 1;
3607
3608   if (le != -1 && (le > (extended_mode > 0? 255:256) || le < 0))
3609     {
3610       /* Expected Data does not fit into an APDU.  What we do now
3611          depends on the EXTENDED_MODE parameter.  Note that a check
3612          for command chaining does not make sense because we are
3613          looking at Le.  */
3614       if (!extended_mode)
3615         return SW_WRONG_LENGTH; /* No way to send such an APDU.  */
3616       else if (use_extended_length)
3617         ; /* We are already using extended length.  */
3618       else if (extended_mode > 0)
3619         use_extended_length = 1;
3620       else
3621         return SW_HOST_INV_VALUE;
3622     }
3623
3624   if ((!data && lc != -1) || (data && lc == -1))
3625     return SW_HOST_INV_VALUE;
3626
3627   if (use_extended_length)
3628     {
3629       if (reader_table[slot].is_t0)
3630         return SW_HOST_NOT_SUPPORTED;
3631
3632       /* Space for: cls/ins/p1/p2+Z+2_byte_Lc+Lc+2_byte_Le.  */
3633       apdu_buffer_size = 4 + 1 + (lc >= 0? (2+lc):0) + 2;
3634       apdu_buffer = xtrymalloc (apdu_buffer_size + 10);
3635       if (!apdu_buffer)
3636         return SW_HOST_OUT_OF_CORE;
3637       apdu = apdu_buffer;
3638     }
3639   else
3640     {
3641       apdu_buffer_size = sizeof short_apdu_buffer;
3642       apdu = short_apdu_buffer;
3643     }
3644
3645   if (use_extended_length && (le > 256 || le < 0))
3646     {
3647       result_buffer_size = le < 0? 4096 : le;
3648       result_buffer = xtrymalloc (result_buffer_size + 10);
3649       if (!result_buffer)
3650         {
3651           xfree (apdu_buffer);
3652           return SW_HOST_OUT_OF_CORE;
3653         }
3654       result = result_buffer;
3655     }
3656   else
3657     {
3658       result_buffer_size = SHORT_RESULT_BUFFER_SIZE;
3659       result = short_result_buffer;
3660     }
3661 #undef SHORT_RESULT_BUFFER_SIZE
3662
3663   if ((sw = lock_slot (slot)))
3664     {
3665       xfree (apdu_buffer);
3666       xfree (result_buffer);
3667       return sw;
3668     }
3669
3670   do
3671     {
3672       if (use_extended_length)
3673         {
3674           use_chaining = 0;
3675           apdulen = 0;
3676           apdu[apdulen++] = class;
3677           apdu[apdulen++] = ins;
3678           apdu[apdulen++] = p0;
3679           apdu[apdulen++] = p1;
3680           if (lc > 0)
3681             {
3682               apdu[apdulen++] = 0;  /* Z byte: Extended length marker.  */
3683               apdu[apdulen++] = ((lc >> 8) & 0xff);
3684               apdu[apdulen++] = (lc & 0xff);
3685               memcpy (apdu+apdulen, data, lc);
3686               data += lc;
3687               apdulen += lc;
3688             }
3689           if (le != -1)
3690             {
3691               if (lc <= 0)
3692                 apdu[apdulen++] = 0;  /* Z byte: Extended length marker.  */
3693               apdu[apdulen++] = ((le >> 8) & 0xff);
3694               apdu[apdulen++] = (le & 0xff);
3695             }
3696         }
3697       else
3698         {
3699           apdulen = 0;
3700           apdu[apdulen] = class;
3701           if (use_chaining && lc > 255)
3702             {
3703               apdu[apdulen] |= 0x10;
3704               assert (use_chaining < 256);
3705               lc_chunk = use_chaining;
3706               lc -= use_chaining;
3707             }
3708           else
3709             {
3710               use_chaining = 0;
3711               lc_chunk = lc;
3712             }
3713           apdulen++;
3714           apdu[apdulen++] = ins;
3715           apdu[apdulen++] = p0;
3716           apdu[apdulen++] = p1;
3717           if (lc_chunk != -1)
3718             {
3719               apdu[apdulen++] = lc_chunk;
3720               memcpy (apdu+apdulen, data, lc_chunk);
3721               data += lc_chunk;
3722               apdulen += lc_chunk;
3723               /* T=0 does not allow the use of Lc together with Le;
3724                  thus disable Le in this case.  */
3725               if (reader_table[slot].is_t0)
3726                 le = -1;
3727             }
3728           if (le != -1 && !use_chaining)
3729             apdu[apdulen++] = le; /* Truncation is okay (0 means 256). */
3730         }
3731
3732     exact_length_hack:
3733       /* As a safeguard don't pass any garbage to the driver.  */
3734       assert (apdulen <= apdu_buffer_size);
3735       memset (apdu+apdulen, 0, apdu_buffer_size - apdulen);
3736       resultlen = result_buffer_size;
3737       rc = send_apdu (slot, apdu, apdulen, result, &resultlen, pininfo);
3738       if (rc || resultlen < 2)
3739         {
3740           log_info ("apdu_send_simple(%d) failed: %s\n",
3741                     slot, apdu_strerror (rc));
3742           unlock_slot (slot);
3743           xfree (apdu_buffer);
3744           xfree (result_buffer);
3745           return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
3746         }
3747       sw = (result[resultlen-2] << 8) | result[resultlen-1];
3748       if (!use_extended_length
3749           && !did_exact_length_hack && SW_EXACT_LENGTH_P (sw))
3750         {
3751           apdu[apdulen-1] = (sw & 0x00ff);
3752           did_exact_length_hack = 1;
3753           goto exact_length_hack;
3754         }
3755     }
3756   while (use_chaining && sw == SW_SUCCESS);
3757
3758   if (apdu_buffer)
3759     {
3760       xfree (apdu_buffer);
3761       apdu_buffer = NULL;
3762       apdu_buffer_size = 0;
3763     }
3764
3765   /* Store away the returned data but strip the statusword. */
3766   resultlen -= 2;
3767   if (DBG_CARD_IO)
3768     {
3769       log_debug (" response: sw=%04X  datalen=%d\n",
3770                  sw, (unsigned int)resultlen);
3771       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
3772         log_printhex ("    dump: ", result, resultlen);
3773     }
3774
3775   if (sw == SW_SUCCESS || sw == SW_EOF_REACHED)
3776     {
3777       if (retbuf)
3778         {
3779           *retbuf = xtrymalloc (resultlen? resultlen : 1);
3780           if (!*retbuf)
3781             {
3782               unlock_slot (slot);
3783               xfree (result_buffer);
3784               return SW_HOST_OUT_OF_CORE;
3785             }
3786           *retbuflen = resultlen;
3787           memcpy (*retbuf, result, resultlen);
3788         }
3789     }
3790   else if ((sw & 0xff00) == SW_MORE_DATA)
3791     {
3792       unsigned char *p = NULL, *tmp;
3793       size_t bufsize = 4096;
3794
3795       /* It is likely that we need to return much more data, so we
3796          start off with a large buffer. */
3797       if (retbuf)
3798         {
3799           *retbuf = p = xtrymalloc (bufsize);
3800           if (!*retbuf)
3801             {
3802               unlock_slot (slot);
3803               xfree (result_buffer);
3804               return SW_HOST_OUT_OF_CORE;
3805             }
3806           assert (resultlen < bufsize);
3807           memcpy (p, result, resultlen);
3808           p += resultlen;
3809         }
3810
3811       do
3812         {
3813           int len = (sw & 0x00ff);
3814
3815           if (DBG_CARD_IO)
3816             log_debug ("apdu_send_simple(%d): %d more bytes available\n",
3817                        slot, len);
3818           apdu_buffer_size = sizeof short_apdu_buffer;
3819           apdu = short_apdu_buffer;
3820           apdulen = 0;
3821           apdu[apdulen++] = class;
3822           apdu[apdulen++] = 0xC0;
3823           apdu[apdulen++] = 0;
3824           apdu[apdulen++] = 0;
3825           apdu[apdulen++] = len;
3826           assert (apdulen <= apdu_buffer_size);
3827           memset (apdu+apdulen, 0, apdu_buffer_size - apdulen);
3828           resultlen = result_buffer_size;
3829           rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
3830           if (rc || resultlen < 2)
3831             {
3832               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
3833                          slot, apdu_strerror (rc));
3834               unlock_slot (slot);
3835               xfree (result_buffer);
3836               return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
3837             }
3838           sw = (result[resultlen-2] << 8) | result[resultlen-1];
3839           resultlen -= 2;
3840           if (DBG_CARD_IO)
3841             {
3842               log_debug ("     more: sw=%04X  datalen=%d\n",
3843                          sw, (unsigned int)resultlen);
3844               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
3845                 log_printhex ("     dump: ", result, resultlen);
3846             }
3847
3848           if ((sw & 0xff00) == SW_MORE_DATA
3849               || sw == SW_SUCCESS
3850               || sw == SW_EOF_REACHED )
3851             {
3852               if (retbuf && resultlen)
3853                 {
3854                   if (p - *retbuf + resultlen > bufsize)
3855                     {
3856                       bufsize += resultlen > 4096? resultlen: 4096;
3857                       tmp = xtryrealloc (*retbuf, bufsize);
3858                       if (!tmp)
3859                         {
3860                           unlock_slot (slot);
3861                           xfree (result_buffer);
3862                           return SW_HOST_OUT_OF_CORE;
3863                         }
3864                       p = tmp + (p - *retbuf);
3865                       *retbuf = tmp;
3866                     }
3867                   memcpy (p, result, resultlen);
3868                   p += resultlen;
3869                 }
3870             }
3871           else
3872             log_info ("apdu_send_simple(%d) "
3873                       "got unexpected status %04X from get response\n",
3874                       slot, sw);
3875         }
3876       while ((sw & 0xff00) == SW_MORE_DATA);
3877
3878       if (retbuf)
3879         {
3880           *retbuflen = p - *retbuf;
3881           tmp = xtryrealloc (*retbuf, *retbuflen);
3882           if (tmp)
3883             *retbuf = tmp;
3884         }
3885     }
3886
3887   unlock_slot (slot);
3888   xfree (result_buffer);
3889
3890   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
3891     log_printhex ("      dump: ", *retbuf, *retbuflen);
3892
3893   return sw;
3894 }
3895
3896 /* Send an APDU to the card in SLOT.  The APDU is created from all
3897    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
3898    for LC won't sent this field and the data field; in this case DATA
3899    must also be passed as NULL.  If EXTENDED_MODE is not 0 command
3900    chaining or extended length will be used; see send_le for details.
3901    The return value is the status word or -1 for an invalid SLOT or
3902    other non card related error.  If RETBUF is not NULL, it will
3903    receive an allocated buffer with the returned data.  The length of
3904    that data will be put into *RETBUFLEN.  The caller is reponsible
3905    for releasing the buffer even in case of errors.  */
3906 int
3907 apdu_send_le(int slot, int extended_mode,
3908              int class, int ins, int p0, int p1,
3909              int lc, const char *data, int le,
3910              unsigned char **retbuf, size_t *retbuflen)
3911 {
3912   return send_le (slot, class, ins, p0, p1,
3913                   lc, data, le,
3914                   retbuf, retbuflen,
3915                   NULL, extended_mode);
3916 }
3917
3918
3919 /* Send an APDU to the card in SLOT.  The APDU is created from all
3920    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
3921    LC won't sent this field and the data field; in this case DATA must
3922    also be passed as NULL.  If EXTENDED_MODE is not 0 command chaining
3923    or extended length will be used; see send_le for details.  The
3924    return value is the status word or -1 for an invalid SLOT or other
3925    non card related error.  If RETBUF is not NULL, it will receive an
3926    allocated buffer with the returned data.  The length of that data
3927    will be put into *RETBUFLEN.  The caller is reponsible for
3928    releasing the buffer even in case of errors.  */
3929 int
3930 apdu_send (int slot, int extended_mode,
3931            int class, int ins, int p0, int p1,
3932            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
3933 {
3934   return send_le (slot, class, ins, p0, p1, lc, data, 256,
3935                   retbuf, retbuflen, NULL, extended_mode);
3936 }
3937
3938 /* Send an APDU to the card in SLOT.  The APDU is created from all
3939    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
3940    LC won't sent this field and the data field; in this case DATA must
3941    also be passed as NULL.  If EXTENDED_MODE is not 0 command chaining
3942    or extended length will be used; see send_le for details.  The
3943    return value is the status word or -1 for an invalid SLOT or other
3944    non card related error.  No data will be returned.  */
3945 int
3946 apdu_send_simple (int slot, int extended_mode,
3947                   int class, int ins, int p0, int p1,
3948                   int lc, const char *data)
3949 {
3950   return send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL, NULL,
3951                   extended_mode);
3952 }
3953
3954
3955 /* This is a more generic version of the apdu sending routine.  It
3956    takes an already formatted APDU in APDUDATA or length APDUDATALEN
3957    and returns with an APDU including the status word.  With
3958    HANDLE_MORE set to true this function will handle the MORE DATA
3959    status and return all APDUs concatenated with one status word at
3960    the end.  If EXTENDED_LENGTH is != 0 extended lengths are allowed
3961    with a max. result data length of EXTENDED_LENGTH bytes.  The
3962    function does not return a regular status word but 0 on success.
3963    If the slot is locked, the function returns immediately with an
3964    error.  */
3965 int
3966 apdu_send_direct (int slot, size_t extended_length,
3967                   const unsigned char *apdudata, size_t apdudatalen,
3968                   int handle_more,
3969                   unsigned char **retbuf, size_t *retbuflen)
3970 {
3971 #define SHORT_RESULT_BUFFER_SIZE 258
3972   unsigned char short_result_buffer[SHORT_RESULT_BUFFER_SIZE+10];
3973   unsigned char *result_buffer = NULL;
3974   size_t result_buffer_size;
3975   unsigned char *result;
3976   size_t resultlen;
3977   unsigned char short_apdu_buffer[5+256+10];
3978   unsigned char *apdu_buffer = NULL;
3979   unsigned char *apdu;
3980   size_t apdulen;
3981   int sw;
3982   long rc; /* we need a long here due to PC/SC. */
3983   int class;
3984
3985   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
3986     return SW_HOST_NO_DRIVER;
3987
3988   if (apdudatalen > 65535)
3989     return SW_HOST_INV_VALUE;
3990
3991   if (apdudatalen > sizeof short_apdu_buffer - 5)
3992     {
3993       apdu_buffer = xtrymalloc (apdudatalen + 5);
3994       if (!apdu_buffer)
3995         return SW_HOST_OUT_OF_CORE;
3996       apdu = apdu_buffer;
3997     }
3998   else
3999     {
4000       apdu = short_apdu_buffer;
4001     }
4002   apdulen = apdudatalen;
4003   memcpy (apdu, apdudata, apdudatalen);
4004   class = apdulen? *apdu : 0;
4005
4006   if (extended_length >= 256 && extended_length <= 65536)
4007     {
4008       result_buffer_size = extended_length;
4009       result_buffer = xtrymalloc (result_buffer_size + 10);
4010       if (!result_buffer)
4011         {
4012           xfree (apdu_buffer);
4013           return SW_HOST_OUT_OF_CORE;
4014         }
4015       result = result_buffer;
4016     }
4017   else
4018     {
4019       result_buffer_size = SHORT_RESULT_BUFFER_SIZE;
4020       result = short_result_buffer;
4021     }
4022 #undef SHORT_RESULT_BUFFER_SIZE
4023
4024   if ((sw = trylock_slot (slot)))
4025     {
4026       xfree (apdu_buffer);
4027       xfree (result_buffer);
4028       return sw;
4029     }
4030
4031   resultlen = result_buffer_size;
4032   rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
4033   xfree (apdu_buffer);
4034   apdu_buffer = NULL;
4035   if (rc || resultlen < 2)
4036     {
4037       log_error ("apdu_send_direct(%d) failed: %s\n",
4038                  slot, apdu_strerror (rc));
4039       unlock_slot (slot);
4040       xfree (result_buffer);
4041       return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
4042     }
4043   sw = (result[resultlen-2] << 8) | result[resultlen-1];
4044   /* Store away the returned data but strip the statusword. */
4045   resultlen -= 2;
4046   if (DBG_CARD_IO)
4047     {
4048       log_debug (" response: sw=%04X  datalen=%d\n",
4049                  sw, (unsigned int)resultlen);
4050       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
4051         log_printhex ("     dump: ", result, resultlen);
4052     }
4053
4054   if (handle_more && (sw & 0xff00) == SW_MORE_DATA)
4055     {
4056       unsigned char *p = NULL, *tmp;
4057       size_t bufsize = 4096;
4058
4059       /* It is likely that we need to return much more data, so we
4060          start off with a large buffer. */
4061       if (retbuf)
4062         {
4063           *retbuf = p = xtrymalloc (bufsize + 2);
4064           if (!*retbuf)
4065             {
4066               unlock_slot (slot);
4067               xfree (result_buffer);
4068               return SW_HOST_OUT_OF_CORE;
4069             }
4070           assert (resultlen < bufsize);
4071           memcpy (p, result, resultlen);
4072           p += resultlen;
4073         }
4074
4075       do
4076         {
4077           int len = (sw & 0x00ff);
4078
4079           if (DBG_CARD_IO)
4080             log_debug ("apdu_send_direct(%d): %d more bytes available\n",
4081                        slot, len);
4082           apdu = short_apdu_buffer;
4083           apdulen = 0;
4084           apdu[apdulen++] = class;
4085           apdu[apdulen++] = 0xC0;
4086           apdu[apdulen++] = 0;
4087           apdu[apdulen++] = 0;
4088           apdu[apdulen++] = len;
4089           memset (apdu+apdulen, 0, sizeof (short_apdu_buffer) - apdulen);
4090           resultlen = result_buffer_size;
4091           rc = send_apdu (slot, apdu, apdulen, result, &resultlen, NULL);
4092           if (rc || resultlen < 2)
4093             {
4094               log_error ("apdu_send_direct(%d) for get response failed: %s\n",
4095                          slot, apdu_strerror (rc));
4096               unlock_slot (slot);
4097               xfree (result_buffer);
4098               return rc ? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
4099             }
4100           sw = (result[resultlen-2] << 8) | result[resultlen-1];
4101           resultlen -= 2;
4102           if (DBG_CARD_IO)
4103             {
4104               log_debug ("     more: sw=%04X  datalen=%d\n",
4105                          sw, (unsigned int)resultlen);
4106               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
4107                 log_printhex ("     dump: ", result, resultlen);
4108             }
4109
4110           if ((sw & 0xff00) == SW_MORE_DATA
4111               || sw == SW_SUCCESS
4112               || sw == SW_EOF_REACHED )
4113             {
4114               if (retbuf && resultlen)
4115                 {
4116                   if (p - *retbuf + resultlen > bufsize)
4117                     {
4118                       bufsize += resultlen > 4096? resultlen: 4096;
4119                       tmp = xtryrealloc (*retbuf, bufsize + 2);
4120                       if (!tmp)
4121                         {
4122                           unlock_slot (slot);
4123                           xfree (result_buffer);
4124                           return SW_HOST_OUT_OF_CORE;
4125                         }
4126                       p = tmp + (p - *retbuf);
4127                       *retbuf = tmp;
4128                     }
4129                   memcpy (p, result, resultlen);
4130                   p += resultlen;
4131                 }
4132             }
4133           else
4134             log_info ("apdu_send_direct(%d) "
4135                       "got unexpected status %04X from get response\n",
4136                       slot, sw);
4137         }
4138       while ((sw & 0xff00) == SW_MORE_DATA);
4139
4140       if (retbuf)
4141         {
4142           *retbuflen = p - *retbuf;
4143           tmp = xtryrealloc (*retbuf, *retbuflen + 2);
4144           if (tmp)
4145             *retbuf = tmp;
4146         }
4147     }
4148   else
4149     {
4150       if (retbuf)
4151         {
4152           *retbuf = xtrymalloc ((resultlen? resultlen : 1)+2);
4153           if (!*retbuf)
4154             {
4155               unlock_slot (slot);
4156               xfree (result_buffer);
4157               return SW_HOST_OUT_OF_CORE;
4158             }
4159           *retbuflen = resultlen;
4160           memcpy (*retbuf, result, resultlen);
4161         }
4162     }
4163
4164   unlock_slot (slot);
4165   xfree (result_buffer);
4166
4167   /* Append the status word.  Note that we reserved the two extra
4168      bytes while allocating the buffer.  */
4169   if (retbuf)
4170     {
4171       (*retbuf)[(*retbuflen)++] = (sw >> 8);
4172       (*retbuf)[(*retbuflen)++] = sw;
4173     }
4174
4175   if (DBG_CARD_IO && retbuf)
4176     log_printhex ("      dump: ", *retbuf, *retbuflen);
4177
4178   return 0;
4179 }