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