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