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