scd: Fix timeout handling for key generation.
[gnupg.git] / scd / ccid-driver.c
1 /* ccid-driver.c - USB ChipCardInterfaceDevices driver
2  * Copyright (C) 2003, 2004, 2005, 2006, 2007
3  *               2008, 2009, 2013  Free Software Foundation, Inc.
4  * Written by Werner Koch.
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <https://www.gnu.org/licenses/>.
20  *
21  * ALTERNATIVELY, this file may be distributed under the terms of the
22  * following license, in which case the provisions of this license are
23  * required INSTEAD OF the GNU General Public License. If you wish to
24  * allow use of your version of this file only under the terms of the
25  * GNU General Public License, and not to allow others to use your
26  * version of this file under the terms of the following license,
27  * indicate your decision by deleting this paragraph and the license
28  * below.
29  *
30  * Redistribution and use in source and binary forms, with or without
31  * modification, are permitted provided that the following conditions
32  * are met:
33  * 1. Redistributions of source code must retain the above copyright
34  *    notice, and the entire permission notice in its entirety,
35  *    including the disclaimer of warranties.
36  * 2. Redistributions in binary form must reproduce the above copyright
37  *    notice, this list of conditions and the following disclaimer in the
38  *    documentation and/or other materials provided with the distribution.
39  * 3. The name of the author may not be used to endorse or promote
40  *    products derived from this software without specific prior
41  *    written permission.
42  *
43  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
44  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
45  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
46  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
47  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
48  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
49  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
51  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
52  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
53  * OF THE POSSIBILITY OF SUCH DAMAGE.
54  */
55
56
57 /* CCID (ChipCardInterfaceDevices) is a specification for accessing
58    smartcard via a reader connected to the USB.
59
60    This is a limited driver allowing to use some CCID drivers directly
61    without any other specila drivers. This is a fallback driver to be
62    used when nothing else works or the system should be kept minimal
63    for security reasons.  It makes use of the libusb library to gain
64    portable access to USB.
65
66    This driver has been tested with the SCM SCR335 and SPR532
67    smartcard readers and requires that a reader implements APDU or
68    TPDU level exchange and does fully automatic initialization.
69 */
70
71 #ifdef HAVE_CONFIG_H
72 # include <config.h>
73 #endif
74
75 #if defined(HAVE_LIBUSB) || defined(TEST)
76
77 #include <errno.h>
78 #include <stdio.h>
79 #include <stdlib.h>
80 #include <string.h>
81 #include <assert.h>
82 #include <sys/types.h>
83 #include <sys/stat.h>
84 #include <fcntl.h>
85 #include <time.h>
86 #include <unistd.h>
87 #ifdef HAVE_NPTH
88 # include <npth.h>
89 #endif /*HAVE_NPTH*/
90
91 #include <libusb.h>
92
93 #include "scdaemon.h"
94 #include "iso7816.h"
95 #define CCID_DRIVER_INCLUDE_USB_IDS 1
96 #include "ccid-driver.h"
97
98 #define DRVNAME "ccid-driver: "
99
100 /* Max length of buffer with out CCID message header of 10-byte
101    Sending: 547 for RSA-4096 key import
102         APDU size = 540 (24+4+256+256)
103         commnd + lc + le = 4 + 3 + 0
104    Sending: write data object of cardholder certificate
105         APDU size = 2048
106         commnd + lc + le = 4 + 3 + 0
107    Receiving: 2048 for cardholder certificate
108 */
109 #define CCID_MAX_BUF (2048+7+10)
110
111 /* CCID command timeout.  */
112 #define CCID_CMD_TIMEOUT (5*1000)
113 /* OpenPGPcard v2.1 requires huge timeout for key generation.  */
114 #define CCID_CMD_TIMEOUT_LONGER (60*1000)
115
116 /* Depending on how this source is used we either define our error
117    output to go to stderr or to the GnuPG based logging functions.  We
118    use the latter when GNUPG_MAJOR_VERSION or GNUPG_SCD_MAIN_HEADER
119    are defined.  */
120 #if defined(GNUPG_MAJOR_VERSION) || defined(GNUPG_SCD_MAIN_HEADER)
121
122 #if defined(GNUPG_SCD_MAIN_HEADER)
123 #  include GNUPG_SCD_MAIN_HEADER
124 #elif GNUPG_MAJOR_VERSION == 1 /* GnuPG Version is < 1.9. */
125 #  include "options.h"
126 #  include "util.h"
127 #  include "memory.h"
128 #  include "cardglue.h"
129 # else /* This is the modularized GnuPG 1.9 or later. */
130 #  include "scdaemon.h"
131 #endif
132
133
134 # define DEBUGOUT(t)         do { if (debug_level) \
135                                   log_debug (DRVNAME t); } while (0)
136 # define DEBUGOUT_1(t,a)     do { if (debug_level) \
137                                   log_debug (DRVNAME t,(a)); } while (0)
138 # define DEBUGOUT_2(t,a,b)   do { if (debug_level) \
139                                   log_debug (DRVNAME t,(a),(b)); } while (0)
140 # define DEBUGOUT_3(t,a,b,c) do { if (debug_level) \
141                                   log_debug (DRVNAME t,(a),(b),(c));} while (0)
142 # define DEBUGOUT_4(t,a,b,c,d) do { if (debug_level) \
143                               log_debug (DRVNAME t,(a),(b),(c),(d));} while (0)
144 # define DEBUGOUT_CONT(t)    do { if (debug_level) \
145                                   log_printf (t); } while (0)
146 # define DEBUGOUT_CONT_1(t,a)  do { if (debug_level) \
147                                   log_printf (t,(a)); } while (0)
148 # define DEBUGOUT_CONT_2(t,a,b)   do { if (debug_level) \
149                                   log_printf (t,(a),(b)); } while (0)
150 # define DEBUGOUT_CONT_3(t,a,b,c) do { if (debug_level) \
151                                   log_printf (t,(a),(b),(c)); } while (0)
152 # define DEBUGOUT_LF()       do { if (debug_level) \
153                                   log_printf ("\n"); } while (0)
154
155 #else /* Other usage of this source - don't use gnupg specifics. */
156
157 # define DEBUGOUT(t)          do { if (debug_level) \
158                      fprintf (stderr, DRVNAME t); } while (0)
159 # define DEBUGOUT_1(t,a)      do { if (debug_level) \
160                      fprintf (stderr, DRVNAME t, (a)); } while (0)
161 # define DEBUGOUT_2(t,a,b)    do { if (debug_level) \
162                      fprintf (stderr, DRVNAME t, (a), (b)); } while (0)
163 # define DEBUGOUT_3(t,a,b,c)  do { if (debug_level) \
164                      fprintf (stderr, DRVNAME t, (a), (b), (c)); } while (0)
165 # define DEBUGOUT_4(t,a,b,c,d)  do { if (debug_level) \
166                      fprintf (stderr, DRVNAME t, (a), (b), (c), (d));} while(0)
167 # define DEBUGOUT_CONT(t)     do { if (debug_level) \
168                      fprintf (stderr, t); } while (0)
169 # define DEBUGOUT_CONT_1(t,a) do { if (debug_level) \
170                      fprintf (stderr, t, (a)); } while (0)
171 # define DEBUGOUT_CONT_2(t,a,b) do { if (debug_level) \
172                      fprintf (stderr, t, (a), (b)); } while (0)
173 # define DEBUGOUT_CONT_3(t,a,b,c) do { if (debug_level) \
174                      fprintf (stderr, t, (a), (b), (c)); } while (0)
175 # define DEBUGOUT_LF()        do { if (debug_level) \
176                      putc ('\n', stderr); } while (0)
177
178 #endif /* This source not used by scdaemon. */
179
180
181 #ifndef EAGAIN
182 #define EAGAIN  EWOULDBLOCK
183 #endif
184
185
186
187 enum {
188   RDR_to_PC_NotifySlotChange= 0x50,
189   RDR_to_PC_HardwareError   = 0x51,
190
191   PC_to_RDR_SetParameters   = 0x61,
192   PC_to_RDR_IccPowerOn      = 0x62,
193   PC_to_RDR_IccPowerOff     = 0x63,
194   PC_to_RDR_GetSlotStatus   = 0x65,
195   PC_to_RDR_Secure          = 0x69,
196   PC_to_RDR_T0APDU          = 0x6a,
197   PC_to_RDR_Escape          = 0x6b,
198   PC_to_RDR_GetParameters   = 0x6c,
199   PC_to_RDR_ResetParameters = 0x6d,
200   PC_to_RDR_IccClock        = 0x6e,
201   PC_to_RDR_XfrBlock        = 0x6f,
202   PC_to_RDR_Mechanical      = 0x71,
203   PC_to_RDR_Abort           = 0x72,
204   PC_to_RDR_SetDataRate     = 0x73,
205
206   RDR_to_PC_DataBlock       = 0x80,
207   RDR_to_PC_SlotStatus      = 0x81,
208   RDR_to_PC_Parameters      = 0x82,
209   RDR_to_PC_Escape          = 0x83,
210   RDR_to_PC_DataRate        = 0x84
211 };
212
213
214 /* Two macro to detect whether a CCID command has failed and to get
215    the error code.  These macros assume that we can access the
216    mandatory first 10 bytes of a CCID message in BUF. */
217 #define CCID_COMMAND_FAILED(buf) ((buf)[7] & 0x40)
218 #define CCID_ERROR_CODE(buf)     (((unsigned char *)(buf))[8])
219
220
221 /* A list and a table with special transport descriptions. */
222 enum {
223   TRANSPORT_USB    = 0, /* Standard USB transport. */
224   TRANSPORT_CM4040 = 1  /* As used by the Cardman 4040. */
225 };
226
227 static struct
228 {
229   char *name;  /* Device name. */
230   int  type;
231
232 } transports[] = {
233   { "/dev/cmx0", TRANSPORT_CM4040 },
234   { "/dev/cmx1", TRANSPORT_CM4040 },
235   { NULL },
236 };
237
238
239 /* Store information on the driver's state.  A pointer to such a
240    structure is used as handle for most functions. */
241 struct ccid_driver_s
242 {
243   libusb_device_handle *idev;
244   int dev_fd;  /* -1 for USB transport or file descriptor of the
245                    transport device. */
246   unsigned int bai;
247   unsigned short id_vendor;
248   unsigned short id_product;
249   int ifc_no;
250   int ep_bulk_out;
251   int ep_bulk_in;
252   int ep_intr;
253   int seqno;
254   unsigned char t1_ns;
255   unsigned char t1_nr;
256   unsigned char nonnull_nad;
257   int max_ifsd;
258   int max_ccid_msglen;
259   int ifsc;
260   unsigned char apdu_level:2;     /* Reader supports short APDU level
261                                      exchange.  With a value of 2 short
262                                      and extended level is supported.*/
263   unsigned int auto_voltage:1;
264   unsigned int auto_param:1;
265   unsigned int auto_pps:1;
266   unsigned int auto_ifsd:1;
267   unsigned int has_pinpad:2;
268   unsigned int enodev_seen:1;
269   int powered_off;
270
271   time_t last_progress; /* Last time we sent progress line.  */
272
273   /* The progress callback and its first arg as supplied to
274      ccid_set_progress_cb.  */
275   void (*progress_cb)(void *, const char *, int, int, int);
276   void *progress_cb_arg;
277
278   unsigned char intr_buf[64];
279   struct libusb_transfer *transfer;
280 };
281
282
283 static int initialized_usb; /* Tracks whether USB has been initialized. */
284 static int debug_level;     /* Flag to control the debug output.
285                                0 = No debugging
286                                1 = USB I/O info
287                                2 = Level 1 + T=1 protocol tracing
288                                3 = Level 2 + USB/I/O tracing of SlotStatus.
289                               */
290 static int ccid_usb_thread_is_alive;
291
292
293 static unsigned int compute_edc (const unsigned char *data, size_t datalen,
294                                  int use_crc);
295 static int bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen,
296                      int no_debug);
297 static int bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
298                     size_t *nread, int expected_type, int seqno, int timeout,
299                     int no_debug);
300 static int abort_cmd (ccid_driver_t handle, int seqno);
301 static int send_escape_cmd (ccid_driver_t handle, const unsigned char *data,
302                             size_t datalen, unsigned char *result,
303                             size_t resultmax, size_t *resultlen);
304
305 /* Convert a little endian stored 4 byte value into an unsigned
306    integer. */
307 static unsigned int
308 convert_le_u32 (const unsigned char *buf)
309 {
310   return buf[0] | (buf[1] << 8) | (buf[2] << 16) | ((unsigned int)buf[3] << 24);
311 }
312
313
314 /* Convert a little endian stored 2 byte value into an unsigned
315    integer. */
316 static unsigned int
317 convert_le_u16 (const unsigned char *buf)
318 {
319   return buf[0] | (buf[1] << 8);
320 }
321
322 static void
323 set_msg_len (unsigned char *msg, unsigned int length)
324 {
325   msg[1] = length;
326   msg[2] = length >> 8;
327   msg[3] = length >> 16;
328   msg[4] = length >> 24;
329 }
330
331
332 static void
333 my_sleep (int seconds)
334 {
335 #ifdef USE_NPTH
336   npth_sleep (seconds);
337 #else
338 # ifdef HAVE_W32_SYSTEM
339   Sleep (seconds*1000);
340 # else
341   sleep (seconds);
342 # endif
343 #endif
344 }
345
346 static void
347 print_progress (ccid_driver_t handle)
348 {
349   time_t ct = time (NULL);
350
351   /* We don't want to print progress lines too often. */
352   if (ct == handle->last_progress)
353     return;
354
355   if (handle->progress_cb)
356     handle->progress_cb (handle->progress_cb_arg, "card_busy", 'w', 0, 0);
357
358   handle->last_progress = ct;
359 }
360
361
362
363 /* Pint an error message for a failed CCID command including a textual
364    error code.  MSG shall be the CCID message at a minimum of 10 bytes. */
365 static void
366 print_command_failed (const unsigned char *msg)
367 {
368   const char *t;
369   char buffer[100];
370   int ec;
371
372   if (!debug_level)
373     return;
374
375   ec = CCID_ERROR_CODE (msg);
376   switch (ec)
377     {
378     case 0x00: t = "Command not supported"; break;
379
380     case 0xE0: t = "Slot busy"; break;
381     case 0xEF: t = "PIN cancelled"; break;
382     case 0xF0: t = "PIN timeout"; break;
383
384     case 0xF2: t = "Automatic sequence ongoing"; break;
385     case 0xF3: t = "Deactivated Protocol"; break;
386     case 0xF4: t = "Procedure byte conflict"; break;
387     case 0xF5: t = "ICC class not supported"; break;
388     case 0xF6: t = "ICC protocol not supported"; break;
389     case 0xF7: t = "Bad checksum in ATR"; break;
390     case 0xF8: t = "Bad TS in ATR"; break;
391
392     case 0xFB: t = "An all inclusive hardware error occurred"; break;
393     case 0xFC: t = "Overrun error while talking to the ICC"; break;
394     case 0xFD: t = "Parity error while talking to the ICC"; break;
395     case 0xFE: t = "CCID timed out while talking to the ICC"; break;
396     case 0xFF: t = "Host aborted the current activity"; break;
397
398     default:
399       if (ec > 0 && ec < 128)
400         sprintf (buffer, "Parameter error at offset %d", ec);
401       else
402         sprintf (buffer, "Error code %02X", ec);
403       t = buffer;
404       break;
405     }
406   DEBUGOUT_1 ("CCID command failed: %s\n", t);
407 }
408
409
410 static void
411 print_pr_data (const unsigned char *data, size_t datalen, size_t off)
412 {
413   int any = 0;
414
415   for (; off < datalen; off++)
416     {
417       if (!any || !(off % 16))
418         {
419           if (any)
420             DEBUGOUT_LF ();
421           DEBUGOUT_1 ("  [%04lu] ", (unsigned long) off);
422         }
423       DEBUGOUT_CONT_1 (" %02X", data[off]);
424       any = 1;
425     }
426   if (any && (off % 16))
427     DEBUGOUT_LF ();
428 }
429
430
431 static void
432 print_p2r_header (const char *name, const unsigned char *msg, size_t msglen)
433 {
434   DEBUGOUT_1 ("%s:\n", name);
435   if (msglen < 7)
436     return;
437   DEBUGOUT_1 ("  dwLength ..........: %u\n", convert_le_u32 (msg+1));
438   DEBUGOUT_1 ("  bSlot .............: %u\n", msg[5]);
439   DEBUGOUT_1 ("  bSeq ..............: %u\n", msg[6]);
440 }
441
442
443 static void
444 print_p2r_iccpoweron (const unsigned char *msg, size_t msglen)
445 {
446   print_p2r_header ("PC_to_RDR_IccPowerOn", msg, msglen);
447   if (msglen < 10)
448     return;
449   DEBUGOUT_2 ("  bPowerSelect ......: 0x%02x (%s)\n", msg[7],
450               msg[7] == 0? "auto":
451               msg[7] == 1? "5.0 V":
452               msg[7] == 2? "3.0 V":
453               msg[7] == 3? "1.8 V":"");
454   print_pr_data (msg, msglen, 8);
455 }
456
457
458 static void
459 print_p2r_iccpoweroff (const unsigned char *msg, size_t msglen)
460 {
461   print_p2r_header ("PC_to_RDR_IccPowerOff", msg, msglen);
462   print_pr_data (msg, msglen, 7);
463 }
464
465
466 static void
467 print_p2r_getslotstatus (const unsigned char *msg, size_t msglen)
468 {
469   print_p2r_header ("PC_to_RDR_GetSlotStatus", msg, msglen);
470   print_pr_data (msg, msglen, 7);
471 }
472
473
474 static void
475 print_p2r_xfrblock (const unsigned char *msg, size_t msglen)
476 {
477   unsigned int val;
478
479   print_p2r_header ("PC_to_RDR_XfrBlock", msg, msglen);
480   if (msglen < 10)
481     return;
482   DEBUGOUT_1 ("  bBWI ..............: 0x%02x\n", msg[7]);
483   val = convert_le_u16 (msg+8);
484   DEBUGOUT_2 ("  wLevelParameter ...: 0x%04x%s\n", val,
485               val == 1? " (continued)":
486               val == 2? " (continues+ends)":
487               val == 3? " (continues+continued)":
488               val == 16? " (DataBlock-expected)":"");
489   print_pr_data (msg, msglen, 10);
490 }
491
492
493 static void
494 print_p2r_getparameters (const unsigned char *msg, size_t msglen)
495 {
496   print_p2r_header ("PC_to_RDR_GetParameters", msg, msglen);
497   print_pr_data (msg, msglen, 7);
498 }
499
500
501 static void
502 print_p2r_resetparameters (const unsigned char *msg, size_t msglen)
503 {
504   print_p2r_header ("PC_to_RDR_ResetParameters", msg, msglen);
505   print_pr_data (msg, msglen, 7);
506 }
507
508
509 static void
510 print_p2r_setparameters (const unsigned char *msg, size_t msglen)
511 {
512   print_p2r_header ("PC_to_RDR_SetParameters", msg, msglen);
513   if (msglen < 10)
514     return;
515   DEBUGOUT_1 ("  bProtocolNum ......: 0x%02x\n", msg[7]);
516   print_pr_data (msg, msglen, 8);
517 }
518
519
520 static void
521 print_p2r_escape (const unsigned char *msg, size_t msglen)
522 {
523   print_p2r_header ("PC_to_RDR_Escape", msg, msglen);
524   print_pr_data (msg, msglen, 7);
525 }
526
527
528 static void
529 print_p2r_iccclock (const unsigned char *msg, size_t msglen)
530 {
531   print_p2r_header ("PC_to_RDR_IccClock", msg, msglen);
532   if (msglen < 10)
533     return;
534   DEBUGOUT_1 ("  bClockCommand .....: 0x%02x\n", msg[7]);
535   print_pr_data (msg, msglen, 8);
536 }
537
538
539 static void
540 print_p2r_to0apdu (const unsigned char *msg, size_t msglen)
541 {
542   print_p2r_header ("PC_to_RDR_T0APDU", msg, msglen);
543   if (msglen < 10)
544     return;
545   DEBUGOUT_1 ("  bmChanges .........: 0x%02x\n", msg[7]);
546   DEBUGOUT_1 ("  bClassGetResponse .: 0x%02x\n", msg[8]);
547   DEBUGOUT_1 ("  bClassEnvelope ....: 0x%02x\n", msg[9]);
548   print_pr_data (msg, msglen, 10);
549 }
550
551
552 static void
553 print_p2r_secure (const unsigned char *msg, size_t msglen)
554 {
555   unsigned int val;
556
557   print_p2r_header ("PC_to_RDR_Secure", msg, msglen);
558   if (msglen < 10)
559     return;
560   DEBUGOUT_1 ("  bBMI ..............: 0x%02x\n", msg[7]);
561   val = convert_le_u16 (msg+8);
562   DEBUGOUT_2 ("  wLevelParameter ...: 0x%04x%s\n", val,
563               val == 1? " (continued)":
564               val == 2? " (continues+ends)":
565               val == 3? " (continues+continued)":
566               val == 16? " (DataBlock-expected)":"");
567   print_pr_data (msg, msglen, 10);
568 }
569
570
571 static void
572 print_p2r_mechanical (const unsigned char *msg, size_t msglen)
573 {
574   print_p2r_header ("PC_to_RDR_Mechanical", msg, msglen);
575   if (msglen < 10)
576     return;
577   DEBUGOUT_1 ("  bFunction .........: 0x%02x\n", msg[7]);
578   print_pr_data (msg, msglen, 8);
579 }
580
581
582 static void
583 print_p2r_abort (const unsigned char *msg, size_t msglen)
584 {
585   print_p2r_header ("PC_to_RDR_Abort", msg, msglen);
586   print_pr_data (msg, msglen, 7);
587 }
588
589
590 static void
591 print_p2r_setdatarate (const unsigned char *msg, size_t msglen)
592 {
593   print_p2r_header ("PC_to_RDR_SetDataRate", msg, msglen);
594   if (msglen < 10)
595     return;
596   print_pr_data (msg, msglen, 7);
597 }
598
599
600 static void
601 print_p2r_unknown (const unsigned char *msg, size_t msglen)
602 {
603   print_p2r_header ("Unknown PC_to_RDR command", msg, msglen);
604   if (msglen < 10)
605     return;
606   print_pr_data (msg, msglen, 0);
607 }
608
609
610 static void
611 print_r2p_header (const char *name, const unsigned char *msg, size_t msglen)
612 {
613   DEBUGOUT_1 ("%s:\n", name);
614   if (msglen < 9)
615     return;
616   DEBUGOUT_1 ("  dwLength ..........: %u\n", convert_le_u32 (msg+1));
617   DEBUGOUT_1 ("  bSlot .............: %u\n", msg[5]);
618   DEBUGOUT_1 ("  bSeq ..............: %u\n", msg[6]);
619   DEBUGOUT_1 ("  bStatus ...........: %u\n", msg[7]);
620   if (msg[8])
621     DEBUGOUT_1 ("  bError ............: %u\n", msg[8]);
622 }
623
624
625 static void
626 print_r2p_datablock (const unsigned char *msg, size_t msglen)
627 {
628   print_r2p_header ("RDR_to_PC_DataBlock", msg, msglen);
629   if (msglen < 10)
630     return;
631   if (msg[9])
632     DEBUGOUT_2 ("  bChainParameter ...: 0x%02x%s\n", msg[9],
633                 msg[9] == 1? " (continued)":
634                 msg[9] == 2? " (continues+ends)":
635                 msg[9] == 3? " (continues+continued)":
636                 msg[9] == 16? " (XferBlock-expected)":"");
637   print_pr_data (msg, msglen, 10);
638 }
639
640
641 static void
642 print_r2p_slotstatus (const unsigned char *msg, size_t msglen)
643 {
644   print_r2p_header ("RDR_to_PC_SlotStatus", msg, msglen);
645   if (msglen < 10)
646     return;
647   DEBUGOUT_2 ("  bClockStatus ......: 0x%02x%s\n", msg[9],
648               msg[9] == 0? " (running)":
649               msg[9] == 1? " (stopped-L)":
650               msg[9] == 2? " (stopped-H)":
651               msg[9] == 3? " (stopped)":"");
652   print_pr_data (msg, msglen, 10);
653 }
654
655
656 static void
657 print_r2p_parameters (const unsigned char *msg, size_t msglen)
658 {
659   print_r2p_header ("RDR_to_PC_Parameters", msg, msglen);
660   if (msglen < 10)
661     return;
662
663   DEBUGOUT_1 ("  protocol ..........: T=%d\n", msg[9]);
664   if (msglen == 17 && msg[9] == 1)
665     {
666       /* Protocol T=1.  */
667       DEBUGOUT_1 ("  bmFindexDindex ....: %02X\n", msg[10]);
668       DEBUGOUT_1 ("  bmTCCKST1 .........: %02X\n", msg[11]);
669       DEBUGOUT_1 ("  bGuardTimeT1 ......: %02X\n", msg[12]);
670       DEBUGOUT_1 ("  bmWaitingIntegersT1: %02X\n", msg[13]);
671       DEBUGOUT_1 ("  bClockStop ........: %02X\n", msg[14]);
672       DEBUGOUT_1 ("  bIFSC .............: %d\n", msg[15]);
673       DEBUGOUT_1 ("  bNadValue .........: %d\n", msg[16]);
674     }
675   else
676     print_pr_data (msg, msglen, 10);
677 }
678
679
680 static void
681 print_r2p_escape (const unsigned char *msg, size_t msglen)
682 {
683   print_r2p_header ("RDR_to_PC_Escape", msg, msglen);
684   if (msglen < 10)
685     return;
686   DEBUGOUT_1 ("  buffer[9] .........: %02X\n", msg[9]);
687   print_pr_data (msg, msglen, 10);
688 }
689
690
691 static void
692 print_r2p_datarate (const unsigned char *msg, size_t msglen)
693 {
694   print_r2p_header ("RDR_to_PC_DataRate", msg, msglen);
695   if (msglen < 10)
696     return;
697   if (msglen >= 18)
698     {
699       DEBUGOUT_1 ("  dwClockFrequency ..: %u\n", convert_le_u32 (msg+10));
700       DEBUGOUT_1 ("  dwDataRate ..... ..: %u\n", convert_le_u32 (msg+14));
701       print_pr_data (msg, msglen, 18);
702     }
703   else
704     print_pr_data (msg, msglen, 10);
705 }
706
707
708 static void
709 print_r2p_unknown (const unsigned char *msg, size_t msglen)
710 {
711   print_r2p_header ("Unknown RDR_to_PC command", msg, msglen);
712   if (msglen < 10)
713     return;
714   DEBUGOUT_1 ("  bMessageType ......: %02X\n", msg[0]);
715   DEBUGOUT_1 ("  buffer[9] .........: %02X\n", msg[9]);
716   print_pr_data (msg, msglen, 10);
717 }
718
719
720 /* Given a handle used for special transport prepare it for use.  In
721    particular setup all information in way that resembles what
722    parse_cccid_descriptor does. */
723 static void
724 prepare_special_transport (ccid_driver_t handle)
725 {
726   assert (!handle->id_vendor);
727
728   handle->nonnull_nad = 0;
729   handle->auto_ifsd = 0;
730   handle->max_ifsd = 32;
731   handle->max_ccid_msglen = CCID_MAX_BUF;
732   handle->has_pinpad = 0;
733   handle->apdu_level = 0;
734   switch (handle->id_product)
735     {
736     case TRANSPORT_CM4040:
737       DEBUGOUT ("setting up transport for CardMan 4040\n");
738       handle->apdu_level = 1;
739       break;
740
741     default: assert (!"transport not defined");
742     }
743 }
744
745 /* Parse a CCID descriptor, optionally print all available features
746    and test whether this reader is usable by this driver.  Returns 0
747    if it is usable.
748
749    Note, that this code is based on the one in lsusb.c of the
750    usb-utils package, I wrote on 2003-09-01. -wk. */
751 static int
752 parse_ccid_descriptor (ccid_driver_t handle, unsigned short bcd_device,
753                        const unsigned char *buf, size_t buflen)
754 {
755   unsigned int i;
756   unsigned int us;
757   int have_t1 = 0, have_tpdu=0;
758
759   handle->nonnull_nad = 0;
760   handle->auto_ifsd = 0;
761   handle->max_ifsd = 32;
762   handle->has_pinpad = 0;
763   handle->apdu_level = 0;
764   handle->auto_voltage = 0;
765   handle->auto_param = 0;
766   handle->auto_pps = 0;
767   DEBUGOUT_3 ("idVendor: %04X  idProduct: %04X  bcdDevice: %04X\n",
768               handle->id_vendor, handle->id_product, bcd_device);
769   if (buflen < 54 || buf[0] < 54)
770     {
771       DEBUGOUT ("CCID device descriptor is too short\n");
772       return -1;
773     }
774
775   DEBUGOUT   ("ChipCard Interface Descriptor:\n");
776   DEBUGOUT_1 ("  bLength             %5u\n", buf[0]);
777   DEBUGOUT_1 ("  bDescriptorType     %5u\n", buf[1]);
778   DEBUGOUT_2 ("  bcdCCID             %2x.%02x", buf[3], buf[2]);
779     if (buf[3] != 1 || buf[2] != 0)
780       DEBUGOUT_CONT("  (Warning: Only accurate for version 1.0)");
781   DEBUGOUT_LF ();
782
783   DEBUGOUT_1 ("  nMaxSlotIndex       %5u\n", buf[4]);
784   DEBUGOUT_2 ("  bVoltageSupport     %5u  %s\n",
785               buf[5], (buf[5] == 1? "5.0V" : buf[5] == 2? "3.0V"
786                        : buf[5] == 3? "1.8V":"?"));
787
788   us = convert_le_u32 (buf+6);
789   DEBUGOUT_1 ("  dwProtocols         %5u ", us);
790   if ((us & 1))
791     DEBUGOUT_CONT (" T=0");
792   if ((us & 2))
793     {
794       DEBUGOUT_CONT (" T=1");
795       have_t1 = 1;
796     }
797   if ((us & ~3))
798     DEBUGOUT_CONT (" (Invalid values detected)");
799   DEBUGOUT_LF ();
800
801   us = convert_le_u32(buf+10);
802   DEBUGOUT_1 ("  dwDefaultClock      %5u\n", us);
803   us = convert_le_u32(buf+14);
804   DEBUGOUT_1 ("  dwMaxiumumClock     %5u\n", us);
805   DEBUGOUT_1 ("  bNumClockSupported  %5u\n", buf[18]);
806   us = convert_le_u32(buf+19);
807   DEBUGOUT_1 ("  dwDataRate        %7u bps\n", us);
808   us = convert_le_u32(buf+23);
809   DEBUGOUT_1 ("  dwMaxDataRate     %7u bps\n", us);
810   DEBUGOUT_1 ("  bNumDataRatesSupp.  %5u\n", buf[27]);
811
812   us = convert_le_u32(buf+28);
813   DEBUGOUT_1 ("  dwMaxIFSD           %5u\n", us);
814   handle->max_ifsd = us;
815
816   us = convert_le_u32(buf+32);
817   DEBUGOUT_1 ("  dwSyncProtocols  %08X ", us);
818   if ((us&1))
819     DEBUGOUT_CONT ( " 2-wire");
820   if ((us&2))
821     DEBUGOUT_CONT ( " 3-wire");
822   if ((us&4))
823     DEBUGOUT_CONT ( " I2C");
824   DEBUGOUT_LF ();
825
826   us = convert_le_u32(buf+36);
827   DEBUGOUT_1 ("  dwMechanical     %08X ", us);
828   if ((us & 1))
829     DEBUGOUT_CONT (" accept");
830   if ((us & 2))
831     DEBUGOUT_CONT (" eject");
832   if ((us & 4))
833     DEBUGOUT_CONT (" capture");
834   if ((us & 8))
835     DEBUGOUT_CONT (" lock");
836   DEBUGOUT_LF ();
837
838   us = convert_le_u32(buf+40);
839   DEBUGOUT_1 ("  dwFeatures       %08X\n", us);
840   if ((us & 0x0002))
841     {
842       DEBUGOUT ("    Auto configuration based on ATR (assumes auto voltage)\n");
843       handle->auto_voltage = 1;
844     }
845   if ((us & 0x0004))
846     DEBUGOUT ("    Auto activation on insert\n");
847   if ((us & 0x0008))
848     {
849       DEBUGOUT ("    Auto voltage selection\n");
850       handle->auto_voltage = 1;
851     }
852   if ((us & 0x0010))
853     DEBUGOUT ("    Auto clock change\n");
854   if ((us & 0x0020))
855     DEBUGOUT ("    Auto baud rate change\n");
856   if ((us & 0x0040))
857     {
858       DEBUGOUT ("    Auto parameter negotiation made by CCID\n");
859       handle->auto_param = 1;
860     }
861   else if ((us & 0x0080))
862     {
863       DEBUGOUT ("    Auto PPS made by CCID\n");
864       handle->auto_pps = 1;
865     }
866   if ((us & (0x0040 | 0x0080)) == (0x0040 | 0x0080))
867     DEBUGOUT ("    WARNING: conflicting negotiation features\n");
868
869   if ((us & 0x0100))
870     DEBUGOUT ("    CCID can set ICC in clock stop mode\n");
871   if ((us & 0x0200))
872     {
873       DEBUGOUT ("    NAD value other than 0x00 accepted\n");
874       handle->nonnull_nad = 1;
875     }
876   if ((us & 0x0400))
877     {
878       DEBUGOUT ("    Auto IFSD exchange\n");
879       handle->auto_ifsd = 1;
880     }
881
882   if ((us & 0x00010000))
883     {
884       DEBUGOUT ("    TPDU level exchange\n");
885       have_tpdu = 1;
886     }
887   else if ((us & 0x00020000))
888     {
889       DEBUGOUT ("    Short APDU level exchange\n");
890       handle->apdu_level = 1;
891     }
892   else if ((us & 0x00040000))
893     {
894       DEBUGOUT ("    Short and extended APDU level exchange\n");
895       handle->apdu_level = 2;
896     }
897   else if ((us & 0x00070000))
898     DEBUGOUT ("    WARNING: conflicting exchange levels\n");
899
900   us = convert_le_u32(buf+44);
901   DEBUGOUT_1 ("  dwMaxCCIDMsgLen     %5u\n", us);
902   handle->max_ccid_msglen = us;
903
904   DEBUGOUT (  "  bClassGetResponse    ");
905   if (buf[48] == 0xff)
906     DEBUGOUT_CONT ("echo\n");
907   else
908     DEBUGOUT_CONT_1 ("  %02X\n", buf[48]);
909
910   DEBUGOUT (  "  bClassEnvelope       ");
911   if (buf[49] == 0xff)
912     DEBUGOUT_CONT ("echo\n");
913   else
914     DEBUGOUT_CONT_1 ("  %02X\n", buf[48]);
915
916   DEBUGOUT (  "  wlcdLayout           ");
917   if (!buf[50] && !buf[51])
918     DEBUGOUT_CONT ("none\n");
919   else
920     DEBUGOUT_CONT_2 ("%u cols %u lines\n", buf[50], buf[51]);
921
922   DEBUGOUT_1 ("  bPINSupport         %5u ", buf[52]);
923   if ((buf[52] & 1))
924     {
925       DEBUGOUT_CONT ( " verification");
926       handle->has_pinpad |= 1;
927     }
928   if ((buf[52] & 2))
929     {
930       DEBUGOUT_CONT ( " modification");
931       handle->has_pinpad |= 2;
932     }
933   DEBUGOUT_LF ();
934
935   DEBUGOUT_1 ("  bMaxCCIDBusySlots   %5u\n", buf[53]);
936
937   if (buf[0] > 54)
938     {
939       DEBUGOUT ("  junk             ");
940       for (i=54; i < buf[0]-54; i++)
941         DEBUGOUT_CONT_1 (" %02X", buf[i]);
942       DEBUGOUT_LF ();
943     }
944
945   if (!have_t1 || !(have_tpdu  || handle->apdu_level))
946     {
947       DEBUGOUT ("this drivers requires that the reader supports T=1, "
948                 "TPDU or APDU level exchange - this is not available\n");
949       return -1;
950     }
951
952
953   /* SCM drivers get stuck in their internal USB stack if they try to
954      send a frame of n*wMaxPacketSize back to us.  Given that
955      wMaxPacketSize is 64 for these readers we set the IFSD to a value
956      lower than that:
957         64 - 10 CCID header -  4 T1frame - 2 reserved = 48
958      Product Ids:
959          0xe001 - SCR 331
960          0x5111 - SCR 331-DI
961          0x5115 - SCR 335
962          0xe003 - SPR 532
963      The
964          0x5117 - SCR 3320 USB ID-000 reader
965      seems to be very slow but enabling this workaround boosts the
966      performance to a more or less acceptable level (tested by David).
967
968   */
969   if (handle->id_vendor == VENDOR_SCM
970       && handle->max_ifsd > 48
971       && (  (handle->id_product == SCM_SCR331   && bcd_device < 0x0516)
972           ||(handle->id_product == SCM_SCR331DI && bcd_device < 0x0620)
973           ||(handle->id_product == SCM_SCR335   && bcd_device < 0x0514)
974           ||(handle->id_product == SCM_SPR532   && bcd_device < 0x0504)
975           ||(handle->id_product == SCM_SCR3320  && bcd_device < 0x0522)
976           ))
977     {
978       DEBUGOUT ("enabling workaround for buggy SCM readers\n");
979       handle->max_ifsd = 48;
980     }
981
982   if (handle->id_vendor == VENDOR_GEMPC)
983     {
984       DEBUGOUT ("enabling product quirk: disable non-null NAD\n");
985       handle->nonnull_nad = 0;
986     }
987
988   return 0;
989 }
990
991
992 static char *
993 get_escaped_usb_string (libusb_device_handle *idev, int idx,
994                         const char *prefix, const char *suffix)
995 {
996   int rc;
997   unsigned char buf[280];
998   unsigned char *s;
999   unsigned int langid;
1000   size_t i, n, len;
1001   char *result;
1002
1003   if (!idx)
1004     return NULL;
1005
1006   /* Fixme: The next line is for the current Valgrid without support
1007      for USB IOCTLs. */
1008   memset (buf, 0, sizeof buf);
1009
1010   /* First get the list of supported languages and use the first one.
1011      If we do don't find it we try to use English.  Note that this is
1012      all in a 2 bute Unicode encoding using little endian. */
1013 #ifdef USE_NPTH
1014   npth_unprotect ();
1015 #endif
1016   rc = libusb_control_transfer (idev, LIBUSB_ENDPOINT_IN,
1017                                 LIBUSB_REQUEST_GET_DESCRIPTOR,
1018                                 (LIBUSB_DT_STRING << 8), 0,
1019                                 (char*)buf, sizeof buf, 1000 /* ms timeout */);
1020 #ifdef USE_NPTH
1021   npth_protect ();
1022 #endif
1023   if (rc < 4)
1024     langid = 0x0409; /* English.  */
1025   else
1026     langid = (buf[3] << 8) | buf[2];
1027
1028 #ifdef USE_NPTH
1029   npth_unprotect ();
1030 #endif
1031   rc = libusb_control_transfer (idev, LIBUSB_ENDPOINT_IN,
1032                                 LIBUSB_REQUEST_GET_DESCRIPTOR,
1033                                 (LIBUSB_DT_STRING << 8) + idx, langid,
1034                                 (char*)buf, sizeof buf, 1000 /* ms timeout */);
1035 #ifdef USE_NPTH
1036   npth_protect ();
1037 #endif
1038   if (rc < 2 || buf[1] != LIBUSB_DT_STRING)
1039     return NULL; /* Error or not a string. */
1040   len = buf[0];
1041   if (len > rc)
1042     return NULL; /* Larger than our buffer. */
1043
1044   for (s=buf+2, i=2, n=0; i+1 < len; i += 2, s += 2)
1045     {
1046       if (s[1])
1047         n++; /* High byte set. */
1048       else if (*s <= 0x20 || *s >= 0x7f || *s == '%' || *s == ':')
1049         n += 3 ;
1050       else
1051         n++;
1052     }
1053
1054   result = malloc (strlen (prefix) + n + strlen (suffix) + 1);
1055   if (!result)
1056     return NULL;
1057
1058   strcpy (result, prefix);
1059   n = strlen (prefix);
1060   for (s=buf+2, i=2; i+1 < len; i += 2, s += 2)
1061     {
1062       if (s[1])
1063         result[n++] = '\xff'; /* High byte set. */
1064       else if (*s <= 0x20 || *s >= 0x7f || *s == '%' || *s == ':')
1065         {
1066           sprintf (result+n, "%%%02X", *s);
1067           n += 3;
1068         }
1069       else
1070         result[n++] = *s;
1071     }
1072   strcpy (result+n, suffix);
1073
1074   return result;
1075 }
1076
1077 /* This function creates an reader id to be used to find the same
1078    physical reader after a reset.  It returns an allocated and possibly
1079    percent escaped string or NULL if not enough memory is available. */
1080 static char *
1081 make_reader_id (libusb_device_handle *idev,
1082                 unsigned int vendor, unsigned int product,
1083                 unsigned char serialno_index)
1084 {
1085   char *rid;
1086   char prefix[20];
1087
1088   sprintf (prefix, "%04X:%04X:", (vendor & 0xffff), (product & 0xffff));
1089   rid = get_escaped_usb_string (idev, serialno_index, prefix, ":0");
1090   if (!rid)
1091     {
1092       rid = malloc (strlen (prefix) + 3 + 1);
1093       if (!rid)
1094         return NULL;
1095       strcpy (rid, prefix);
1096       strcat (rid, "X:0");
1097     }
1098   return rid;
1099 }
1100
1101
1102 /* Helper to find the endpoint from an interface descriptor.  */
1103 static int
1104 find_endpoint (const struct libusb_interface_descriptor *ifcdesc, int mode)
1105 {
1106   int no;
1107   int want_bulk_in = 0;
1108
1109   if (mode == 1)
1110     want_bulk_in = 0x80;
1111   for (no=0; no < ifcdesc->bNumEndpoints; no++)
1112     {
1113       const struct libusb_endpoint_descriptor *ep = ifcdesc->endpoint + no;
1114       if (ep->bDescriptorType != LIBUSB_DT_ENDPOINT)
1115         ;
1116       else if (mode == 2
1117                && ((ep->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK)
1118                    == LIBUSB_TRANSFER_TYPE_INTERRUPT)
1119                && (ep->bEndpointAddress & 0x80))
1120         return ep->bEndpointAddress;
1121       else if ((mode == 0 || mode == 1)
1122                && ((ep->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK)
1123                    == LIBUSB_TRANSFER_TYPE_BULK)
1124                && (ep->bEndpointAddress & 0x80) == want_bulk_in)
1125         return ep->bEndpointAddress;
1126     }
1127
1128   return -1;
1129 }
1130
1131
1132 /* Helper for scan_or_find_devices. This function returns true if a
1133    requested device has been found or the caller should stop scanning
1134    for other reasons. */
1135 static int
1136 scan_or_find_usb_device (int scan_mode,
1137                          int readerno, int *count, char **rid_list,
1138                          const char *readerid,
1139                          struct libusb_device *dev,
1140                          char **r_rid,
1141                          struct libusb_device_descriptor *desc,
1142                          libusb_device_handle **r_idev,
1143                          unsigned char **ifcdesc_extra,
1144                          size_t *ifcdesc_extra_len,
1145                          int *interface_number, int *setting_number,
1146                          int *ep_bulk_out, int *ep_bulk_in, int *ep_intr)
1147 {
1148   int ifc_no;
1149   int set_no;
1150   const struct libusb_interface_descriptor *ifcdesc;
1151   char *rid;
1152   libusb_device_handle *idev = NULL;
1153   int err;
1154   struct libusb_config_descriptor *config;
1155
1156   err = libusb_get_device_descriptor (dev, desc);
1157   if (err)
1158     return 0;
1159
1160   *r_idev = NULL;
1161
1162   err = libusb_get_active_config_descriptor (dev, &config);
1163   if (err)
1164     return 0;
1165
1166   for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
1167     for (set_no=0; set_no < config->interface[ifc_no].num_altsetting; set_no++)
1168       {
1169         ifcdesc = (config->interface[ifc_no].altsetting + set_no);
1170         /* The second condition is for older SCM SPR 532 who did
1171            not know about the assigned CCID class.  The third
1172            condition does the same for a Cherry SmartTerminal
1173            ST-2000.  Instead of trying to interpret the strings
1174            we simply check the product ID. */
1175         if (ifcdesc && ifcdesc->extra
1176             && ((ifcdesc->bInterfaceClass == 11
1177                  && ifcdesc->bInterfaceSubClass == 0
1178                  && ifcdesc->bInterfaceProtocol == 0)
1179                 || (ifcdesc->bInterfaceClass == 255
1180                     && desc->idVendor == VENDOR_SCM
1181                     && desc->idProduct == SCM_SPR532)
1182                 || (ifcdesc->bInterfaceClass == 255
1183                     && desc->idVendor == VENDOR_CHERRY
1184                     && desc->idProduct == CHERRY_ST2000)))
1185           {
1186             ++*count;
1187             if (!scan_mode && ((readerno > 0 && readerno != *count - 1)))
1188               continue;
1189
1190             err = libusb_open (dev, &idev);
1191             if (err)
1192               {
1193                 DEBUGOUT_1 ("usb_open failed: %s\n", libusb_error_name (err));
1194                 continue; /* with next setting. */
1195               }
1196
1197             rid = make_reader_id (idev, desc->idVendor, desc->idProduct,
1198                                   desc->iSerialNumber);
1199             if (!rid)
1200               {
1201                 libusb_free_config_descriptor (config);
1202                 return 0;
1203               }
1204
1205             if (!scan_mode && readerno == -1 && readerid
1206                 && strncmp (rid, readerid, strlen (readerid)))
1207               continue;
1208
1209             if (scan_mode)
1210               {
1211                 char *p;
1212
1213                 /* We are collecting infos about all
1214                    available CCID readers.  Store them and
1215                    continue. */
1216                 DEBUGOUT_2 ("found CCID reader %d (ID=%s)\n", *count, rid);
1217                 p = malloc ((*rid_list? strlen (*rid_list):0) + 1
1218                             + strlen (rid) + 1);
1219                 if (p)
1220                   {
1221                     *p = 0;
1222                     if (*rid_list)
1223                       {
1224                         strcat (p, *rid_list);
1225                         free (*rid_list);
1226                       }
1227                     strcat (p, rid);
1228                     strcat (p, "\n");
1229                     *rid_list = p;
1230                   }
1231                 else /* Out of memory. */
1232                   {
1233                     libusb_free_config_descriptor (config);
1234                     free (rid);
1235                     return 0;
1236                   }
1237               }
1238             else
1239               {
1240                 /* We found the requested reader. */
1241                 if (ifcdesc_extra && ifcdesc_extra_len)
1242                   {
1243                     *ifcdesc_extra = malloc (ifcdesc->extra_length);
1244                     if (!*ifcdesc_extra)
1245                       {
1246                         libusb_close (idev);
1247                         free (rid);
1248                         libusb_free_config_descriptor (config);
1249                         return 1; /* Out of core. */
1250                       }
1251                     memcpy (*ifcdesc_extra, ifcdesc->extra,
1252                             ifcdesc->extra_length);
1253                     *ifcdesc_extra_len = ifcdesc->extra_length;
1254                   }
1255
1256                 if (interface_number)
1257                   *interface_number = ifc_no;
1258
1259                 if (setting_number)
1260                   *setting_number = set_no;
1261
1262                 if (ep_bulk_out)
1263                   *ep_bulk_out = find_endpoint (ifcdesc, 0);
1264                 if (ep_bulk_in)
1265                   *ep_bulk_in = find_endpoint (ifcdesc, 1);
1266                 if (ep_intr)
1267                   *ep_intr = find_endpoint (ifcdesc, 2);
1268
1269                 if (r_rid)
1270                   {
1271                     *r_rid = rid;
1272                     rid = NULL;
1273                   }
1274                 else
1275                   free (rid);
1276
1277                 *r_idev = idev;
1278                 libusb_free_config_descriptor (config);
1279                 return 1; /* Found requested device. */
1280               }
1281
1282             free (rid);
1283             libusb_close (idev);
1284             idev = NULL;
1285           }
1286       }
1287
1288   libusb_free_config_descriptor (config);
1289
1290   return 0;
1291 }
1292
1293 /* Combination function to either scan all CCID devices or to find and
1294    open one specific device.
1295
1296    The function returns 0 if a reader has been found or when a scan
1297    returned without error.
1298
1299    With READERNO = -1 and READERID is NULL, scan mode is used and
1300    R_RID should be the address where to store the list of reader_ids
1301    we found.  If on return this list is empty, no CCID device has been
1302    found; otherwise it points to an allocated linked list of reader
1303    IDs.  Note that in this mode the function always returns NULL.
1304
1305    With READERNO >= 0 or READERID is not NULL find mode is used.  This
1306    uses the same algorithm as the scan mode but stops and returns at
1307    the entry number READERNO and return the handle for the opened
1308    USB device. If R_RID is not NULL it will receive the reader ID of
1309    that device.  If R_DEV is not NULL it will the device pointer of
1310    that device.  If IFCDESC_EXTRA is NOT NULL it will receive a
1311    malloced copy of the interfaces "extra: data filed;
1312    IFCDESC_EXTRA_LEN receive the length of this field.  If there is
1313    no reader with number READERNO or that reader is not usable by our
1314    implementation NULL will be returned.  The caller must close a
1315    returned USB device handle and free (if not passed as NULL) the
1316    returned reader ID info as well as the IFCDESC_EXTRA.  On error
1317    NULL will get stored at R_RID, R_DEV, IFCDESC_EXTRA and
1318    IFCDESC_EXTRA_LEN.  With READERID being -1 the function stops if
1319    the READERID was found.
1320
1321    If R_FD is not -1 on return the device is not using USB for
1322    transport but the device associated with that file descriptor.  In
1323    this case INTERFACE will receive the transport type and the other
1324    USB specific return values are not used; the return value is
1325    (void*)(1).
1326
1327    Note that the first entry of the returned reader ID list in scan mode
1328    corresponds with a READERNO of 0 in find mode.
1329 */
1330 static int
1331 scan_or_find_devices (int readerno, const char *readerid,
1332                       char **r_rid,
1333                       struct libusb_device_descriptor *r_desc,
1334                       unsigned char **ifcdesc_extra,
1335                       size_t *ifcdesc_extra_len,
1336                       int *interface_number, int *setting_number,
1337                       int *ep_bulk_out, int *ep_bulk_in, int *ep_intr,
1338                       libusb_device_handle **r_idev,
1339                       int *r_fd)
1340 {
1341   char *rid_list = NULL;
1342   int count = 0;
1343   libusb_device **dev_list = NULL;
1344   libusb_device *dev;
1345   libusb_device_handle *idev = NULL;
1346   int scan_mode = (readerno == -1 && !readerid);
1347   int i;
1348   ssize_t n;
1349   struct libusb_device_descriptor desc;
1350
1351   /* Set return values to a default. */
1352   if (r_rid)
1353     *r_rid = NULL;
1354   if (ifcdesc_extra)
1355     *ifcdesc_extra = NULL;
1356   if (ifcdesc_extra_len)
1357     *ifcdesc_extra_len = 0;
1358   if (interface_number)
1359     *interface_number = 0;
1360   if (setting_number)
1361     *setting_number = 0;
1362   if (r_idev)
1363     *r_idev = NULL;
1364   if (r_fd)
1365     *r_fd = -1;
1366
1367   /* See whether we want scan or find mode. */
1368   if (scan_mode)
1369     {
1370       assert (r_rid);
1371     }
1372
1373   n = libusb_get_device_list (NULL, &dev_list);
1374
1375   for (i = 0; i < n; i++)
1376     {
1377       dev = dev_list[i];
1378       if (scan_or_find_usb_device (scan_mode, readerno, &count, &rid_list,
1379                                    readerid,
1380                                    dev,
1381                                    r_rid,
1382                                    &desc,
1383                                    &idev,
1384                                    ifcdesc_extra,
1385                                    ifcdesc_extra_len,
1386                                    interface_number, setting_number,
1387                                    ep_bulk_out, ep_bulk_in, ep_intr))
1388         {
1389           libusb_free_device_list (dev_list, 1);
1390           /* Found requested device or out of core. */
1391           if (!idev)
1392             {
1393               free (rid_list);
1394               return -1; /* error */
1395             }
1396           *r_idev = idev;
1397           if (r_desc)
1398             memcpy (r_desc, &desc, sizeof (struct libusb_device_descriptor));
1399           return 0;
1400         }
1401     }
1402
1403   libusb_free_device_list (dev_list, 1);
1404
1405   /* Now check whether there are any devices with special transport types. */
1406   for (i=0; transports[i].name; i++)
1407     {
1408       int fd;
1409       char *rid, *p;
1410
1411       fd = open (transports[i].name, O_RDWR);
1412       if (fd == -1 && scan_mode && errno == EBUSY)
1413         {
1414           /* Ignore this error in scan mode because it indicates that
1415              the device exists but is already open (most likely by us)
1416              and thus in general suitable as a reader.  */
1417         }
1418       else if (fd == -1)
1419         {
1420           DEBUGOUT_2 ("failed to open '%s': %s\n",
1421                      transports[i].name, strerror (errno));
1422           continue;
1423         }
1424
1425       rid = malloc (strlen (transports[i].name) + 30 + 10);
1426       if (!rid)
1427         {
1428           if (fd != -1)
1429             close (fd);
1430           free (rid_list);
1431           return -1; /* Error. */
1432         }
1433       sprintf (rid, "0000:%04X:%s:0", transports[i].type, transports[i].name);
1434       if (scan_mode)
1435         {
1436           DEBUGOUT_2 ("found CCID reader %d (ID=%s)\n", count, rid);
1437           p = malloc ((rid_list? strlen (rid_list):0) + 1 + strlen (rid) + 1);
1438           if (!p)
1439             {
1440               if (fd != -1)
1441                 close (fd);
1442               free (rid_list);
1443               free (rid);
1444               return -1; /* Error. */
1445             }
1446           *p = 0;
1447           if (rid_list)
1448             {
1449               strcat (p, rid_list);
1450               free (rid_list);
1451             }
1452           strcat (p, rid);
1453           strcat (p, "\n");
1454           rid_list = p;
1455           ++count;
1456         }
1457       else if (!readerno ||
1458                (readerno < 0 && readerid && !strcmp (readerid, rid)))
1459         {
1460           /* Found requested device. */
1461           if (interface_number)
1462             *interface_number = transports[i].type;
1463           if (r_rid)
1464             *r_rid = rid;
1465           else
1466             free (rid);
1467           if (r_fd)
1468             *r_fd = fd;
1469           return 0; /* Okay, found device */
1470         }
1471       else /* This is not yet the reader we want. */
1472         {
1473           if (readerno >= 0)
1474             --readerno;
1475         }
1476       free (rid);
1477       if (fd != -1)
1478         close (fd);
1479     }
1480
1481   if (scan_mode)
1482     {
1483       *r_rid = rid_list;
1484       return 0;
1485     }
1486   else
1487     return -1;
1488 }
1489
1490
1491 /* Set the level of debugging to LEVEL and return the old level.  -1
1492    just returns the old level.  A level of 0 disables debugging, 1
1493    enables debugging, 2 enables additional tracing of the T=1
1494    protocol, 3 additionally enables debugging for GetSlotStatus, other
1495    values are not yet defined.
1496
1497    Note that libusb may provide its own debugging feature which is
1498    enabled by setting the envvar USB_DEBUG.  */
1499 int
1500 ccid_set_debug_level (int level)
1501 {
1502   int old = debug_level;
1503   if (level != -1)
1504     debug_level = level;
1505   return old;
1506 }
1507
1508
1509 char *
1510 ccid_get_reader_list (void)
1511 {
1512   char *reader_list;
1513
1514   if (!initialized_usb)
1515     {
1516       libusb_init (NULL);
1517       initialized_usb = 1;
1518     }
1519
1520   if (scan_or_find_devices (-1, NULL, &reader_list, NULL, NULL, NULL, NULL,
1521                             NULL, NULL, NULL, NULL, NULL, NULL))
1522     return NULL; /* Error. */
1523   return reader_list;
1524 }
1525
1526
1527 /* Vendor specific custom initialization.  */
1528 static int
1529 ccid_vendor_specific_init (ccid_driver_t handle)
1530 {
1531   if (handle->id_vendor == VENDOR_VEGA && handle->id_product == VEGA_ALPHA)
1532     {
1533       int r;
1534       /*
1535        * Vega alpha has a feature to show retry counter on the pinpad
1536        * display.  But it assumes that the card returns the value of
1537        * retry counter by VERIFY with empty data (return code of
1538        * 63Cx).  Unfortunately, existing OpenPGP cards don't support
1539        * VERIFY command with empty data.  This vendor specific command
1540        * sequence is to disable the feature.
1541        */
1542       const unsigned char cmd[] = { '\xb5', '\x01', '\x00', '\x03', '\x00' };
1543
1544       r = send_escape_cmd (handle, cmd, sizeof (cmd), NULL, 0, NULL);
1545       if (r != 0 && r != CCID_DRIVER_ERR_CARD_INACTIVE
1546           && r != CCID_DRIVER_ERR_NO_CARD)
1547         return r;
1548     }
1549
1550   return 0;
1551 }
1552
1553
1554 #define MAX_DEVICE 4 /* See MAX_READER in apdu.c.  */
1555
1556 struct ccid_dev_table {
1557   int n;                        /* Index to ccid_usb_dev_list */
1558   int transport;
1559   int interface_number;
1560   int setting_number;
1561   unsigned char *ifcdesc_extra;
1562   int ep_bulk_out;
1563   int ep_bulk_in;
1564   int ep_intr;
1565   size_t ifcdesc_extra_len;
1566 };
1567
1568 static libusb_device **ccid_usb_dev_list;
1569 static struct ccid_dev_table ccid_dev_table[MAX_DEVICE];
1570
1571 gpg_error_t
1572 ccid_dev_scan (int *idx_max_p, struct ccid_dev_table **t_p)
1573 {
1574   ssize_t n;
1575   libusb_device *dev;
1576   int i;
1577   int ifc_no;
1578   int set_no;
1579   int idx = 0;
1580   int err = 0;
1581
1582   if (!initialized_usb)
1583     {
1584       libusb_init (NULL);
1585       initialized_usb = 1;
1586     }
1587
1588   n = libusb_get_device_list (NULL, &ccid_usb_dev_list);
1589   for (i = 0; i < n; i++)
1590     {
1591       struct libusb_config_descriptor *config;
1592       struct libusb_device_descriptor desc;
1593
1594       dev = ccid_usb_dev_list[i];
1595
1596       if (libusb_get_device_descriptor (dev, &desc))
1597         continue;
1598
1599       if (libusb_get_active_config_descriptor (dev, &config))
1600         continue;
1601
1602       for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
1603         for (set_no=0; set_no < config->interface[ifc_no].num_altsetting;
1604              set_no++)
1605           {
1606             const struct libusb_interface_descriptor *ifcdesc;
1607
1608             ifcdesc = &config->interface[ifc_no].altsetting[set_no];
1609             /* The second condition is for older SCM SPR 532 who did
1610                not know about the assigned CCID class.  The third
1611                condition does the same for a Cherry SmartTerminal
1612                ST-2000.  Instead of trying to interpret the strings
1613                we simply check the product ID. */
1614             if (ifcdesc && ifcdesc->extra
1615                 && ((ifcdesc->bInterfaceClass == 11
1616                      && ifcdesc->bInterfaceSubClass == 0
1617                      && ifcdesc->bInterfaceProtocol == 0)
1618                     || (ifcdesc->bInterfaceClass == 255
1619                         && desc.idVendor == VENDOR_SCM
1620                         && desc.idProduct == SCM_SPR532)
1621                     || (ifcdesc->bInterfaceClass == 255
1622                         && desc.idVendor == VENDOR_CHERRY
1623                         && desc.idProduct == CHERRY_ST2000)))
1624               {
1625                 /* Found a reader.  */
1626                 unsigned char *ifcdesc_extra;
1627
1628                 ifcdesc_extra = malloc (ifcdesc->extra_length);
1629                 if (!ifcdesc_extra)
1630                   {
1631                     err = gpg_error_from_syserror ();
1632                     libusb_free_config_descriptor (config);
1633                     goto scan_finish;
1634                   }
1635                 memcpy (ifcdesc_extra, ifcdesc->extra, ifcdesc->extra_length);
1636
1637                 ccid_dev_table[idx].transport = TRANSPORT_USB;
1638                 ccid_dev_table[idx].n = i;
1639                 ccid_dev_table[idx].interface_number = ifc_no;
1640                 ccid_dev_table[idx].setting_number = set_no;
1641                 ccid_dev_table[idx].ifcdesc_extra = ifcdesc_extra;
1642                 ccid_dev_table[idx].ifcdesc_extra_len = ifcdesc->extra_length;
1643                 ccid_dev_table[idx].ep_bulk_out = find_endpoint (ifcdesc, 0);
1644                 ccid_dev_table[idx].ep_bulk_in = find_endpoint (ifcdesc, 1);
1645                 ccid_dev_table[idx].ep_intr = find_endpoint (ifcdesc, 2);
1646
1647                 idx++;
1648                 if (idx >= MAX_DEVICE)
1649                   {
1650                     libusb_free_config_descriptor (config);
1651                     err = 0;
1652                     goto scan_finish;
1653                   }
1654               }
1655           }
1656
1657       libusb_free_config_descriptor (config);
1658     }
1659
1660   /* Now check whether there are any devices with special transport types. */
1661   for (i=0; transports[i].name; i++)
1662     {
1663       if (access (transports[i].name, (R_OK|W_OK)) == 0)
1664         {
1665           /* Found a device. */
1666           DEBUGOUT_1 ("Found CCID reader %d\n", idx);
1667
1668           ccid_dev_table[idx].transport = TRANSPORT_CM4040;
1669           ccid_dev_table[idx].n = i;
1670           ccid_dev_table[idx].interface_number = 0;
1671           ccid_dev_table[idx].setting_number = 0;
1672           ccid_dev_table[idx].ifcdesc_extra = NULL;
1673           ccid_dev_table[idx].ifcdesc_extra_len = 0;
1674           ccid_dev_table[idx].ep_bulk_out = 0;
1675           ccid_dev_table[idx].ep_bulk_in = 0;
1676           ccid_dev_table[idx].ep_intr = 0;
1677
1678           idx++;
1679           if (idx >= MAX_DEVICE)
1680             goto scan_finish;
1681         }
1682     }
1683
1684  scan_finish:
1685
1686   if (err)
1687     {
1688       *idx_max_p = 0;
1689       *t_p = NULL;
1690       for (i = 0; i < idx; i++)
1691         {
1692           free (ccid_dev_table[idx].ifcdesc_extra);
1693           ccid_dev_table[idx].transport = 0;
1694           ccid_dev_table[idx].n = 0;
1695           ccid_dev_table[idx].interface_number = 0;
1696           ccid_dev_table[idx].setting_number = 0;
1697           ccid_dev_table[idx].ifcdesc_extra = NULL;
1698           ccid_dev_table[idx].ifcdesc_extra_len = 0;
1699           ccid_dev_table[idx].ep_bulk_out = 0;
1700           ccid_dev_table[idx].ep_bulk_in = 0;
1701           ccid_dev_table[idx].ep_intr = 0;
1702         }
1703       libusb_free_device_list (ccid_usb_dev_list, 1);
1704       ccid_usb_dev_list = NULL;
1705     }
1706   else
1707     {
1708       *idx_max_p = idx;
1709       if (idx)
1710         *t_p = ccid_dev_table;
1711       else
1712         *t_p = NULL;
1713     }
1714
1715   return err;
1716 }
1717
1718 void
1719 ccid_dev_scan_finish (struct ccid_dev_table *tbl, int max)
1720 {
1721   int i;
1722
1723   for (i = 0; i < max; i++)
1724     {
1725       free (tbl[i].ifcdesc_extra);
1726       tbl[i].transport = 0;
1727       tbl[i].n = 0;
1728       tbl[i].interface_number = 0;
1729       tbl[i].setting_number = 0;
1730       tbl[i].ifcdesc_extra = NULL;
1731       tbl[i].ifcdesc_extra_len = 0;
1732       tbl[i].ep_bulk_out = 0;
1733       tbl[i].ep_bulk_in = 0;
1734       tbl[i].ep_intr = 0;
1735     }
1736   libusb_free_device_list (ccid_usb_dev_list, 1);
1737   ccid_usb_dev_list = NULL;
1738 }
1739
1740 unsigned int
1741 ccid_get_BAI (int idx, struct ccid_dev_table *tbl)
1742 {
1743   int n;
1744   int bus, addr, intf;
1745   unsigned int bai;
1746
1747   if (tbl[idx].transport == TRANSPORT_USB)
1748     {
1749       libusb_device *dev;
1750
1751       n = tbl[idx].n;
1752       dev = ccid_usb_dev_list[n];
1753
1754       bus = libusb_get_bus_number (dev);
1755       addr = libusb_get_device_address (dev);
1756       intf = tbl[idx].interface_number;
1757       bai = (bus << 16) | (addr << 8) | intf;
1758     }
1759   else
1760     {
1761       n = tbl[idx].n;
1762       bai = 0xFFFF0000 | n;
1763     }
1764
1765   return bai;
1766 }
1767
1768 int
1769 ccid_compare_BAI (ccid_driver_t handle, unsigned int bai)
1770 {
1771   return handle->bai == bai;
1772 }
1773
1774
1775 static void
1776 intr_cb (struct libusb_transfer *transfer)
1777 {
1778   ccid_driver_t handle = transfer->user_data;
1779
1780   DEBUGOUT_1 ("CCID: interrupt callback %d\n", transfer->status);
1781
1782   if (transfer->status == LIBUSB_TRANSFER_TIMED_OUT)
1783     {
1784       int err;
1785
1786     submit_again:
1787       /* Submit the URB again to keep watching the INTERRUPT transfer.  */
1788       err = libusb_submit_transfer (transfer);
1789       if (err == LIBUSB_ERROR_NO_DEVICE)
1790         goto device_removed;
1791
1792       DEBUGOUT_1 ("CCID submit transfer again %d\n", err);
1793     }
1794   else if (transfer->status == LIBUSB_TRANSFER_COMPLETED)
1795     {
1796       if (transfer->actual_length == 2
1797           && transfer->buffer[0] == 0x50
1798           && (transfer->buffer[1] & 1) == 0)
1799         {
1800           DEBUGOUT ("CCID: card removed\n");
1801           handle->powered_off = 1;
1802         }
1803       else
1804         {
1805           /* Event other than card removal.  */
1806           goto submit_again;
1807         }
1808     }
1809   else if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
1810     handle->powered_off = 1;
1811   else
1812     {
1813     device_removed:
1814       DEBUGOUT ("CCID: device removed\n");
1815       handle->powered_off = 1;
1816     }
1817
1818   scd_kick_the_loop ();
1819 }
1820
1821 static void
1822 ccid_setup_intr  (ccid_driver_t handle)
1823 {
1824   struct libusb_transfer *transfer;
1825   int err;
1826
1827   transfer = libusb_alloc_transfer (0);
1828   handle->transfer = transfer;
1829   libusb_fill_interrupt_transfer (transfer, handle->idev, handle->ep_intr,
1830                                   handle->intr_buf, sizeof (handle->intr_buf),
1831                                   intr_cb, handle, 0);
1832   err = libusb_submit_transfer (transfer);
1833   DEBUGOUT_2 ("CCID submit transfer (%x): %d", handle->ep_intr, err);
1834 }
1835
1836
1837 static void *
1838 ccid_usb_thread (void *arg)
1839 {
1840   libusb_context *ctx = arg;
1841
1842   while (ccid_usb_thread_is_alive)
1843     {
1844 #ifdef USE_NPTH
1845       npth_unprotect ();
1846 #endif
1847       libusb_handle_events_completed (ctx, NULL);
1848 #ifdef USE_NPTH
1849       npth_protect ();
1850 #endif
1851     }
1852
1853   return NULL;
1854 }
1855
1856
1857 static int
1858 ccid_open_usb_reader (const char *spec_reader_name,
1859                       int idx, struct ccid_dev_table *ccid_table,
1860                       ccid_driver_t *handle, char **rdrname_p)
1861 {
1862   libusb_device *dev;
1863   libusb_device_handle *idev = NULL;
1864   char *rid = NULL;
1865   int rc = 0;
1866   int ifc_no, set_no;
1867   struct libusb_device_descriptor desc;
1868   int n;
1869   int bus, addr;
1870   unsigned int bai;
1871
1872   n = ccid_table[idx].n;
1873   ifc_no = ccid_table[idx].interface_number;
1874   set_no = ccid_table[idx].setting_number;
1875
1876   dev = ccid_usb_dev_list[n];
1877   bus = libusb_get_bus_number (dev);
1878   addr = libusb_get_device_address (dev);
1879   bai = (bus << 16) | (addr << 8) | ifc_no;
1880
1881   rc = libusb_open (dev, &idev);
1882   if (rc)
1883     {
1884       DEBUGOUT_1 ("usb_open failed: %s\n", libusb_error_name (rc));
1885       free (*handle);
1886       *handle = NULL;
1887       return rc;
1888     }
1889
1890   if (ccid_usb_thread_is_alive++ == 0)
1891     {
1892       npth_t thread;
1893       npth_attr_t tattr;
1894       int err;
1895
1896       err = npth_attr_init (&tattr);
1897       if (err)
1898         {
1899           DEBUGOUT_1 ("npth_attr_init failed: %s\n", strerror (err));
1900           free (*handle);
1901           *handle = NULL;
1902           return err;
1903         }
1904
1905       npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1906       err = npth_create (&thread, &tattr, ccid_usb_thread, NULL);
1907       if (err)
1908         {
1909           DEBUGOUT_1 ("npth_create failed: %s\n", strerror (err));
1910           free (*handle);
1911           *handle = NULL;
1912           return err;
1913         }
1914
1915       npth_attr_destroy (&tattr);
1916     }
1917
1918   rc = libusb_get_device_descriptor (dev, &desc);
1919   if (rc)
1920     {
1921       DEBUGOUT ("get_device_descripor failed\n");
1922       goto leave;
1923     }
1924
1925   rid = make_reader_id (idev, desc.idVendor, desc.idProduct,
1926                         desc.iSerialNumber);
1927
1928   /* Check to see if reader name matches the spec.  */
1929   if (spec_reader_name
1930       && strncmp (rid, spec_reader_name, strlen (spec_reader_name)))
1931     {
1932       DEBUGOUT ("device not matched\n");
1933       rc = CCID_DRIVER_ERR_NO_READER;
1934       goto leave;
1935     }
1936
1937   (*handle)->id_vendor = desc.idVendor;
1938   (*handle)->id_product = desc.idProduct;
1939   (*handle)->idev = idev;
1940   (*handle)->dev_fd = -1;
1941   (*handle)->bai = bai;
1942   (*handle)->ifc_no = ifc_no;
1943   (*handle)->ep_bulk_out = ccid_table[idx].ep_bulk_out;
1944   (*handle)->ep_bulk_in = ccid_table[idx].ep_bulk_in;
1945   (*handle)->ep_intr = ccid_table[idx].ep_intr;
1946
1947   DEBUGOUT_2 ("using CCID reader %d (ID=%s)\n", idx, rid);
1948
1949   if (parse_ccid_descriptor (*handle, desc.bcdDevice,
1950                              ccid_table[idx].ifcdesc_extra,
1951                              ccid_table[idx].ifcdesc_extra_len))
1952     {
1953       DEBUGOUT ("device not supported\n");
1954       rc = CCID_DRIVER_ERR_NO_READER;
1955       goto leave;
1956     }
1957
1958   rc = libusb_claim_interface (idev, ifc_no);
1959   if (rc)
1960     {
1961       DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
1962       rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1963       goto leave;
1964     }
1965
1966   if (set_no != 0)
1967     {
1968       rc = libusb_set_interface_alt_setting (idev, ifc_no, set_no);
1969       if (rc)
1970         {
1971           DEBUGOUT_1 ("usb_set_interface_alt_setting failed: %d\n", rc);
1972           rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1973           goto leave;
1974         }
1975     }
1976
1977   if ((*handle)->ep_intr >= 0)
1978     ccid_setup_intr (*handle);
1979
1980   rc = ccid_vendor_specific_init (*handle);
1981
1982  leave:
1983   if (rc)
1984     {
1985       --ccid_usb_thread_is_alive;
1986       free (rid);
1987       libusb_close (idev);
1988       free (*handle);
1989       *handle = NULL;
1990     }
1991   else
1992     {
1993       if (rdrname_p)
1994         *rdrname_p = rid;
1995       else
1996         free (rid);
1997     }
1998
1999   return rc;
2000 }
2001
2002 /* Open the reader with the internal number READERNO and return a
2003    pointer to be used as handle in HANDLE.  Returns 0 on success. */
2004 int
2005 ccid_open_reader (const char *spec_reader_name, int idx,
2006                   struct ccid_dev_table *ccid_table,
2007                   ccid_driver_t *handle, char **rdrname_p)
2008 {
2009   int n;
2010   int fd;
2011   char *rid;
2012
2013   *handle = calloc (1, sizeof **handle);
2014   if (!*handle)
2015     {
2016       DEBUGOUT ("out of memory\n");
2017       return CCID_DRIVER_ERR_OUT_OF_CORE;
2018     }
2019
2020   if (ccid_table[idx].transport == TRANSPORT_USB)
2021     return ccid_open_usb_reader (spec_reader_name, idx, ccid_table,
2022                                  handle, rdrname_p);
2023
2024   /* Special transport support.  */
2025
2026   n = ccid_table[idx].n;
2027   fd = open (transports[n].name, O_RDWR);
2028   if (fd < 0)
2029     {
2030       DEBUGOUT_2 ("failed to open '%s': %s\n",
2031                   transports[n].name, strerror (errno));
2032       free (*handle);
2033       *handle = NULL;
2034       return -1;
2035     }
2036
2037   rid = malloc (strlen (transports[n].name) + 30 + 10);
2038   if (!rid)
2039     {
2040       close (fd);
2041       free (*handle);
2042       *handle = NULL;
2043       return -1; /* Error. */
2044     }
2045
2046   sprintf (rid, "0000:%04X:%s:0", transports[n].type, transports[n].name);
2047
2048   /* Check to see if reader name matches the spec.  */
2049   if (spec_reader_name
2050       && strncmp (rid, spec_reader_name, strlen (spec_reader_name)))
2051     {
2052       DEBUGOUT ("device not matched\n");
2053       free (rid);
2054       close (fd);
2055       free (*handle);
2056       *handle = NULL;
2057       return -1;
2058     }
2059
2060   (*handle)->id_vendor = 0;
2061   (*handle)->id_product = transports[n].type;
2062   (*handle)->idev = NULL;
2063   (*handle)->dev_fd = fd;
2064   (*handle)->bai = 0xFFFF0000 | n;
2065   prepare_special_transport (*handle);
2066   if (rdrname_p)
2067     *rdrname_p = rid;
2068   else
2069     free (rid);
2070
2071   return 0;
2072 }
2073
2074
2075 int
2076 ccid_require_get_status (ccid_driver_t handle)
2077 {
2078   /* When a card reader supports interrupt transfer to check the
2079      status of card, it is possible to submit only an interrupt
2080      transfer, and no check is required by application layer.  USB can
2081      detect removal of a card and can detect removal of a reader.
2082   */
2083   if (handle->ep_intr >= 0)
2084     return 0;
2085
2086   /* Libusb actually detects the removal of USB device in use.
2087      However, there is no good API to handle the removal (yet),
2088      cleanly and with good portability.
2089
2090      There is libusb_set_pollfd_notifiers function, but it doesn't
2091      offer libusb_device_handle* data to its callback.  So, when it
2092      watches multiple devices, there is no way to know which device is
2093      removed.
2094
2095      Once, we will have a good programming interface of libusb, we can
2096      list tokens (with no interrupt transfer support, but always with
2097      card inserted) here to return 0, so that scdaemon can submit
2098      minimum packet on wire.
2099   */
2100   return 1;
2101 }
2102
2103
2104 static void
2105 do_close_reader (ccid_driver_t handle)
2106 {
2107   int rc;
2108   unsigned char msg[100];
2109   size_t msglen;
2110   unsigned char seqno;
2111
2112   if (!handle->powered_off)
2113     {
2114       msg[0] = PC_to_RDR_IccPowerOff;
2115       msg[5] = 0; /* slot */
2116       msg[6] = seqno = handle->seqno++;
2117       msg[7] = 0; /* RFU */
2118       msg[8] = 0; /* RFU */
2119       msg[9] = 0; /* RFU */
2120       set_msg_len (msg, 0);
2121       msglen = 10;
2122
2123       rc = bulk_out (handle, msg, msglen, 0);
2124       if (!rc)
2125         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
2126                  seqno, 2000, 0);
2127     }
2128   if (handle->idev)
2129     {
2130       if (handle->transfer)
2131         {
2132           if (!handle->powered_off)
2133             {
2134               DEBUGOUT ("libusb_cancel_transfer\n");
2135
2136               rc = libusb_cancel_transfer (handle->transfer);
2137               if (rc != LIBUSB_ERROR_NOT_FOUND)
2138                 while (!handle->powered_off)
2139                   {
2140                     DEBUGOUT ("libusb_handle_events_completed\n");
2141 #ifdef USE_NPTH
2142                     npth_unprotect ();
2143 #endif
2144                     libusb_handle_events_completed (NULL, &handle->powered_off);
2145 #ifdef USE_NPTH
2146                     npth_protect ();
2147 #endif
2148                   }
2149             }
2150
2151           libusb_free_transfer (handle->transfer);
2152         }
2153       libusb_release_interface (handle->idev, handle->ifc_no);
2154       --ccid_usb_thread_is_alive;
2155       libusb_close (handle->idev);
2156       handle->idev = NULL;
2157     }
2158   if (handle->dev_fd != -1)
2159     {
2160       close (handle->dev_fd);
2161       handle->dev_fd = -1;
2162     }
2163 }
2164
2165
2166 int
2167 ccid_set_progress_cb (ccid_driver_t handle,
2168                       void (*cb)(void *, const char *, int, int, int),
2169                       void *cb_arg)
2170 {
2171   if (!handle)
2172     return CCID_DRIVER_ERR_INV_VALUE;
2173
2174   handle->progress_cb = cb;
2175   handle->progress_cb_arg = cb_arg;
2176   return 0;
2177 }
2178
2179
2180 /* Close the reader HANDLE. */
2181 int
2182 ccid_close_reader (ccid_driver_t handle)
2183 {
2184   if (!handle || (!handle->idev && handle->dev_fd == -1))
2185     return 0;
2186
2187   do_close_reader (handle);
2188   free (handle);
2189   return 0;
2190 }
2191
2192
2193 /* Return False if a card is present and powered. */
2194 int
2195 ccid_check_card_presence (ccid_driver_t handle)
2196 {
2197   (void)handle;  /* Not yet implemented.  */
2198   return -1;
2199 }
2200
2201
2202 /* Write NBYTES of BUF to file descriptor FD. */
2203 static int
2204 writen (int fd, const void *buf, size_t nbytes)
2205 {
2206   size_t nleft = nbytes;
2207   int nwritten;
2208
2209   while (nleft > 0)
2210     {
2211       nwritten = write (fd, buf, nleft);
2212       if (nwritten < 0)
2213         {
2214           if (errno == EINTR)
2215             nwritten = 0;
2216           else
2217             return -1;
2218         }
2219       nleft -= nwritten;
2220       buf = (const char*)buf + nwritten;
2221     }
2222
2223   return 0;
2224 }
2225
2226
2227 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
2228    Returns 0 on success. */
2229 static int
2230 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen,
2231           int no_debug)
2232 {
2233   int rc;
2234
2235   /* No need to continue and clutter the log with USB write error
2236      messages after we got the first ENODEV.  */
2237   if (handle->enodev_seen)
2238     return CCID_DRIVER_ERR_NO_READER;
2239
2240   if (debug_level && (!no_debug || debug_level >= 3))
2241     {
2242       switch (msglen? msg[0]:0)
2243         {
2244         case PC_to_RDR_IccPowerOn:
2245           print_p2r_iccpoweron (msg, msglen);
2246           break;
2247         case PC_to_RDR_IccPowerOff:
2248           print_p2r_iccpoweroff (msg, msglen);
2249           break;
2250         case PC_to_RDR_GetSlotStatus:
2251           print_p2r_getslotstatus (msg, msglen);
2252           break;
2253         case PC_to_RDR_XfrBlock:
2254           print_p2r_xfrblock (msg, msglen);
2255           break;
2256         case PC_to_RDR_GetParameters:
2257           print_p2r_getparameters (msg, msglen);
2258           break;
2259         case PC_to_RDR_ResetParameters:
2260           print_p2r_resetparameters (msg, msglen);
2261           break;
2262         case PC_to_RDR_SetParameters:
2263           print_p2r_setparameters (msg, msglen);
2264           break;
2265         case PC_to_RDR_Escape:
2266           print_p2r_escape (msg, msglen);
2267           break;
2268         case PC_to_RDR_IccClock:
2269           print_p2r_iccclock (msg, msglen);
2270           break;
2271         case PC_to_RDR_T0APDU:
2272           print_p2r_to0apdu (msg, msglen);
2273           break;
2274         case PC_to_RDR_Secure:
2275           print_p2r_secure (msg, msglen);
2276           break;
2277         case PC_to_RDR_Mechanical:
2278           print_p2r_mechanical (msg, msglen);
2279           break;
2280         case PC_to_RDR_Abort:
2281           print_p2r_abort (msg, msglen);
2282           break;
2283         case PC_to_RDR_SetDataRate:
2284           print_p2r_setdatarate (msg, msglen);
2285           break;
2286         default:
2287           print_p2r_unknown (msg, msglen);
2288           break;
2289         }
2290     }
2291
2292   if (handle->idev)
2293     {
2294       int transferred;
2295
2296 #ifdef USE_NPTH
2297       npth_unprotect ();
2298 #endif
2299       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
2300                                  (char*)msg, msglen, &transferred,
2301                                  5000 /* ms timeout */);
2302 #ifdef USE_NPTH
2303       npth_protect ();
2304 #endif
2305       if (rc == 0 && transferred == msglen)
2306         return 0;
2307
2308       if (rc)
2309         {
2310           DEBUGOUT_1 ("usb_bulk_write error: %s\n", libusb_error_name (rc));
2311           if (rc == LIBUSB_ERROR_NO_DEVICE)
2312             {
2313               handle->enodev_seen = 1;
2314               return CCID_DRIVER_ERR_NO_READER;
2315             }
2316         }
2317     }
2318   else
2319     {
2320       rc = writen (handle->dev_fd, msg, msglen);
2321       if (!rc)
2322         return 0;
2323       DEBUGOUT_2 ("writen to %d failed: %s\n",
2324                   handle->dev_fd, strerror (errno));
2325
2326     }
2327   return CCID_DRIVER_ERR_CARD_IO_ERROR;
2328 }
2329
2330
2331 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
2332    BUFFER and return the actual read number if bytes in NREAD. SEQNO
2333    is the sequence number used to send the request and EXPECTED_TYPE
2334    the type of message we expect. Does checks on the ccid
2335    header. TIMEOUT is the timeout value in ms. NO_DEBUG may be set to
2336    avoid debug messages in case of no error; this can be overriden
2337    with a glibal debug level of at least 3. Returns 0 on success. */
2338 static int
2339 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
2340          size_t *nread, int expected_type, int seqno, int timeout,
2341          int no_debug)
2342 {
2343   int rc;
2344   int msglen;
2345   int eagain_retries = 0;
2346
2347   /* Fixme: The next line for the current Valgrind without support
2348      for USB IOCTLs. */
2349   memset (buffer, 0, length);
2350  retry:
2351   if (handle->idev)
2352     {
2353 #ifdef USE_NPTH
2354       npth_unprotect ();
2355 #endif
2356       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
2357                                  (char*)buffer, length, &msglen, timeout);
2358 #ifdef USE_NPTH
2359       npth_protect ();
2360 #endif
2361       if (rc)
2362         {
2363           DEBUGOUT_1 ("usb_bulk_read error: %s\n", libusb_error_name (rc));
2364           if (rc == LIBUSB_ERROR_NO_DEVICE)
2365             {
2366               handle->enodev_seen = 1;
2367               return CCID_DRIVER_ERR_NO_READER;
2368             }
2369
2370           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2371         }
2372       if (msglen < 0)
2373         return CCID_DRIVER_ERR_INV_VALUE;  /* Faulty libusb.  */
2374       *nread = msglen;
2375     }
2376   else
2377     {
2378       rc = read (handle->dev_fd, buffer, length);
2379       if (rc < 0)
2380         {
2381           rc = errno;
2382           DEBUGOUT_2 ("read from %d failed: %s\n",
2383                       handle->dev_fd, strerror (rc));
2384           if (rc == EAGAIN && eagain_retries++ < 5)
2385             {
2386               my_sleep (1);
2387               goto retry;
2388             }
2389           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2390         }
2391       *nread = msglen = rc;
2392     }
2393   eagain_retries = 0;
2394
2395   if (msglen < 10)
2396     {
2397       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
2398       abort_cmd (handle, seqno);
2399       return CCID_DRIVER_ERR_INV_VALUE;
2400     }
2401   if (buffer[5] != 0)
2402     {
2403       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
2404       return CCID_DRIVER_ERR_INV_VALUE;
2405     }
2406   if (buffer[6] != seqno)
2407     {
2408       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
2409                   seqno, buffer[6]);
2410       /* Retry until we are synced again.  */
2411       goto retry;
2412     }
2413
2414   /* We need to handle the time extension request before we check that
2415      we got the expected message type.  This is in particular required
2416      for the Cherry keyboard which sends a time extension request for
2417      each key hit.  */
2418   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
2419     {
2420       /* Card present and active, time extension requested. */
2421       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
2422                   buffer[7], buffer[8]);
2423       goto retry;
2424     }
2425
2426   if (buffer[0] != expected_type)
2427     {
2428       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
2429       abort_cmd (handle, seqno);
2430       return CCID_DRIVER_ERR_INV_VALUE;
2431     }
2432
2433   if (debug_level && (!no_debug || debug_level >= 3))
2434     {
2435       switch (buffer[0])
2436         {
2437         case RDR_to_PC_DataBlock:
2438           print_r2p_datablock (buffer, msglen);
2439           break;
2440         case RDR_to_PC_SlotStatus:
2441           print_r2p_slotstatus (buffer, msglen);
2442           break;
2443         case RDR_to_PC_Parameters:
2444           print_r2p_parameters (buffer, msglen);
2445           break;
2446         case RDR_to_PC_Escape:
2447           print_r2p_escape (buffer, msglen);
2448           break;
2449         case RDR_to_PC_DataRate:
2450           print_r2p_datarate (buffer, msglen);
2451           break;
2452         default:
2453           print_r2p_unknown (buffer, msglen);
2454           break;
2455         }
2456     }
2457   if (CCID_COMMAND_FAILED (buffer))
2458     print_command_failed (buffer);
2459
2460   /* Check whether a card is at all available.  Note: If you add new
2461      error codes here, check whether they need to be ignored in
2462      send_escape_cmd. */
2463   switch ((buffer[7] & 0x03))
2464     {
2465     case 0: /* no error */ break;
2466     case 1: return CCID_DRIVER_ERR_CARD_INACTIVE;
2467     case 2: return CCID_DRIVER_ERR_NO_CARD;
2468     case 3: /* RFU */ break;
2469     }
2470   return 0;
2471 }
2472
2473
2474
2475 /* Send an abort sequence and wait until everything settled.  */
2476 static int
2477 abort_cmd (ccid_driver_t handle, int seqno)
2478 {
2479   int rc;
2480   char dummybuf[8];
2481   unsigned char msg[100];
2482   int msglen;
2483
2484   if (!handle->idev)
2485     {
2486       /* I don't know how to send an abort to non-USB devices.  */
2487       rc = CCID_DRIVER_ERR_NOT_SUPPORTED;
2488     }
2489
2490   seqno &= 0xff;
2491   DEBUGOUT_1 ("sending abort sequence for seqno %d\n", seqno);
2492   /* Send the abort command to the control pipe.  Note that we don't
2493      need to keep track of sent abort commands because there should
2494      never be another thread using the same slot concurrently.  */
2495 #ifdef USE_NPTH
2496   npth_unprotect ();
2497 #endif
2498   rc = libusb_control_transfer (handle->idev,
2499                                 0x21,/* bmRequestType: host-to-device,
2500                                         class specific, to interface.  */
2501                                 1,   /* ABORT */
2502                                 (seqno << 8 | 0 /* slot */),
2503                                 handle->ifc_no,
2504                                 dummybuf, 0,
2505                                 1000 /* ms timeout */);
2506 #ifdef USE_NPTH
2507   npth_protect ();
2508 #endif
2509   if (rc)
2510     {
2511       DEBUGOUT_1 ("usb_control_msg error: %s\n", libusb_error_name (rc));
2512       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2513     }
2514
2515   /* Now send the abort command to the bulk out pipe using the same
2516      SEQNO and SLOT.  Do this in a loop to so that all seqno are
2517      tried.  */
2518   seqno--;  /* Adjust for next increment.  */
2519   do
2520     {
2521       int transferred;
2522
2523       seqno++;
2524       msg[0] = PC_to_RDR_Abort;
2525       msg[5] = 0; /* slot */
2526       msg[6] = seqno;
2527       msg[7] = 0; /* RFU */
2528       msg[8] = 0; /* RFU */
2529       msg[9] = 0; /* RFU */
2530       msglen = 10;
2531       set_msg_len (msg, 0);
2532
2533 #ifdef USE_NPTH
2534       npth_unprotect ();
2535 #endif
2536       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
2537                                  (char*)msg, msglen, &transferred,
2538                                  5000 /* ms timeout */);
2539 #ifdef USE_NPTH
2540       npth_protect ();
2541 #endif
2542       if (rc == 0 && transferred == msglen)
2543         rc = 0;
2544       else if (rc)
2545         DEBUGOUT_1 ("usb_bulk_write error in abort_cmd: %s\n",
2546                     libusb_error_name (rc));
2547
2548       if (rc)
2549         return rc;
2550
2551 #ifdef USE_NPTH
2552       npth_unprotect ();
2553 #endif
2554       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
2555                                  (char*)msg, sizeof msg, &msglen,
2556                                  5000 /*ms timeout*/);
2557 #ifdef USE_NPTH
2558       npth_protect ();
2559 #endif
2560       if (rc)
2561         {
2562           DEBUGOUT_1 ("usb_bulk_read error in abort_cmd: %s\n",
2563                       libusb_error_name (rc));
2564           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2565         }
2566
2567       if (msglen < 10)
2568         {
2569           DEBUGOUT_1 ("bulk-in msg in abort_cmd too short (%u)\n",
2570                       (unsigned int)msglen);
2571           return CCID_DRIVER_ERR_INV_VALUE;
2572         }
2573       if (msg[5] != 0)
2574         {
2575           DEBUGOUT_1 ("unexpected bulk-in slot (%d) in abort_cmd\n", msg[5]);
2576           return CCID_DRIVER_ERR_INV_VALUE;
2577         }
2578
2579       DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n",
2580                   msg[7], msg[8], msg[9]);
2581       if (CCID_COMMAND_FAILED (msg))
2582         print_command_failed (msg);
2583     }
2584   while (msg[0] != RDR_to_PC_SlotStatus && msg[5] != 0 && msg[6] != seqno);
2585
2586   handle->seqno = ((seqno + 1) & 0xff);
2587   DEBUGOUT ("sending abort sequence succeeded\n");
2588
2589   return 0;
2590 }
2591
2592
2593 /* Note that this function won't return the error codes NO_CARD or
2594    CARD_INACTIVE.  IF RESULT is not NULL, the result from the
2595    operation will get returned in RESULT and its length in RESULTLEN.
2596    If the response is larger than RESULTMAX, an error is returned and
2597    the required buffer length returned in RESULTLEN.  */
2598 static int
2599 send_escape_cmd (ccid_driver_t handle,
2600                  const unsigned char *data, size_t datalen,
2601                  unsigned char *result, size_t resultmax, size_t *resultlen)
2602 {
2603   int rc;
2604   unsigned char msg[100];
2605   size_t msglen;
2606   unsigned char seqno;
2607
2608   if (resultlen)
2609     *resultlen = 0;
2610
2611   if (datalen > sizeof msg - 10)
2612     return CCID_DRIVER_ERR_INV_VALUE; /* Escape data too large.  */
2613
2614   msg[0] = PC_to_RDR_Escape;
2615   msg[5] = 0; /* slot */
2616   msg[6] = seqno = handle->seqno++;
2617   msg[7] = 0; /* RFU */
2618   msg[8] = 0; /* RFU */
2619   msg[9] = 0; /* RFU */
2620   memcpy (msg+10, data, datalen);
2621   msglen = 10 + datalen;
2622   set_msg_len (msg, datalen);
2623
2624   rc = bulk_out (handle, msg, msglen, 0);
2625   if (rc)
2626     return rc;
2627   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Escape,
2628                 seqno, 5000, 0);
2629   if (result)
2630     switch (rc)
2631       {
2632         /* We need to ignore certain errorcode here. */
2633       case 0:
2634       case CCID_DRIVER_ERR_CARD_INACTIVE:
2635       case CCID_DRIVER_ERR_NO_CARD:
2636         {
2637           if (msglen > resultmax)
2638             rc = CCID_DRIVER_ERR_INV_VALUE; /* Response too large. */
2639           else
2640             {
2641               memcpy (result, msg, msglen);
2642               *resultlen = msglen;
2643               rc = 0;
2644             }
2645         }
2646         break;
2647       default:
2648         break;
2649       }
2650
2651   return rc;
2652 }
2653
2654
2655 int
2656 ccid_transceive_escape (ccid_driver_t handle,
2657                         const unsigned char *data, size_t datalen,
2658                         unsigned char *resp, size_t maxresplen, size_t *nresp)
2659 {
2660   return send_escape_cmd (handle, data, datalen, resp, maxresplen, nresp);
2661 }
2662
2663
2664
2665 /* experimental */
2666 int
2667 ccid_poll (ccid_driver_t handle)
2668 {
2669   int rc;
2670   unsigned char msg[10];
2671   int msglen;
2672   int i, j;
2673
2674   if (handle->idev)
2675     {
2676       rc = libusb_interrupt_transfer (handle->idev, handle->ep_intr,
2677                                       (char*)msg, sizeof msg, &msglen,
2678                                       0 /* ms timeout */ );
2679       if (rc == LIBUSB_ERROR_TIMEOUT)
2680         return 0;
2681     }
2682   else
2683     return 0;
2684
2685   if (rc)
2686     {
2687       DEBUGOUT_1 ("usb_intr_read error: %s\n", libusb_error_name (rc));
2688       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2689     }
2690
2691   if (msglen < 1)
2692     {
2693       DEBUGOUT ("intr-in msg too short\n");
2694       return CCID_DRIVER_ERR_INV_VALUE;
2695     }
2696
2697   if (msg[0] == RDR_to_PC_NotifySlotChange)
2698     {
2699       DEBUGOUT ("notify slot change:");
2700       for (i=1; i < msglen; i++)
2701         for (j=0; j < 4; j++)
2702           DEBUGOUT_CONT_3 (" %d:%c%c",
2703                            (i-1)*4+j,
2704                            (msg[i] & (1<<(j*2)))? 'p':'-',
2705                            (msg[i] & (2<<(j*2)))? '*':' ');
2706       DEBUGOUT_LF ();
2707     }
2708   else if (msg[0] == RDR_to_PC_HardwareError)
2709     {
2710       DEBUGOUT ("hardware error occurred\n");
2711     }
2712   else
2713     {
2714       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
2715     }
2716
2717   return 0;
2718 }
2719
2720
2721 /* Note that this function won't return the error codes NO_CARD or
2722    CARD_INACTIVE */
2723 int
2724 ccid_slot_status (ccid_driver_t handle, int *statusbits, int on_wire)
2725 {
2726   int rc;
2727   unsigned char msg[100];
2728   size_t msglen;
2729   unsigned char seqno;
2730   int retries = 0;
2731
2732   if (handle->powered_off)
2733     return CCID_DRIVER_ERR_NO_READER;
2734
2735   /* If the card (with its lower-level driver) doesn't require
2736      GET_STATUS on wire (because it supports INTERRUPT transfer for
2737      status change, or it's a token which has a card always inserted),
2738      no need to send on wire.  */
2739   if (!on_wire && !ccid_require_get_status (handle))
2740     {
2741       *statusbits = 0;
2742       return 0;
2743     }
2744
2745  retry:
2746   msg[0] = PC_to_RDR_GetSlotStatus;
2747   msg[5] = 0; /* slot */
2748   msg[6] = seqno = handle->seqno++;
2749   msg[7] = 0; /* RFU */
2750   msg[8] = 0; /* RFU */
2751   msg[9] = 0; /* RFU */
2752   set_msg_len (msg, 0);
2753
2754   rc = bulk_out (handle, msg, 10, 1);
2755   if (rc)
2756     return rc;
2757   /* Note that we set the NO_DEBUG flag here, so that the logs won't
2758      get cluttered up by a ticker function checking for the slot
2759      status and debugging enabled. */
2760   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
2761                 seqno, retries? 1000 : 200, 1);
2762   if (rc == CCID_DRIVER_ERR_CARD_IO_ERROR && retries < 3)
2763     {
2764       if (!retries)
2765         {
2766           DEBUGOUT ("USB: CALLING USB_CLEAR_HALT\n");
2767 #ifdef USE_NPTH
2768           npth_unprotect ();
2769 #endif
2770           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
2771           libusb_clear_halt (handle->idev, handle->ep_bulk_out);
2772 #ifdef USE_NPTH
2773           npth_protect ();
2774 #endif
2775         }
2776       else
2777           DEBUGOUT ("USB: RETRYING bulk_in AGAIN\n");
2778       retries++;
2779       goto retry;
2780     }
2781   if (rc && rc != CCID_DRIVER_ERR_NO_CARD && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
2782     return rc;
2783   *statusbits = (msg[7] & 3);
2784
2785   return 0;
2786 }
2787
2788
2789 /* Parse ATR string (of ATRLEN) and update parameters at PARAM.
2790    Calling this routine, it should prepare default values at PARAM
2791    beforehand.  This routine assumes that card is accessed by T=1
2792    protocol.  It doesn't analyze historical bytes at all.
2793
2794    Returns < 0 value on error:
2795      -1 for parse error or integrity check error
2796      -2 for card doesn't support T=1 protocol
2797      -3 for parameters are nod explicitly defined by ATR
2798      -4 for this driver doesn't support CRC
2799
2800    Returns >= 0 on success:
2801       0 for card is negotiable mode
2802       1 for card is specific mode (and not negotiable)
2803  */
2804 static int
2805 update_param_by_atr (unsigned char *param, unsigned char *atr, size_t atrlen)
2806 {
2807   int i = -1;
2808   int t, y, chk;
2809   int historical_bytes_num, negotiable = 1;
2810
2811 #define NEXTBYTE() do { i++; if (atrlen <= i) return -1; } while (0)
2812
2813   NEXTBYTE ();
2814
2815   if (atr[i] == 0x3F)
2816     param[1] |= 0x02;           /* Convention is inverse.  */
2817   NEXTBYTE ();
2818
2819   y = (atr[i] >> 4);
2820   historical_bytes_num = atr[i] & 0x0f;
2821   NEXTBYTE ();
2822
2823   if ((y & 1))
2824     {
2825       param[0] = atr[i];        /* TA1 - Fi & Di */
2826       NEXTBYTE ();
2827     }
2828
2829   if ((y & 2))
2830     NEXTBYTE ();                /* TB1 - ignore */
2831
2832   if ((y & 4))
2833     {
2834       param[2] = atr[i];        /* TC1 - Guard Time */
2835       NEXTBYTE ();
2836     }
2837
2838   if ((y & 8))
2839     {
2840       y = (atr[i] >> 4);        /* TD1 */
2841       t = atr[i] & 0x0f;
2842       NEXTBYTE ();
2843
2844       if ((y & 1))
2845         {                       /* TA2 - PPS mode */
2846           if ((atr[i] & 0x0f) != 1)
2847             return -2;          /* Wrong card protocol (!= 1).  */
2848
2849           if ((atr[i] & 0x10) != 0x10)
2850             return -3; /* Transmission parameters are implicitly defined. */
2851
2852           negotiable = 0;       /* TA2 means specific mode.  */
2853           NEXTBYTE ();
2854         }
2855
2856       if ((y & 2))
2857         NEXTBYTE ();            /* TB2 - ignore */
2858
2859       if ((y & 4))
2860         NEXTBYTE ();            /* TC2 - ignore */
2861
2862       if ((y & 8))
2863         {
2864           y = (atr[i] >> 4);    /* TD2 */
2865           t = atr[i] & 0x0f;
2866           NEXTBYTE ();
2867         }
2868       else
2869         y = 0;
2870
2871       while (y)
2872         {
2873           if ((y & 1))
2874             {                   /* TAx */
2875               if (t == 1)
2876                 param[5] = atr[i]; /* IFSC */
2877               else if (t == 15)
2878                 /* XXX: check voltage? */
2879                 param[4] = (atr[i] >> 6); /* ClockStop */
2880
2881               NEXTBYTE ();
2882             }
2883
2884           if ((y & 2))
2885             {
2886               if (t == 1)
2887                 param[3] = atr[i]; /* TBx - BWI & CWI */
2888               NEXTBYTE ();
2889             }
2890
2891           if ((y & 4))
2892             {
2893               if (t == 1)
2894                 param[1] |= (atr[i] & 0x01); /* TCx - LRC/CRC */
2895               NEXTBYTE ();
2896
2897               if (param[1] & 0x01)
2898                 return -4;      /* CRC not supported yet.  */
2899             }
2900
2901           if ((y & 8))
2902             {
2903               y = (atr[i] >> 4); /* TDx */
2904               t = atr[i] & 0x0f;
2905               NEXTBYTE ();
2906             }
2907           else
2908             y = 0;
2909         }
2910     }
2911
2912   i += historical_bytes_num - 1;
2913   NEXTBYTE ();
2914   if (atrlen != i+1)
2915     return -1;
2916
2917 #undef NEXTBYTE
2918
2919   chk = 0;
2920   do
2921     {
2922       chk ^= atr[i];
2923       i--;
2924     }
2925   while (i > 0);
2926
2927   if (chk != 0)
2928     return -1;
2929
2930   return negotiable;
2931 }
2932
2933
2934 /* Return the ATR of the card.  This is not a cached value and thus an
2935    actual reset is done.  */
2936 int
2937 ccid_get_atr (ccid_driver_t handle,
2938               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
2939 {
2940   int rc;
2941   int statusbits;
2942   unsigned char msg[100];
2943   unsigned char *tpdu;
2944   size_t msglen, tpdulen;
2945   unsigned char seqno;
2946   int use_crc = 0;
2947   unsigned int edc;
2948   int tried_iso = 0;
2949   int got_param;
2950   unsigned char param[7] = { /* For Protocol T=1 */
2951     0x11, /* bmFindexDindex */
2952     0x10, /* bmTCCKST1 */
2953     0x00, /* bGuardTimeT1 */
2954     0x4d, /* bmWaitingIntegersT1 */
2955     0x00, /* bClockStop */
2956     0x20, /* bIFSC */
2957     0x00  /* bNadValue */
2958   };
2959
2960   /* First check whether a card is available.  */
2961   rc = ccid_slot_status (handle, &statusbits, 1);
2962   if (rc)
2963     return rc;
2964   if (statusbits == 2)
2965     return CCID_DRIVER_ERR_NO_CARD;
2966
2967   /* For an inactive and also for an active card, issue the PowerOn
2968      command to get the ATR.  */
2969  again:
2970   msg[0] = PC_to_RDR_IccPowerOn;
2971   msg[5] = 0; /* slot */
2972   msg[6] = seqno = handle->seqno++;
2973   /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
2974   msg[7] = handle->auto_voltage ? 0 : 1;
2975   msg[8] = 0; /* RFU */
2976   msg[9] = 0; /* RFU */
2977   set_msg_len (msg, 0);
2978   msglen = 10;
2979
2980   rc = bulk_out (handle, msg, msglen, 0);
2981   if (rc)
2982     return rc;
2983   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2984                 seqno, 5000, 0);
2985   if (rc)
2986     return rc;
2987   if (!tried_iso && CCID_COMMAND_FAILED (msg) && CCID_ERROR_CODE (msg) == 0xbb
2988       && ((handle->id_vendor == VENDOR_CHERRY
2989            && handle->id_product == 0x0005)
2990           || (handle->id_vendor == VENDOR_GEMPC
2991               && handle->id_product == 0x4433)
2992           ))
2993     {
2994       tried_iso = 1;
2995       /* Try switching to ISO mode. */
2996       if (!send_escape_cmd (handle, (const unsigned char*)"\xF1\x01", 2,
2997                             NULL, 0, NULL))
2998         goto again;
2999     }
3000   else if (CCID_COMMAND_FAILED (msg))
3001     return CCID_DRIVER_ERR_CARD_IO_ERROR;
3002
3003
3004   handle->powered_off = 0;
3005
3006   if (atr)
3007     {
3008       size_t n = msglen - 10;
3009
3010       if (n > maxatrlen)
3011         n = maxatrlen;
3012       memcpy (atr, msg+10, n);
3013       *atrlen = n;
3014     }
3015
3016   param[6] = handle->nonnull_nad? ((1 << 4) | 0): 0;
3017   rc = update_param_by_atr (param, msg+10, msglen - 10);
3018   if (rc < 0)
3019     {
3020       DEBUGOUT_1 ("update_param_by_atr failed: %d\n", rc);
3021       return CCID_DRIVER_ERR_CARD_IO_ERROR;
3022     }
3023
3024   got_param = 0;
3025
3026   if (handle->auto_param)
3027     {
3028       msg[0] = PC_to_RDR_GetParameters;
3029       msg[5] = 0; /* slot */
3030       msg[6] = seqno = handle->seqno++;
3031       msg[7] = 0; /* RFU */
3032       msg[8] = 0; /* RFU */
3033       msg[9] = 0; /* RFU */
3034       set_msg_len (msg, 0);
3035       msglen = 10;
3036       rc = bulk_out (handle, msg, msglen, 0);
3037       if (!rc)
3038         rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
3039                       seqno, 2000, 0);
3040       if (rc)
3041         DEBUGOUT ("GetParameters failed\n");
3042       else if (msglen == 17 && msg[9] == 1)
3043         got_param = 1;
3044     }
3045   else if (handle->auto_pps)
3046     ;
3047   else if (rc == 1)             /* It's negotiable, send PPS.  */
3048     {
3049       msg[0] = PC_to_RDR_XfrBlock;
3050       msg[5] = 0; /* slot */
3051       msg[6] = seqno = handle->seqno++;
3052       msg[7] = 0;
3053       msg[8] = 0;
3054       msg[9] = 0;
3055       msg[10] = 0xff;           /* PPSS */
3056       msg[11] = 0x11;           /* PPS0: PPS1, Protocol T=1 */
3057       msg[12] = param[0];       /* PPS1: Fi / Di */
3058       msg[13] = 0xff ^ 0x11 ^ param[0]; /* PCK */
3059       set_msg_len (msg, 4);
3060       msglen = 10 + 4;
3061
3062       rc = bulk_out (handle, msg, msglen, 0);
3063       if (rc)
3064         return rc;
3065
3066       rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
3067                     seqno, 5000, 0);
3068       if (rc)
3069         return rc;
3070
3071       if (msglen != 10 + 4)
3072         {
3073           DEBUGOUT_1 ("Setting PPS failed: %zu\n", msglen);
3074           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3075         }
3076
3077       if (msg[10] != 0xff || msg[11] != 0x11 || msg[12] != param[0])
3078         {
3079           DEBUGOUT_1 ("Setting PPS failed: 0x%02x\n", param[0]);
3080           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3081         }
3082     }
3083
3084   /* Setup parameters to select T=1. */
3085   msg[0] = PC_to_RDR_SetParameters;
3086   msg[5] = 0; /* slot */
3087   msg[6] = seqno = handle->seqno++;
3088   msg[7] = 1; /* Select T=1. */
3089   msg[8] = 0; /* RFU */
3090   msg[9] = 0; /* RFU */
3091
3092   if (!got_param)
3093     memcpy (&msg[10], param, 7);
3094   set_msg_len (msg, 7);
3095   msglen = 10 + 7;
3096
3097   rc = bulk_out (handle, msg, msglen, 0);
3098   if (rc)
3099     return rc;
3100   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
3101                 seqno, 5000, 0);
3102   if (rc)
3103     DEBUGOUT ("SetParameters failed (ignored)\n");
3104
3105   if (!rc && msglen > 15 && msg[15] >= 16 && msg[15] <= 254 )
3106     handle->ifsc = msg[15];
3107   else
3108     handle->ifsc = 128; /* Something went wrong, assume 128 bytes.  */
3109
3110   if (handle->nonnull_nad && msglen > 16 && msg[16] == 0)
3111     {
3112       DEBUGOUT ("Use Null-NAD, clearing handle->nonnull_nad.\n");
3113       handle->nonnull_nad = 0;
3114     }
3115
3116   handle->t1_ns = 0;
3117   handle->t1_nr = 0;
3118
3119   /* Send an S-Block with our maximum IFSD to the CCID.  */
3120   if (!handle->apdu_level && !handle->auto_ifsd)
3121     {
3122       tpdu = msg+10;
3123       /* NAD: DAD=1, SAD=0 */
3124       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
3125       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
3126       tpdu[2] = 1;
3127       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32;
3128       tpdulen = 4;
3129       edc = compute_edc (tpdu, tpdulen, use_crc);
3130       if (use_crc)
3131         tpdu[tpdulen++] = (edc >> 8);
3132       tpdu[tpdulen++] = edc;
3133
3134       msg[0] = PC_to_RDR_XfrBlock;
3135       msg[5] = 0; /* slot */
3136       msg[6] = seqno = handle->seqno++;
3137       msg[7] = 0;
3138       msg[8] = 0; /* RFU */
3139       msg[9] = 0; /* RFU */
3140       set_msg_len (msg, tpdulen);
3141       msglen = 10 + tpdulen;
3142
3143       if (debug_level > 1)
3144         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
3145                       ((msg[11] & 0xc0) == 0x80)? 'R' :
3146                                 (msg[11] & 0x80)? 'S' : 'I',
3147                       ((msg[11] & 0x80)? !!(msg[11]& 0x10)
3148                                        : !!(msg[11] & 0x40)),
3149                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
3150
3151       rc = bulk_out (handle, msg, msglen, 0);
3152       if (rc)
3153         return rc;
3154
3155
3156       rc = bulk_in (handle, msg, sizeof msg, &msglen,
3157                     RDR_to_PC_DataBlock, seqno, 5000, 0);
3158       if (rc)
3159         return rc;
3160
3161       tpdu = msg + 10;
3162       tpdulen = msglen - 10;
3163
3164       if (tpdulen < 4)
3165         return CCID_DRIVER_ERR_ABORTED;
3166
3167       if (debug_level > 1)
3168         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3169                     ((msg[11] & 0xc0) == 0x80)? 'R' :
3170                               (msg[11] & 0x80)? 'S' : 'I',
3171                     ((msg[11] & 0x80)? !!(msg[11]& 0x10)
3172                                      : !!(msg[11] & 0x40)),
3173                     ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
3174                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
3175
3176       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
3177         {
3178           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
3179           return -1;
3180         }
3181       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
3182     }
3183
3184   return 0;
3185 }
3186
3187
3188 \f
3189
3190 static unsigned int
3191 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
3192 {
3193   if (use_crc)
3194     {
3195       return 0x42; /* Not yet implemented. */
3196     }
3197   else
3198     {
3199       unsigned char crc = 0;
3200
3201       for (; datalen; datalen--)
3202         crc ^= *data++;
3203       return crc;
3204     }
3205 }
3206
3207
3208 /* Return true if APDU is an extended length one.  */
3209 static int
3210 is_exlen_apdu (const unsigned char *apdu, size_t apdulen)
3211 {
3212   if (apdulen < 7 || apdu[4])
3213     return 0;  /* Too short or no Z byte.  */
3214   return 1;
3215 }
3216
3217
3218 /* Helper for ccid_transceive used for APDU level exchanges.  */
3219 static int
3220 ccid_transceive_apdu_level (ccid_driver_t handle,
3221                             const unsigned char *apdu_buf, size_t apdu_len,
3222                             unsigned char *resp, size_t maxresplen,
3223                             size_t *nresp)
3224 {
3225   int rc;
3226   unsigned char msg[CCID_MAX_BUF];
3227   const unsigned char *apdu_p;
3228   size_t apdu_part_len;
3229   size_t msglen;
3230   unsigned char seqno;
3231   int bwi = 4;
3232   unsigned char chain = 0;
3233
3234   if (apdu_len == 0 || apdu_len > sizeof (msg) - 10)
3235     return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
3236
3237   apdu_p = apdu_buf;
3238   while (1)
3239     {
3240       apdu_part_len = apdu_len;
3241       if (apdu_part_len > handle->max_ccid_msglen - 10)
3242         {
3243           apdu_part_len = handle->max_ccid_msglen - 10;
3244           chain |= 0x01;
3245         }
3246
3247       msg[0] = PC_to_RDR_XfrBlock;
3248       msg[5] = 0; /* slot */
3249       msg[6] = seqno = handle->seqno++;
3250       msg[7] = bwi;
3251       msg[8] = chain;
3252       msg[9] = 0;
3253       memcpy (msg+10, apdu_p, apdu_part_len);
3254       set_msg_len (msg, apdu_part_len);
3255       msglen = 10 + apdu_part_len;
3256
3257       rc = bulk_out (handle, msg, msglen, 0);
3258       if (rc)
3259         return rc;
3260
3261       apdu_p += apdu_part_len;
3262       apdu_len -= apdu_part_len;
3263
3264       rc = bulk_in (handle, msg, sizeof msg, &msglen,
3265                     RDR_to_PC_DataBlock, seqno, CCID_CMD_TIMEOUT, 0);
3266       if (rc)
3267         return rc;
3268
3269       if (!(chain & 0x01))
3270         break;
3271
3272       chain = 0x02;
3273     }
3274
3275   apdu_len = 0;
3276   while (1)
3277     {
3278       apdu_part_len = msglen - 10;
3279       if (resp && apdu_len + apdu_part_len <= maxresplen)
3280         memcpy (resp + apdu_len, msg+10, apdu_part_len);
3281       apdu_len += apdu_part_len;
3282
3283       if (!(msg[9] & 0x01))
3284         break;
3285
3286       msg[0] = PC_to_RDR_XfrBlock;
3287       msg[5] = 0; /* slot */
3288       msg[6] = seqno = handle->seqno++;
3289       msg[7] = bwi;
3290       msg[8] = 0x10;                /* Request next data block */
3291       msg[9] = 0;
3292       set_msg_len (msg, 0);
3293       msglen = 10;
3294
3295       rc = bulk_out (handle, msg, msglen, 0);
3296       if (rc)
3297         return rc;
3298
3299       rc = bulk_in (handle, msg, sizeof msg, &msglen,
3300                     RDR_to_PC_DataBlock, seqno, CCID_CMD_TIMEOUT, 0);
3301       if (rc)
3302         return rc;
3303     }
3304
3305   if (resp)
3306     {
3307       if (apdu_len > maxresplen)
3308         {
3309           DEBUGOUT_2 ("provided buffer too short for received data "
3310                       "(%u/%u)\n",
3311                       (unsigned int)apdu_len, (unsigned int)maxresplen);
3312           return CCID_DRIVER_ERR_INV_VALUE;
3313         }
3314
3315       *nresp = apdu_len;
3316     }
3317
3318   return 0;
3319 }
3320
3321
3322
3323 /*
3324   Protocol T=1 overview
3325
3326   Block Structure:
3327            Prologue Field:
3328    1 byte     Node Address (NAD)
3329    1 byte     Protocol Control Byte (PCB)
3330    1 byte     Length (LEN)
3331            Information Field:
3332    0-254 byte APDU or Control Information (INF)
3333            Epilogue Field:
3334    1 byte     Error Detection Code (EDC)
3335
3336   NAD:
3337    bit 7     unused
3338    bit 4..6  Destination Node Address (DAD)
3339    bit 3     unused
3340    bit 2..0  Source Node Address (SAD)
3341
3342    If node adresses are not used, SAD and DAD should be set to 0 on
3343    the first block sent to the card.  If they are used they should
3344    have different values (0 for one is okay); that first block sets up
3345    the addresses of the nodes.
3346
3347   PCB:
3348    Information Block (I-Block):
3349       bit 7    0
3350       bit 6    Sequence number (yep, that is modulo 2)
3351       bit 5    Chaining flag
3352       bit 4..0 reserved
3353    Received-Ready Block (R-Block):
3354       bit 7    1
3355       bit 6    0
3356       bit 5    0
3357       bit 4    Sequence number
3358       bit 3..0  0 = no error
3359                 1 = EDC or parity error
3360                 2 = other error
3361                 other values are reserved
3362    Supervisory Block (S-Block):
3363       bit 7    1
3364       bit 6    1
3365       bit 5    clear=request,set=response
3366       bit 4..0  0 = resyncronisation request
3367                 1 = information field size request
3368                 2 = abort request
3369                 3 = extension of BWT request
3370                 4 = VPP error
3371                 other values are reserved
3372
3373 */
3374
3375 int
3376 ccid_transceive (ccid_driver_t handle,
3377                  const unsigned char *apdu_buf, size_t apdu_buflen,
3378                  unsigned char *resp, size_t maxresplen, size_t *nresp)
3379 {
3380   int rc;
3381   /* The size of the buffer used to be 10+259.  For the via_escape
3382      hack we need one extra byte, thus 11+259.  */
3383   unsigned char send_buffer[11+259], recv_buffer[11+259];
3384   const unsigned char *apdu;
3385   size_t apdulen;
3386   unsigned char *msg, *tpdu, *p;
3387   size_t msglen, tpdulen, last_tpdulen, n;
3388   unsigned char seqno;
3389   unsigned int edc;
3390   int use_crc = 0;
3391   int hdrlen, pcboff;
3392   size_t dummy_nresp;
3393   int via_escape = 0;
3394   int next_chunk = 1;
3395   int sending = 1;
3396   int retries = 0;
3397   int resyncing = 0;
3398   int nad_byte;
3399   int wait_more = 0;
3400
3401   if (!nresp)
3402     nresp = &dummy_nresp;
3403   *nresp = 0;
3404
3405   /* Smarter readers allow sending APDUs directly; divert here. */
3406   if (handle->apdu_level)
3407     {
3408       /* We employ a hack for Omnikey readers which are able to send
3409          TPDUs using an escape sequence.  There is no documentation
3410          but the Windows driver does it this way.  Tested using a
3411          CM6121.  This method works also for the Cherry XX44
3412          keyboards; however there are problems with the
3413          ccid_transceive_secure which leads to a loss of sync on the
3414          CCID level.  If Cherry wants to make their keyboard work
3415          again, they should hand over some docs. */
3416       if ((handle->id_vendor == VENDOR_OMNIKEY
3417            || (!handle->idev && handle->id_product == TRANSPORT_CM4040))
3418           && handle->apdu_level < 2
3419           && is_exlen_apdu (apdu_buf, apdu_buflen))
3420         via_escape = 1;
3421       else
3422         return ccid_transceive_apdu_level (handle, apdu_buf, apdu_buflen,
3423                                            resp, maxresplen, nresp);
3424     }
3425
3426   /* The other readers we support require sending TPDUs.  */
3427
3428   tpdulen = 0; /* Avoid compiler warning about no initialization. */
3429   msg = send_buffer;
3430   hdrlen = via_escape? 11 : 10;
3431
3432   /* NAD: DAD=1, SAD=0 */
3433   nad_byte = handle->nonnull_nad? ((1 << 4) | 0): 0;
3434   if (via_escape)
3435     nad_byte = 0;
3436
3437   last_tpdulen = 0;  /* Avoid gcc warning (controlled by RESYNCING). */
3438   for (;;)
3439     {
3440       if (next_chunk)
3441         {
3442           next_chunk = 0;
3443
3444           apdu = apdu_buf;
3445           apdulen = apdu_buflen;
3446           assert (apdulen);
3447
3448           /* Construct an I-Block. */
3449           tpdu = msg + hdrlen;
3450           tpdu[0] = nad_byte;
3451           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
3452           if (apdulen > handle->ifsc )
3453             {
3454               apdulen = handle->ifsc;
3455               apdu_buf += handle->ifsc;
3456               apdu_buflen -= handle->ifsc;
3457               tpdu[1] |= (1 << 5); /* Set more bit. */
3458             }
3459           tpdu[2] = apdulen;
3460           memcpy (tpdu+3, apdu, apdulen);
3461           tpdulen = 3 + apdulen;
3462           edc = compute_edc (tpdu, tpdulen, use_crc);
3463           if (use_crc)
3464             tpdu[tpdulen++] = (edc >> 8);
3465           tpdu[tpdulen++] = edc;
3466         }
3467
3468       if (via_escape)
3469         {
3470           msg[0] = PC_to_RDR_Escape;
3471           msg[5] = 0; /* slot */
3472           msg[6] = seqno = handle->seqno++;
3473           msg[7] = 0; /* RFU */
3474           msg[8] = 0; /* RFU */
3475           msg[9] = 0; /* RFU */
3476           msg[10] = 0x1a; /* Omnikey command to send a TPDU.  */
3477           set_msg_len (msg, 1 + tpdulen);
3478         }
3479       else
3480         {
3481           msg[0] = PC_to_RDR_XfrBlock;
3482           msg[5] = 0; /* slot */
3483           msg[6] = seqno = handle->seqno++;
3484           msg[7] = 4; /* bBWI */
3485           msg[8] = 0; /* RFU */
3486           msg[9] = 0; /* RFU */
3487           set_msg_len (msg, tpdulen);
3488         }
3489       msglen = hdrlen + tpdulen;
3490       if (!resyncing)
3491         last_tpdulen = tpdulen;
3492       pcboff = hdrlen+1;
3493
3494       if (debug_level > 1)
3495         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
3496                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3497                     (msg[pcboff] & 0x80)? 'S' : 'I',
3498                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3499                      : !!(msg[pcboff] & 0x40)),
3500                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3501                      " [more]":""));
3502
3503       rc = bulk_out (handle, msg, msglen, 0);
3504       if (rc)
3505         return rc;
3506
3507       msg = recv_buffer;
3508       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3509                     via_escape? RDR_to_PC_Escape : RDR_to_PC_DataBlock, seqno,
3510                     wait_more? CCID_CMD_TIMEOUT_LONGER: CCID_CMD_TIMEOUT, 0);
3511       if (rc)
3512         return rc;
3513
3514       tpdu = msg + hdrlen;
3515       tpdulen = msglen - hdrlen;
3516       resyncing = 0;
3517
3518       if (tpdulen < 4)
3519         {
3520 #ifdef USE_NPTH
3521           npth_unprotect ();
3522 #endif
3523           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
3524 #ifdef USE_NPTH
3525           npth_protect ();
3526 #endif
3527           return CCID_DRIVER_ERR_ABORTED;
3528         }
3529
3530       if (debug_level > 1)
3531         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3532                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3533                               (msg[pcboff] & 0x80)? 'S' : 'I',
3534                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3535                      : !!(msg[pcboff] & 0x40)),
3536                     ((msg[pcboff] & 0xc0) == 0x80)? (msg[pcboff] & 0x0f) : 0,
3537                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3538                      " [more]":""));
3539
3540       if (!(tpdu[1] & 0x80))
3541         { /* This is an I-block. */
3542           retries = 0;
3543           if (sending)
3544             { /* last block sent was successful. */
3545               handle->t1_ns ^= 1;
3546               sending = 0;
3547             }
3548
3549           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3550             { /* Response does not match our sequence number. */
3551               msg = send_buffer;
3552               tpdu = msg + hdrlen;
3553               tpdu[0] = nad_byte;
3554               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
3555               tpdu[2] = 0;
3556               tpdulen = 3;
3557               edc = compute_edc (tpdu, tpdulen, use_crc);
3558               if (use_crc)
3559                 tpdu[tpdulen++] = (edc >> 8);
3560               tpdu[tpdulen++] = edc;
3561
3562               continue;
3563             }
3564
3565           handle->t1_nr ^= 1;
3566
3567           p = tpdu + 3; /* Skip the prologue field. */
3568           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3569           /* fixme: verify the checksum. */
3570           if (resp)
3571             {
3572               if (n > maxresplen)
3573                 {
3574                   DEBUGOUT_2 ("provided buffer too short for received data "
3575                               "(%u/%u)\n",
3576                               (unsigned int)n, (unsigned int)maxresplen);
3577                   return CCID_DRIVER_ERR_INV_VALUE;
3578                 }
3579
3580               memcpy (resp, p, n);
3581               resp += n;
3582               *nresp += n;
3583               maxresplen -= n;
3584             }
3585
3586           if (!(tpdu[1] & 0x20))
3587             return 0; /* No chaining requested - ready. */
3588
3589           msg = send_buffer;
3590           tpdu = msg + hdrlen;
3591           tpdu[0] = nad_byte;
3592           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
3593           tpdu[2] = 0;
3594           tpdulen = 3;
3595           edc = compute_edc (tpdu, tpdulen, use_crc);
3596           if (use_crc)
3597             tpdu[tpdulen++] = (edc >> 8);
3598           tpdu[tpdulen++] = edc;
3599         }
3600       else if ((tpdu[1] & 0xc0) == 0x80)
3601         { /* This is a R-block. */
3602           if ( (tpdu[1] & 0x0f))
3603             {
3604               retries++;
3605               if (via_escape && retries == 1 && (msg[pcboff] & 0x0f))
3606                 {
3607                   /* Error probably due to switching to TPDU.  Send a
3608                      resync request.  We use the recv_buffer so that
3609                      we don't corrupt the send_buffer.  */
3610                   msg = recv_buffer;
3611                   tpdu = msg + hdrlen;
3612                   tpdu[0] = nad_byte;
3613                   tpdu[1] = 0xc0; /* S-block resync request. */
3614                   tpdu[2] = 0;
3615                   tpdulen = 3;
3616                   edc = compute_edc (tpdu, tpdulen, use_crc);
3617                   if (use_crc)
3618                     tpdu[tpdulen++] = (edc >> 8);
3619                   tpdu[tpdulen++] = edc;
3620                   resyncing = 1;
3621                   DEBUGOUT ("T=1: requesting resync\n");
3622                 }
3623               else if (retries > 3)
3624                 {
3625                   DEBUGOUT ("T=1: 3 failed retries\n");
3626                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
3627                 }
3628               else
3629                 {
3630                   /* Error: repeat last block */
3631                   msg = send_buffer;
3632                   tpdulen = last_tpdulen;
3633                 }
3634             }
3635           else if (sending && !!(tpdu[1] & 0x10) == handle->t1_ns)
3636             { /* Response does not match our sequence number. */
3637               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
3638               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3639             }
3640           else if (sending)
3641             { /* Send next chunk. */
3642               retries = 0;
3643               msg = send_buffer;
3644               next_chunk = 1;
3645               handle->t1_ns ^= 1;
3646             }
3647           else
3648             {
3649               DEBUGOUT ("unexpected ACK R-block received\n");
3650               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3651             }
3652         }
3653       else
3654         { /* This is a S-block. */
3655           retries = 0;
3656           DEBUGOUT_2 ("T=1: S-block %s received cmd=%d\n",
3657                       (tpdu[1] & 0x20)? "response": "request",
3658                       (tpdu[1] & 0x1f));
3659           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 1 && tpdu[2] == 1)
3660             {
3661               /* Information field size request.  */
3662               unsigned char ifsc = tpdu[3];
3663
3664               if (ifsc < 16 || ifsc > 254)
3665                 return CCID_DRIVER_ERR_CARD_IO_ERROR;
3666
3667               msg = send_buffer;
3668               tpdu = msg + hdrlen;
3669               tpdu[0] = nad_byte;
3670               tpdu[1] = (0xc0 | 0x20 | 1); /* S-block response */
3671               tpdu[2] = 1;
3672               tpdu[3] = ifsc;
3673               tpdulen = 4;
3674               edc = compute_edc (tpdu, tpdulen, use_crc);
3675               if (use_crc)
3676                 tpdu[tpdulen++] = (edc >> 8);
3677               tpdu[tpdulen++] = edc;
3678               DEBUGOUT_1 ("T=1: requesting an ifsc=%d\n", ifsc);
3679             }
3680           else if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
3681             {
3682               /* Wait time extension request. */
3683               unsigned char bwi = tpdu[3];
3684
3685               /* Check if it's unsual value which can't be expressed in ATR.  */
3686               if (bwi > 15)
3687                 wait_more = 1;
3688
3689               msg = send_buffer;
3690               tpdu = msg + hdrlen;
3691               tpdu[0] = nad_byte;
3692               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
3693               tpdu[2] = 1;
3694               tpdu[3] = bwi;
3695               tpdulen = 4;
3696               edc = compute_edc (tpdu, tpdulen, use_crc);
3697               if (use_crc)
3698                 tpdu[tpdulen++] = (edc >> 8);
3699               tpdu[tpdulen++] = edc;
3700               DEBUGOUT_1 ("T=1: waittime extension of bwi=%d\n", bwi);
3701               print_progress (handle);
3702             }
3703           else if ( (tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 0 && !tpdu[2])
3704             {
3705               DEBUGOUT ("T=1: resync ack from reader\n");
3706               /* Repeat previous block.  */
3707               msg = send_buffer;
3708               tpdulen = last_tpdulen;
3709             }
3710           else
3711             return CCID_DRIVER_ERR_CARD_IO_ERROR;
3712         }
3713     } /* end T=1 protocol loop. */
3714
3715   return 0;
3716 }
3717
3718
3719 /* Send the CCID Secure command to the reader.  APDU_BUF should
3720    contain the APDU template.  PIN_MODE defines how the pin gets
3721    formatted:
3722
3723      1 := The PIN is ASCII encoded and of variable length.  The
3724           length of the PIN entered will be put into Lc by the reader.
3725           The APDU should me made up of 4 bytes without Lc.
3726
3727    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
3728    may be used t enable reasonable defaults.
3729
3730    When called with RESP and NRESP set to NULL, the function will
3731    merely check whether the reader supports the secure command for the
3732    given APDU and PIN_MODE. */
3733 int
3734 ccid_transceive_secure (ccid_driver_t handle,
3735                         const unsigned char *apdu_buf, size_t apdu_buflen,
3736                         pininfo_t *pininfo,
3737                         unsigned char *resp, size_t maxresplen, size_t *nresp)
3738 {
3739   int rc;
3740   unsigned char send_buffer[10+259], recv_buffer[10+259];
3741   unsigned char *msg, *tpdu, *p;
3742   size_t msglen, tpdulen, n;
3743   unsigned char seqno;
3744   size_t dummy_nresp;
3745   int testmode;
3746   int cherry_mode = 0;
3747   int add_zero = 0;
3748   int enable_varlen = 0;
3749
3750   testmode = !resp && !nresp;
3751
3752   if (!nresp)
3753     nresp = &dummy_nresp;
3754   *nresp = 0;
3755
3756   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
3757     ;
3758   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
3759     ;
3760   else
3761     return CCID_DRIVER_ERR_NO_PINPAD;
3762
3763   if (!pininfo->minlen)
3764     pininfo->minlen = 1;
3765   if (!pininfo->maxlen)
3766     pininfo->maxlen = 15;
3767
3768   /* Note that the 25 is the maximum value the SPR532 allows.  */
3769   if (pininfo->minlen < 1 || pininfo->minlen > 25
3770       || pininfo->maxlen < 1 || pininfo->maxlen > 25
3771       || pininfo->minlen > pininfo->maxlen)
3772     return CCID_DRIVER_ERR_INV_VALUE;
3773
3774   /* We have only tested a few readers so better don't risk anything
3775      and do not allow the use with other readers. */
3776   switch (handle->id_vendor)
3777     {
3778     case VENDOR_SCM:  /* Tested with SPR 532. */
3779     case VENDOR_KAAN: /* Tested with KAAN Advanced (1.02). */
3780     case VENDOR_FSIJ: /* Tested with Gnuk (0.21). */
3781       pininfo->maxlen = 25;
3782       enable_varlen = 1;
3783       break;
3784     case VENDOR_REINER:/* Tested with cyberJack go */
3785     case VENDOR_VASCO: /* Tested with DIGIPASS 920 */
3786       enable_varlen = 1;
3787       break;
3788     case VENDOR_CHERRY:
3789       pininfo->maxlen = 15;
3790       enable_varlen = 1;
3791       /* The CHERRY XX44 keyboard echos an asterisk for each entered
3792          character on the keyboard channel.  We use a special variant
3793          of PC_to_RDR_Secure which directs these characters to the
3794          smart card's bulk-in channel.  We also need to append a zero
3795          Lc byte to the APDU.  It seems that it will be replaced with
3796          the actual length instead of being appended before the APDU
3797          is send to the card. */
3798       add_zero = 1;
3799       if (handle->id_product != CHERRY_ST2000)
3800         cherry_mode = 1;
3801       break;
3802     default:
3803       if ((handle->id_vendor == VENDOR_GEMPC &&
3804            handle->id_product == GEMPC_PINPAD)
3805           || (handle->id_vendor == VENDOR_VEGA &&
3806               handle->id_product == VEGA_ALPHA))
3807         {
3808           enable_varlen = 0;
3809           pininfo->minlen = 4;
3810           pininfo->maxlen = 8;
3811           break;
3812         }
3813      return CCID_DRIVER_ERR_NOT_SUPPORTED;
3814     }
3815
3816   if (enable_varlen)
3817     pininfo->fixedlen = 0;
3818
3819   if (testmode)
3820     return 0; /* Success */
3821
3822   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
3823     return CCID_DRIVER_ERR_NOT_SUPPORTED;
3824
3825   msg = send_buffer;
3826   if (handle->id_vendor == VENDOR_SCM)
3827     {
3828       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
3829       rc = send_escape_cmd (handle, (const unsigned char*)"\x80\x02\x00", 3,
3830                             NULL, 0, NULL);
3831       if (rc)
3832         return rc;
3833     }
3834
3835   msg[0] = cherry_mode? 0x89 : PC_to_RDR_Secure;
3836   msg[5] = 0; /* slot */
3837   msg[6] = seqno = handle->seqno++;
3838   msg[7] = 0; /* bBWI */
3839   msg[8] = 0; /* RFU */
3840   msg[9] = 0; /* RFU */
3841   msg[10] = apdu_buf[1] == 0x20 ? 0 : 1;
3842                /* Perform PIN verification or PIN modification. */
3843   msg[11] = 0; /* Timeout in seconds. */
3844   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
3845   if (handle->id_vendor == VENDOR_SCM)
3846     {
3847       /* For the SPR532 the next 2 bytes need to be zero.  We do this
3848          for all SCM products.  Kudos to Martin Paljak for this
3849          hint.  */
3850       msg[13] = msg[14] = 0;
3851     }
3852   else
3853     {
3854       msg[13] = pininfo->fixedlen; /* bmPINBlockString:
3855                                       0 bits of pin length to insert.
3856                                       PIN block size by fixedlen.  */
3857       msg[14] = 0x00; /* bmPINLengthFormat:
3858                          Units are bytes, position is 0. */
3859     }
3860
3861   msglen = 15;
3862   if (apdu_buf[1] == 0x24)
3863     {
3864       msg[msglen++] = 0;    /* bInsertionOffsetOld */
3865       msg[msglen++] = pininfo->fixedlen;    /* bInsertionOffsetNew */
3866     }
3867
3868   /* The following is a little endian word. */
3869   msg[msglen++] = pininfo->maxlen;   /* wPINMaxExtraDigit-Maximum.  */
3870   msg[msglen++] = pininfo->minlen;   /* wPINMaxExtraDigit-Minimum.  */
3871
3872   if (apdu_buf[1] == 0x24)
3873     msg[msglen++] = apdu_buf[2] == 0 ? 0x03 : 0x01;
3874               /* bConfirmPIN
3875                *    0x00: new PIN once
3876                *    0x01: new PIN twice (confirmation)
3877                *    0x02: old PIN and new PIN once
3878                *    0x03: old PIN and new PIN twice (confirmation)
3879                */
3880
3881   msg[msglen] = 0x02; /* bEntryValidationCondition:
3882                          Validation key pressed */
3883   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
3884     msg[msglen] |= 0x01; /* Max size reached.  */
3885   msglen++;
3886
3887   if (apdu_buf[1] == 0x20)
3888     msg[msglen++] = 0x01; /* bNumberMessage. */
3889   else
3890     msg[msglen++] = 0x03; /* bNumberMessage. */
3891
3892   msg[msglen++] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
3893   msg[msglen++] = 0x04; /* wLangId-High. */
3894
3895   if (apdu_buf[1] == 0x20)
3896     msg[msglen++] = 0;    /* bMsgIndex. */
3897   else
3898     {
3899       msg[msglen++] = 0;    /* bMsgIndex1. */
3900       msg[msglen++] = 1;    /* bMsgIndex2. */
3901       msg[msglen++] = 2;    /* bMsgIndex3. */
3902     }
3903
3904   /* Calculate Lc.  */
3905   n = pininfo->fixedlen;
3906   if (apdu_buf[1] == 0x24)
3907     n += pininfo->fixedlen;
3908
3909   /* bTeoProlog follows: */
3910   msg[msglen++] = handle->nonnull_nad? ((1 << 4) | 0): 0;
3911   msg[msglen++] = ((handle->t1_ns & 1) << 6); /* I-block */
3912   if (n)
3913     msg[msglen++] = n + 5; /* apdulen should be filled for fixed length.  */
3914   else
3915     msg[msglen++] = 0; /* The apdulen will be filled in by the reader.  */
3916   /* APDU follows:  */
3917   msg[msglen++] = apdu_buf[0]; /* CLA */
3918   msg[msglen++] = apdu_buf[1]; /* INS */
3919   msg[msglen++] = apdu_buf[2]; /* P1 */
3920   msg[msglen++] = apdu_buf[3]; /* P2 */
3921   if (add_zero)
3922     msg[msglen++] = 0;
3923   else if (pininfo->fixedlen != 0)
3924     {
3925       msg[msglen++] = n;
3926       memset (&msg[msglen], 0xff, n);
3927       msglen += n;
3928     }
3929   /* An EDC is not required. */
3930   set_msg_len (msg, msglen - 10);
3931
3932   rc = bulk_out (handle, msg, msglen, 0);
3933   if (rc)
3934     return rc;
3935
3936   msg = recv_buffer;
3937   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3938                 RDR_to_PC_DataBlock, seqno, 30000, 0);
3939   if (rc)
3940     return rc;
3941
3942   tpdu = msg + 10;
3943   tpdulen = msglen - 10;
3944
3945   if (handle->apdu_level)
3946     {
3947       if (resp)
3948         {
3949           if (tpdulen > maxresplen)
3950             {
3951               DEBUGOUT_2 ("provided buffer too short for received data "
3952                           "(%u/%u)\n",
3953                           (unsigned int)tpdulen, (unsigned int)maxresplen);
3954               return CCID_DRIVER_ERR_INV_VALUE;
3955             }
3956
3957           memcpy (resp, tpdu, tpdulen);
3958           *nresp = tpdulen;
3959         }
3960       return 0;
3961     }
3962
3963   if (tpdulen < 4)
3964     {
3965 #ifdef USE_NPTH
3966       npth_unprotect ();
3967 #endif
3968       libusb_clear_halt (handle->idev, handle->ep_bulk_in);
3969 #ifdef USE_NPTH
3970       npth_protect ();
3971 #endif
3972       return CCID_DRIVER_ERR_ABORTED;
3973     }
3974   if (debug_level > 1)
3975     DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3976                 ((msg[11] & 0xc0) == 0x80)? 'R' :
3977                           (msg[11] & 0x80)? 'S' : 'I',
3978                 ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
3979                 ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
3980                 (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
3981
3982   if (!(tpdu[1] & 0x80))
3983     { /* This is an I-block. */
3984       /* Last block sent was successful. */
3985       handle->t1_ns ^= 1;
3986
3987       if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3988         { /* Response does not match our sequence number. */
3989           DEBUGOUT ("I-block with wrong seqno received\n");
3990           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3991         }
3992
3993       handle->t1_nr ^= 1;
3994
3995       p = tpdu + 3; /* Skip the prologue field. */
3996       n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3997       /* fixme: verify the checksum. */
3998       if (resp)
3999         {
4000           if (n > maxresplen)
4001             {
4002               DEBUGOUT_2 ("provided buffer too short for received data "
4003                           "(%u/%u)\n",
4004                           (unsigned int)n, (unsigned int)maxresplen);
4005               return CCID_DRIVER_ERR_INV_VALUE;
4006             }
4007
4008           memcpy (resp, p, n);
4009           resp += n;
4010           *nresp += n;
4011           maxresplen -= n;
4012         }
4013
4014       if (!(tpdu[1] & 0x20))
4015         return 0; /* No chaining requested - ready. */
4016
4017       DEBUGOUT ("chaining requested but not supported for Secure operation\n");
4018       return CCID_DRIVER_ERR_CARD_IO_ERROR;
4019     }
4020   else if ((tpdu[1] & 0xc0) == 0x80)
4021     { /* This is a R-block. */
4022       if ( (tpdu[1] & 0x0f))
4023         { /* Error: repeat last block */
4024           DEBUGOUT ("No retries supported for Secure operation\n");
4025           return CCID_DRIVER_ERR_CARD_IO_ERROR;
4026         }
4027       else if (!!(tpdu[1] & 0x10) == handle->t1_ns)
4028         { /* Response does not match our sequence number. */
4029           DEBUGOUT ("R-block with wrong seqno received on more bit\n");
4030           return CCID_DRIVER_ERR_CARD_IO_ERROR;
4031         }
4032       else
4033         { /* Send next chunk. */
4034           DEBUGOUT ("chaining not supported on Secure operation\n");
4035           return CCID_DRIVER_ERR_CARD_IO_ERROR;
4036         }
4037     }
4038   else
4039     { /* This is a S-block. */
4040       DEBUGOUT_2 ("T=1: S-block %s received cmd=%d for Secure operation\n",
4041                   (tpdu[1] & 0x20)? "response": "request",
4042                   (tpdu[1] & 0x1f));
4043       return CCID_DRIVER_ERR_CARD_IO_ERROR;
4044     }
4045
4046   return 0;
4047 }
4048
4049
4050
4051
4052 #ifdef TEST
4053
4054
4055 static void
4056 print_error (int err)
4057 {
4058   const char *p;
4059   char buf[50];
4060
4061   switch (err)
4062     {
4063     case 0: p = "success";
4064     case CCID_DRIVER_ERR_OUT_OF_CORE: p = "out of core"; break;
4065     case CCID_DRIVER_ERR_INV_VALUE: p = "invalid value"; break;
4066     case CCID_DRIVER_ERR_NO_DRIVER: p = "no driver"; break;
4067     case CCID_DRIVER_ERR_NOT_SUPPORTED: p = "not supported"; break;
4068     case CCID_DRIVER_ERR_LOCKING_FAILED: p = "locking failed"; break;
4069     case CCID_DRIVER_ERR_BUSY: p = "busy"; break;
4070     case CCID_DRIVER_ERR_NO_CARD: p = "no card"; break;
4071     case CCID_DRIVER_ERR_CARD_INACTIVE: p = "card inactive"; break;
4072     case CCID_DRIVER_ERR_CARD_IO_ERROR: p = "card I/O error"; break;
4073     case CCID_DRIVER_ERR_GENERAL_ERROR: p = "general error"; break;
4074     case CCID_DRIVER_ERR_NO_READER: p = "no reader"; break;
4075     case CCID_DRIVER_ERR_ABORTED: p = "aborted"; break;
4076     default: sprintf (buf, "0x%05x", err); p = buf; break;
4077     }
4078   fprintf (stderr, "operation failed: %s\n", p);
4079 }
4080
4081
4082 static void
4083 print_data (const unsigned char *data, size_t length)
4084 {
4085   if (length >= 2)
4086     {
4087       fprintf (stderr, "operation status: %02X%02X\n",
4088                data[length-2], data[length-1]);
4089       length -= 2;
4090     }
4091   if (length)
4092     {
4093         fputs ("   returned data:", stderr);
4094         for (; length; length--, data++)
4095           fprintf (stderr, " %02X", *data);
4096         putc ('\n', stderr);
4097     }
4098 }
4099
4100 static void
4101 print_result (int rc, const unsigned char *data, size_t length)
4102 {
4103   if (rc)
4104     print_error (rc);
4105   else if (data)
4106     print_data (data, length);
4107 }
4108
4109 int
4110 main (int argc, char **argv)
4111 {
4112   int rc;
4113   ccid_driver_t ccid;
4114   int slotstat;
4115   unsigned char result[512];
4116   size_t resultlen;
4117   int no_pinpad = 0;
4118   int verify_123456 = 0;
4119   int did_verify = 0;
4120   int no_poll = 0;
4121
4122   if (argc)
4123     {
4124       argc--;
4125       argv++;
4126     }
4127
4128   while (argc)
4129     {
4130       if ( !strcmp (*argv, "--list"))
4131         {
4132           char *p;
4133           p = ccid_get_reader_list ();
4134           if (!p)
4135             return 1;
4136           fputs (p, stderr);
4137           free (p);
4138           return 0;
4139         }
4140       else if ( !strcmp (*argv, "--debug"))
4141         {
4142           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
4143           argc--; argv++;
4144         }
4145       else if ( !strcmp (*argv, "--no-poll"))
4146         {
4147           no_poll = 1;
4148           argc--; argv++;
4149         }
4150       else if ( !strcmp (*argv, "--no-pinpad"))
4151         {
4152           no_pinpad = 1;
4153           argc--; argv++;
4154         }
4155       else if ( !strcmp (*argv, "--verify-123456"))
4156         {
4157           verify_123456 = 1;
4158           argc--; argv++;
4159         }
4160       else
4161         break;
4162     }
4163
4164   rc = ccid_open_reader (&ccid, argc? *argv:NULL, NULL);
4165   if (rc)
4166     return 1;
4167
4168   if (!no_poll)
4169     ccid_poll (ccid);
4170   fputs ("getting ATR ...\n", stderr);
4171   rc = ccid_get_atr (ccid, NULL, 0, NULL);
4172   if (rc)
4173     {
4174       print_error (rc);
4175       return 1;
4176     }
4177
4178   if (!no_poll)
4179     ccid_poll (ccid);
4180   fputs ("getting slot status ...\n", stderr);
4181   rc = ccid_slot_status (ccid, &slotstat);
4182   if (rc)
4183     {
4184       print_error (rc);
4185       return 1;
4186     }
4187
4188   if (!no_poll)
4189     ccid_poll (ccid);
4190
4191   fputs ("selecting application OpenPGP ....\n", stderr);
4192   {
4193     static unsigned char apdu[] = {
4194       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};