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