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