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