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