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