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