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