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