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