515b15a6bde7be04f64c86f0a4baa577aed455c8
[gnupg.git] / g10 / 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 #include "../include/host2net.h"
96
97 #define DRVNAME "ccid-driver: "
98
99
100 /* Depending on how this source is used we either define our error
101    output to go to stderr or to the jnlib based logging functions.  We
102    use the latter when GNUPG_MAJOR_VERSION is defines or when both,
103    GNUPG_SCD_MAIN_HEADER and HAVE_JNLIB_LOGGING are defined.
104 */
105 #if defined(GNUPG_MAJOR_VERSION) \
106     || (defined(GNUPG_SCD_MAIN_HEADER) && defined(HAVE_JNLIB_LOGGING))
107
108 #if defined(GNUPG_SCD_MAIN_HEADER)
109 #  include GNUPG_SCD_MAIN_HEADER
110 #elif GNUPG_MAJOR_VERSION == 1 /* GnuPG Version is < 1.9. */
111 #  include "options.h"
112 #  include "util.h"
113 #  include "memory.h"
114 #  include "cardglue.h"
115 # else /* This is the modularized GnuPG 1.9 or later. */
116 #  include "scdaemon.h"
117 #endif
118
119
120 # define DEBUGOUT(t)         do { if (debug_level) \
121                                   log_debug (DRVNAME t); } while (0)
122 # define DEBUGOUT_1(t,a)     do { if (debug_level) \
123                                   log_debug (DRVNAME t,(a)); } while (0)
124 # define DEBUGOUT_2(t,a,b)   do { if (debug_level) \
125                                   log_debug (DRVNAME t,(a),(b)); } while (0)
126 # define DEBUGOUT_3(t,a,b,c) do { if (debug_level) \
127                                   log_debug (DRVNAME t,(a),(b),(c));} while (0)
128 # define DEBUGOUT_4(t,a,b,c,d) do { if (debug_level) \
129                               log_debug (DRVNAME t,(a),(b),(c),(d));} while (0)
130 # define DEBUGOUT_CONT(t)    do { if (debug_level) \
131                                   log_printf (t); } while (0)
132 # define DEBUGOUT_CONT_1(t,a)  do { if (debug_level) \
133                                   log_printf (t,(a)); } while (0)
134 # define DEBUGOUT_CONT_2(t,a,b)   do { if (debug_level) \
135                                   log_printf (t,(a),(b)); } while (0)
136 # define DEBUGOUT_CONT_3(t,a,b,c) do { if (debug_level) \
137                                   log_printf (t,(a),(b),(c)); } while (0)
138 # define DEBUGOUT_LF()       do { if (debug_level) \
139                                   log_printf ("\n"); } while (0)
140
141 #else /* Other usage of this source - don't use gnupg specifics. */
142
143 # define DEBUGOUT(t)          do { if (debug_level) \
144                      fprintf (stderr, DRVNAME t); } while (0)
145 # define DEBUGOUT_1(t,a)      do { if (debug_level) \
146                      fprintf (stderr, DRVNAME t, (a)); } while (0)
147 # define DEBUGOUT_2(t,a,b)    do { if (debug_level) \
148                      fprintf (stderr, DRVNAME t, (a), (b)); } while (0)
149 # define DEBUGOUT_3(t,a,b,c)  do { if (debug_level) \
150                      fprintf (stderr, DRVNAME t, (a), (b), (c)); } while (0)
151 # define DEBUGOUT_4(t,a,b,c,d)  do { if (debug_level) \
152                      fprintf (stderr, DRVNAME t, (a), (b), (c), (d));} while(0)
153 # define DEBUGOUT_CONT(t)     do { if (debug_level) \
154                      fprintf (stderr, t); } while (0)
155 # define DEBUGOUT_CONT_1(t,a) do { if (debug_level) \
156                      fprintf (stderr, t, (a)); } while (0)
157 # define DEBUGOUT_CONT_2(t,a,b) do { if (debug_level) \
158                      fprintf (stderr, t, (a), (b)); } while (0)
159 # define DEBUGOUT_CONT_3(t,a,b,c) do { if (debug_level) \
160                      fprintf (stderr, t, (a), (b), (c)); } while (0)
161 # define DEBUGOUT_LF()        do { if (debug_level) \
162                      putc ('\n', stderr); } while (0)
163
164 #endif /* This source not used by scdaemon. */
165
166
167 #ifndef EAGAIN
168 #define EAGAIN  EWOULDBLOCK
169 #endif
170
171
172
173 enum {
174   RDR_to_PC_NotifySlotChange= 0x50,
175   RDR_to_PC_HardwareError   = 0x51,
176
177   PC_to_RDR_SetParameters   = 0x61,
178   PC_to_RDR_IccPowerOn      = 0x62,
179   PC_to_RDR_IccPowerOff     = 0x63,
180   PC_to_RDR_GetSlotStatus   = 0x65,
181   PC_to_RDR_Secure          = 0x69,
182   PC_to_RDR_T0APDU          = 0x6a,
183   PC_to_RDR_Escape          = 0x6b,
184   PC_to_RDR_GetParameters   = 0x6c,
185   PC_to_RDR_ResetParameters = 0x6d,
186   PC_to_RDR_IccClock        = 0x6e,
187   PC_to_RDR_XfrBlock        = 0x6f,
188   PC_to_RDR_Mechanical      = 0x71,
189   PC_to_RDR_Abort           = 0x72,
190   PC_to_RDR_SetDataRate     = 0x73,
191
192   RDR_to_PC_DataBlock       = 0x80,
193   RDR_to_PC_SlotStatus      = 0x81,
194   RDR_to_PC_Parameters      = 0x82,
195   RDR_to_PC_Escape          = 0x83,
196   RDR_to_PC_DataRate        = 0x84
197 };
198
199
200 /* Two macro to detect whether a CCID command has failed and to get
201    the error code.  These macros assume that we can access the
202    mandatory first 10 bytes of a CCID message in BUF. */
203 #define CCID_COMMAND_FAILED(buf) ((buf)[7] & 0x40)
204 #define CCID_ERROR_CODE(buf)     (((unsigned char *)(buf))[8])
205
206
207 /* We need to know the vendor to do some hacks. */
208 enum {
209   VENDOR_CHERRY = 0x046a,
210   VENDOR_SCM    = 0x04e6,
211   VENDOR_OMNIKEY= 0x076b,
212   VENDOR_GEMPC  = 0x08e6,
213   VENDOR_KAAN   = 0x0d46
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) | ((unsigned int)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     DEBUGOUT ("  junk             ");
924     for (i=54; i < buf[0]-54; i++)
925       DEBUGOUT_CONT_1 (" %02X", buf[i]);
926     DEBUGOUT_LF ();
927   }
928
929   if (!have_t1 || !(have_tpdu  || handle->apdu_level) || !have_auto_conf)
930     {
931       DEBUGOUT ("this drivers requires that the reader supports T=1, "
932                 "TPDU or APDU level exchange and auto configuration - "
933                 "this is not available\n");
934       return -1;
935     }
936
937
938   /* SCM drivers get stuck in their internal USB stack if they try to
939      send a frame of n*wMaxPacketSize back to us.  Given that
940      wMaxPacketSize is 64 for these readers we set the IFSD to a value
941      lower than that:
942         64 - 10 CCID header -  4 T1frame - 2 reserved = 48
943      Product Ids:
944          0xe001 - SCR 331 
945          0x5111 - SCR 331-DI 
946          0x5115 - SCR 335 
947          0xe003 - SPR 532 
948      The     
949          0x5117 - SCR 3320 USB ID-000 reader
950      seems to be very slow but enabling this workaround boosts the
951      performance to a a more or less acceptable level (tested by David). 
952          
953   */
954   if (handle->id_vendor == VENDOR_SCM
955       && handle->max_ifsd > 48      
956       && (  (handle->id_product == 0xe001 && handle->bcd_device < 0x0516)
957           ||(handle->id_product == 0x5111 && handle->bcd_device < 0x0620)
958           ||(handle->id_product == 0x5115 && handle->bcd_device < 0x0514)
959           ||(handle->id_product == 0xe003 && handle->bcd_device < 0x0504)
960           ||(handle->id_product == 0x5117 && handle->bcd_device < 0x0522)
961           ))
962     {
963       DEBUGOUT ("enabling workaround for buggy SCM readers\n");
964       handle->max_ifsd = 48;
965     }
966
967
968   return 0;
969 }
970
971
972 static char *
973 get_escaped_usb_string (usb_dev_handle *idev, int idx,
974                         const char *prefix, const char *suffix)
975 {
976   int rc;
977   unsigned char buf[280];
978   unsigned char *s;
979   unsigned int langid;
980   size_t i, n, len;
981   char *result;
982
983   if (!idx)
984     return NULL;
985
986   /* Fixme: The next line is for the current Valgrid without support
987      for USB IOCTLs. */
988   memset (buf, 0, sizeof buf);
989
990   /* First get the list of supported languages and use the first one.
991      If we do don't find it we try to use English.  Note that this is
992      all in a 2 bute Unicode encoding using little endian. */
993   rc = usb_control_msg (idev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
994                         (USB_DT_STRING << 8), 0, 
995                         (char*)buf, sizeof buf, 1000 /* ms timeout */);
996   if (rc < 4)
997     langid = 0x0409; /* English.  */
998   else
999     langid = (buf[3] << 8) | buf[2];
1000
1001   rc = usb_control_msg (idev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
1002                         (USB_DT_STRING << 8) + idx, langid,
1003                         (char*)buf, sizeof buf, 1000 /* ms timeout */);
1004   if (rc < 2 || buf[1] != USB_DT_STRING)
1005     return NULL; /* Error or not a string. */
1006   len = buf[0];
1007   if (len > rc)
1008     return NULL; /* Larger than our buffer. */
1009
1010   for (s=buf+2, i=2, n=0; i+1 < len; i += 2, s += 2)
1011     {
1012       if (s[1])
1013         n++; /* High byte set. */
1014       else if (*s <= 0x20 || *s >= 0x7f || *s == '%' || *s == ':')
1015         n += 3 ;
1016       else 
1017         n++;
1018     }
1019
1020   result = malloc (strlen (prefix) + n + strlen (suffix) + 1);
1021   if (!result)
1022     return NULL;
1023
1024   strcpy (result, prefix);
1025   n = strlen (prefix);
1026   for (s=buf+2, i=2; i+1 < len; i += 2, s += 2)
1027     {
1028       if (s[1])
1029         result[n++] = '\xff'; /* High byte set. */
1030       else if (*s <= 0x20 || *s >= 0x7f || *s == '%' || *s == ':')
1031         {
1032           sprintf (result+n, "%%%02X", *s);
1033           n += 3;
1034         }
1035       else 
1036         result[n++] = *s;
1037     }
1038   strcpy (result+n, suffix);
1039
1040   return result;
1041 }
1042
1043 /* This function creates an reader id to be used to find the same
1044    physical reader after a reset.  It returns an allocated and possibly
1045    percent escaped string or NULL if not enough memory is available. */
1046 static char *
1047 make_reader_id (usb_dev_handle *idev,
1048                 unsigned int vendor, unsigned int product,
1049                 unsigned char serialno_index)
1050 {
1051   char *rid;
1052   char prefix[20];
1053
1054   sprintf (prefix, "%04X:%04X:", (vendor & 0xffff), (product & 0xffff));
1055   rid = get_escaped_usb_string (idev, serialno_index, prefix, ":0");
1056   if (!rid)
1057     {
1058       rid = malloc (strlen (prefix) + 3 + 1);
1059       if (!rid)
1060         return NULL;
1061       strcpy (rid, prefix);
1062       strcat (rid, "X:0");
1063     }
1064   return rid;
1065 }
1066
1067
1068 /* Helper to find the endpoint from an interface descriptor.  */
1069 static int
1070 find_endpoint (struct usb_interface_descriptor *ifcdesc, int mode)
1071 {
1072   int no;
1073   int want_bulk_in = 0;
1074
1075   if (mode == 1)
1076     want_bulk_in = 0x80;
1077   for (no=0; no < ifcdesc->bNumEndpoints; no++)
1078     {
1079       struct usb_endpoint_descriptor *ep = ifcdesc->endpoint + no;
1080       if (ep->bDescriptorType != USB_DT_ENDPOINT)
1081         ;
1082       else if (mode == 2
1083           && ((ep->bmAttributes & USB_ENDPOINT_TYPE_MASK)
1084               == USB_ENDPOINT_TYPE_INTERRUPT)
1085           && (ep->bEndpointAddress & 0x80))
1086         return (ep->bEndpointAddress & 0x0f);
1087       else if (((ep->bmAttributes & USB_ENDPOINT_TYPE_MASK)
1088                 == USB_ENDPOINT_TYPE_BULK)
1089                && (ep->bEndpointAddress & 0x80) == want_bulk_in)
1090         return (ep->bEndpointAddress & 0x0f);
1091     }
1092   /* Should never happen.  */
1093   return mode == 2? 0x83 : mode == 1? 0x82 :1;
1094 }
1095
1096
1097 /* Helper for scan_or_find_devices. This function returns true if a
1098    requested device has been found or the caller should stop scanning
1099    for other reasons. */
1100 static int
1101 scan_or_find_usb_device (int scan_mode,
1102                          int *readerno, int *count, char **rid_list,
1103                          const char *readerid,
1104                          struct usb_device *dev,
1105                          char **r_rid,
1106                          struct usb_device **r_dev,
1107                          usb_dev_handle **r_idev,
1108                          unsigned char **ifcdesc_extra,
1109                          size_t *ifcdesc_extra_len,
1110                          int *interface_number,
1111                          int *ep_bulk_out, int *ep_bulk_in, int *ep_intr)
1112 {
1113   int cfg_no;
1114   int ifc_no;
1115   int set_no;
1116   struct usb_config_descriptor *config;
1117   struct usb_interface *interface;          
1118   struct usb_interface_descriptor *ifcdesc;
1119   char *rid;
1120   usb_dev_handle *idev;
1121
1122   *r_idev = NULL;
1123
1124   for (cfg_no=0; cfg_no < dev->descriptor.bNumConfigurations; cfg_no++)
1125     {
1126       config = dev->config + cfg_no;
1127       if(!config)
1128         continue;
1129
1130       for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
1131         {
1132           interface = config->interface + ifc_no;
1133           if (!interface)
1134             continue;
1135                   
1136           for (set_no=0; set_no < interface->num_altsetting; set_no++)
1137             {
1138               ifcdesc = (interface->altsetting + set_no);
1139               /* The second condition is for older SCM SPR 532 who did
1140                  not know about the assigned CCID class.  Instead of
1141                  trying to interpret the strings we simply check the
1142                  product ID. */
1143               if (ifcdesc && ifcdesc->extra
1144                   && ((ifcdesc->bInterfaceClass == 11
1145                        && ifcdesc->bInterfaceSubClass == 0
1146                        && ifcdesc->bInterfaceProtocol == 0)
1147                       || (ifcdesc->bInterfaceClass == 255
1148                           && dev->descriptor.idVendor == VENDOR_SCM
1149                           && dev->descriptor.idProduct == 0xe003)))
1150                 {
1151                   idev = usb_open (dev);
1152                   if (!idev)
1153                     {
1154                       DEBUGOUT_1 ("usb_open failed: %s\n",
1155                                   strerror (errno));
1156                       continue; /* with next setting. */
1157                     }
1158                   
1159                   rid = make_reader_id (idev,
1160                                         dev->descriptor.idVendor,
1161                                         dev->descriptor.idProduct,
1162                                         dev->descriptor.iSerialNumber);
1163                   if (rid)
1164                     {
1165                       if (scan_mode)
1166                         {
1167                           char *p;
1168                           
1169                           /* We are collecting infos about all
1170                              available CCID readers.  Store them and
1171                              continue. */
1172                           DEBUGOUT_2 ("found CCID reader %d (ID=%s)\n",
1173                                       *count, rid );
1174                           p = malloc ((*rid_list? strlen (*rid_list):0) + 1
1175                                       + strlen (rid) + 1);
1176                           if (p)
1177                             {
1178                               *p = 0;
1179                               if (*rid_list)
1180                                 {
1181                                   strcat (p, *rid_list);
1182                                   free (*rid_list);
1183                                 }
1184                               strcat (p, rid);
1185                               strcat (p, "\n");
1186                               *rid_list = p;
1187                             }
1188                           else /* Out of memory. */
1189                             free (rid);
1190                           
1191                           rid = NULL;
1192                           ++*count;
1193                         }
1194                       else if (!*readerno
1195                                || (*readerno < 0
1196                                    && readerid
1197                                    && !strcmp (readerid, rid)))
1198                         {
1199                           /* We found the requested reader. */
1200                           if (ifcdesc_extra && ifcdesc_extra_len)
1201                             {
1202                               *ifcdesc_extra = malloc (ifcdesc
1203                                                        ->extralen);
1204                               if (!*ifcdesc_extra)
1205                                 {
1206                                   usb_close (idev);
1207                                   free (rid);
1208                                   return 1; /* Out of core. */
1209                                 }
1210                               memcpy (*ifcdesc_extra, ifcdesc->extra,
1211                                       ifcdesc->extralen);
1212                               *ifcdesc_extra_len = ifcdesc->extralen;
1213                             }
1214
1215                           if (interface_number)
1216                             *interface_number = (ifcdesc->bInterfaceNumber);
1217
1218                           if (ep_bulk_out)
1219                             *ep_bulk_out = find_endpoint (ifcdesc, 0);
1220                           if (ep_bulk_in)
1221                             *ep_bulk_in = find_endpoint (ifcdesc, 1);
1222                           if (ep_intr)
1223                             *ep_intr = find_endpoint (ifcdesc, 2);
1224
1225                           if (r_dev)
1226                             *r_dev = dev;
1227                           if (r_rid)
1228                             {
1229                               *r_rid = rid;
1230                               rid = NULL;
1231                             }
1232                           else
1233                             free (rid);
1234                           
1235                           *r_idev = idev;
1236                           return 1; /* Found requested device. */
1237                         }
1238                       else
1239                         {
1240                           /* This is not yet the reader we want.
1241                              fixme: We should avoid the extra usb_open
1242                              in this case. */
1243                           if (*readerno >= 0)
1244                             --*readerno;
1245                         }
1246                       free (rid);
1247                     }
1248                   
1249                   usb_close (idev);
1250                   idev = NULL;
1251                   return 0;
1252                 }
1253             }
1254         }
1255     }
1256
1257   return 0;
1258 }
1259
1260 /* Combination function to either scan all CCID devices or to find and
1261    open one specific device. 
1262
1263    The function returns 0 if a reader has been found or when a scan
1264    returned without error.
1265
1266    With READERNO = -1 and READERID is NULL, scan mode is used and
1267    R_RID should be the address where to store the list of reader_ids
1268    we found.  If on return this list is empty, no CCID device has been
1269    found; otherwise it points to an allocated linked list of reader
1270    IDs.  Note that in this mode the function always returns NULL.
1271
1272    With READERNO >= 0 or READERID is not NULL find mode is used.  This
1273    uses the same algorithm as the scan mode but stops and returns at
1274    the entry number READERNO and return the handle for the the opened
1275    USB device. If R_RID is not NULL it will receive the reader ID of
1276    that device.  If R_DEV is not NULL it will the device pointer of
1277    that device.  If IFCDESC_EXTRA is NOT NULL it will receive a
1278    malloced copy of the interfaces "extra: data filed;
1279    IFCDESC_EXTRA_LEN receive the length of this field.  If there is
1280    no reader with number READERNO or that reader is not usable by our
1281    implementation NULL will be returned.  The caller must close a
1282    returned USB device handle and free (if not passed as NULL) the
1283    returned reader ID info as well as the IFCDESC_EXTRA.  On error
1284    NULL will get stored at R_RID, R_DEV, IFCDESC_EXTRA and
1285    IFCDESC_EXTRA_LEN.  With READERID being -1 the function stops if
1286    the READERID was found.
1287
1288    If R_FD is not -1 on return the device is not using USB for
1289    transport but the device associated with that file descriptor.  In
1290    this case INTERFACE will receive the transport type and the other
1291    USB specific return values are not used; the return value is
1292    (void*)(1).
1293
1294    Note that the first entry of the returned reader ID list in scan mode
1295    corresponds with a READERNO of 0 in find mode.
1296 */
1297 static int
1298 scan_or_find_devices (int readerno, const char *readerid,
1299                       char **r_rid,
1300                       struct usb_device **r_dev,
1301                       unsigned char **ifcdesc_extra,
1302                       size_t *ifcdesc_extra_len,
1303                       int *interface_number,
1304                       int *ep_bulk_out, int *ep_bulk_in, int *ep_intr,
1305                       usb_dev_handle **r_idev,
1306                       int *r_fd)
1307 {
1308   char *rid_list = NULL;
1309   int count = 0;
1310   struct usb_bus *busses, *bus;
1311   struct usb_device *dev = NULL;
1312   usb_dev_handle *idev = NULL;
1313   int scan_mode = (readerno == -1 && !readerid);
1314   int i;
1315
1316   /* Set return values to a default. */
1317   if (r_rid)
1318     *r_rid = NULL;
1319   if (r_dev)
1320     *r_dev = NULL; 
1321   if (ifcdesc_extra)
1322     *ifcdesc_extra = NULL;
1323   if (ifcdesc_extra_len)
1324     *ifcdesc_extra_len = 0;
1325   if (interface_number)
1326     *interface_number = 0;
1327   if (r_idev)
1328     *r_idev = NULL;
1329   if (r_fd)
1330     *r_fd = -1;
1331
1332   /* See whether we want scan or find mode. */
1333   if (scan_mode) 
1334     {
1335       assert (r_rid);
1336     }
1337
1338   usb_find_busses();
1339   usb_find_devices();
1340
1341 #ifdef HAVE_USB_GET_BUSSES
1342   busses = usb_get_busses();
1343 #else
1344   busses = usb_busses;
1345 #endif
1346
1347   for (bus = busses; bus; bus = bus->next) 
1348     {
1349       for (dev = bus->devices; dev; dev = dev->next)
1350         {
1351           if (scan_or_find_usb_device (scan_mode, &readerno, &count, &rid_list,
1352                                        readerid,
1353                                        dev,
1354                                        r_rid,
1355                                        r_dev,
1356                                        &idev,
1357                                        ifcdesc_extra,
1358                                        ifcdesc_extra_len,
1359                                        interface_number,
1360                                        ep_bulk_out, ep_bulk_in, ep_intr))
1361             {
1362               /* Found requested device or out of core. */
1363               if (!idev)
1364                 {
1365                   free (rid_list);
1366                   return -1; /* error */
1367                 }
1368               *r_idev = idev;
1369               return 0; 
1370             }
1371         }
1372     }
1373
1374   /* Now check whether there are any devices with special transport types. */
1375   for (i=0; transports[i].name; i++)
1376     {
1377       int fd;
1378       char *rid, *p;
1379
1380       fd = open (transports[i].name, O_RDWR);
1381       if (fd == -1 && scan_mode && errno == EBUSY)
1382         {
1383           /* Ignore this error in scan mode because it indicates that
1384              the device exists but is already open (most likely by us)
1385              and thus in general suitable as a reader.  */
1386         }
1387       else if (fd == -1)
1388         {
1389           DEBUGOUT_2 ("failed to open `%s': %s\n",
1390                      transports[i].name, strerror (errno));
1391           continue;
1392         }
1393
1394       rid = malloc (strlen (transports[i].name) + 30 + 10);
1395       if (!rid)
1396         {
1397           if (fd != -1)
1398             close (fd);
1399           free (rid_list);
1400           return -1; /* Error. */
1401         }
1402       sprintf (rid, "0000:%04X:%s:0", transports[i].type, transports[i].name);
1403       if (scan_mode)
1404         {
1405           DEBUGOUT_2 ("found CCID reader %d (ID=%s)\n", count, rid);
1406           p = malloc ((rid_list? strlen (rid_list):0) + 1 + strlen (rid) + 1);
1407           if (!p)
1408             {
1409               if (fd != -1)
1410                 close (fd);
1411               free (rid_list);
1412               free (rid);
1413               return -1; /* Error. */
1414             }
1415           *p = 0;
1416           if (rid_list)
1417             {
1418               strcat (p, rid_list);
1419               free (rid_list);
1420             }
1421           strcat (p, rid);
1422           strcat (p, "\n");
1423           rid_list = p;
1424           ++count;
1425         }
1426       else if (!readerno ||
1427                (readerno < 0 && readerid && !strcmp (readerid, rid)))
1428         {
1429           /* Found requested device. */
1430           if (interface_number)
1431             *interface_number = transports[i].type;
1432           if (r_rid)
1433             *r_rid = rid;
1434           else
1435             free (rid);
1436           if (r_fd)
1437             *r_fd = fd;
1438           return 0; /* Okay, found device */
1439         }
1440       else /* This is not yet the reader we want. */
1441         {
1442           if (readerno >= 0)
1443             --readerno;
1444         }
1445       free (rid);
1446       if (fd != -1)
1447         close (fd);
1448     }
1449
1450   if (scan_mode)
1451     {
1452       *r_rid = rid_list;
1453       return 0;
1454     }
1455   else
1456     return -1;
1457 }
1458
1459
1460 /* Set the level of debugging to LEVEL and return the old level.  -1
1461    just returns the old level.  A level of 0 disables debugging, 1
1462    enables debugging, 2 enables additional tracing of the T=1
1463    protocol, 3 additionally enables debugging for GetSlotStatus, other
1464    values are not yet defined.
1465
1466    Note that libusb may provide its own debugging feature which is
1467    enabled by setting the envvar USB_DEBUG.  */
1468 int
1469 ccid_set_debug_level (int level)
1470 {
1471   int old = debug_level;
1472   if (level != -1)
1473     debug_level = level;
1474   return old;
1475 }
1476
1477
1478 char *
1479 ccid_get_reader_list (void)
1480 {
1481   char *reader_list;
1482
1483   if (!initialized_usb)
1484     {
1485       usb_init ();
1486       initialized_usb = 1;
1487     }
1488
1489   if (scan_or_find_devices (-1, NULL, &reader_list, NULL, NULL, NULL, NULL,
1490                             NULL, NULL, NULL, NULL, NULL))
1491     return NULL; /* Error. */
1492   return reader_list;
1493 }
1494
1495
1496 /* Open the reader with the internal number READERNO and return a 
1497    pointer to be used as handle in HANDLE.  Returns 0 on success. */
1498 int 
1499 ccid_open_reader (ccid_driver_t *handle, const char *readerid)
1500 {
1501   int rc = 0;
1502   struct usb_device *dev = NULL;
1503   usb_dev_handle *idev = NULL;
1504   int dev_fd = -1;
1505   char *rid = NULL;
1506   unsigned char *ifcdesc_extra = NULL;
1507   size_t ifcdesc_extra_len;
1508   int readerno;
1509   int ifc_no, ep_bulk_out, ep_bulk_in, ep_intr;
1510
1511   *handle = NULL;
1512
1513   if (!initialized_usb)
1514     {
1515       usb_init ();
1516       initialized_usb = 1;
1517     }
1518
1519   /* See whether we want to use the reader ID string or a reader
1520      number. A readerno of -1 indicates that the reader ID string is
1521      to be used. */
1522   if (readerid && strchr (readerid, ':'))
1523     readerno = -1; /* We want to use the readerid.  */
1524   else if (readerid)
1525     {
1526       readerno = atoi (readerid);
1527       if (readerno < 0)
1528         {
1529           DEBUGOUT ("no CCID readers found\n");
1530           rc = CCID_DRIVER_ERR_NO_READER;
1531           goto leave;
1532         }
1533     }
1534   else
1535     readerno = 0;  /* Default. */
1536
1537   if (scan_or_find_devices (readerno, readerid, &rid, &dev,
1538                             &ifcdesc_extra, &ifcdesc_extra_len,
1539                             &ifc_no, &ep_bulk_out, &ep_bulk_in, &ep_intr,
1540                             &idev, &dev_fd) )
1541     {
1542       if (readerno == -1)
1543         DEBUGOUT_1 ("no CCID reader with ID %s\n", readerid );
1544       else
1545         DEBUGOUT_1 ("no CCID reader with number %d\n", readerno );
1546       rc = CCID_DRIVER_ERR_NO_READER;
1547       goto leave;
1548     }
1549
1550   /* Okay, this is a CCID reader. */
1551   *handle = calloc (1, sizeof **handle);
1552   if (!*handle)
1553     {
1554       DEBUGOUT ("out of memory\n");
1555       rc = CCID_DRIVER_ERR_OUT_OF_CORE;
1556       goto leave;
1557     }
1558   (*handle)->rid = rid;
1559   if (idev) /* Regular USB transport. */
1560     {
1561       (*handle)->idev = idev;
1562       (*handle)->dev_fd = -1;
1563       (*handle)->id_vendor = dev->descriptor.idVendor;
1564       (*handle)->id_product = dev->descriptor.idProduct;
1565       (*handle)->bcd_device = dev->descriptor.bcdDevice;
1566       (*handle)->ifc_no = ifc_no;
1567       (*handle)->ep_bulk_out = ep_bulk_out;
1568       (*handle)->ep_bulk_in = ep_bulk_in;
1569       (*handle)->ep_intr = ep_intr;
1570     }
1571   else if (dev_fd != -1) /* Device transport. */
1572     {
1573       (*handle)->idev = NULL;
1574       (*handle)->dev_fd = dev_fd;
1575       (*handle)->id_vendor = 0;  /* Magic vendor for special transport. */
1576       (*handle)->id_product = ifc_no; /* Transport type */
1577       prepare_special_transport (*handle);
1578     }
1579   else
1580     {
1581       assert (!"no transport"); /* Bug. */
1582     }
1583
1584   DEBUGOUT_2 ("using CCID reader %d (ID=%s)\n",  readerno, rid );
1585
1586   if (idev)
1587     {
1588       if (parse_ccid_descriptor (*handle, ifcdesc_extra, ifcdesc_extra_len))
1589         {
1590           DEBUGOUT ("device not supported\n");
1591           rc = CCID_DRIVER_ERR_NO_READER;
1592           goto leave;
1593         }
1594       
1595       rc = usb_claim_interface (idev, ifc_no);
1596       if (rc)
1597         {
1598           DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
1599           rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1600           goto leave;
1601         }
1602     }
1603
1604  leave:
1605   free (ifcdesc_extra);
1606   if (rc)
1607     {
1608       free (rid);
1609       if (idev)
1610         usb_close (idev);
1611       if (dev_fd != -1)
1612         close (dev_fd);
1613       free (*handle);
1614       *handle = NULL;
1615     }
1616
1617   return rc;
1618 }
1619
1620
1621 static void
1622 do_close_reader (ccid_driver_t handle)
1623 {
1624   int rc;
1625   unsigned char msg[100];
1626   size_t msglen;
1627   unsigned char seqno;
1628   
1629   if (!handle->powered_off)
1630     {
1631       msg[0] = PC_to_RDR_IccPowerOff;
1632       msg[5] = 0; /* slot */
1633       msg[6] = seqno = handle->seqno++;
1634       msg[7] = 0; /* RFU */
1635       msg[8] = 0; /* RFU */
1636       msg[9] = 0; /* RFU */
1637       set_msg_len (msg, 0);
1638       msglen = 10;
1639       
1640       rc = bulk_out (handle, msg, msglen, 0);
1641       if (!rc)
1642         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
1643                  seqno, 2000, 0);
1644       handle->powered_off = 1;
1645     }
1646   if (handle->idev)
1647     {
1648       usb_release_interface (handle->idev, handle->ifc_no);
1649       usb_close (handle->idev);
1650       handle->idev = NULL;
1651     }
1652   if (handle->dev_fd != -1)
1653     {
1654       close (handle->dev_fd);
1655       handle->dev_fd = -1;
1656     }
1657 }
1658
1659
1660 /* Reset a reader on HANDLE.  This is useful in case a reader has been
1661    plugged of and inserted at a different port.  By resetting the
1662    handle, the same reader will be get used.  Note, that on error the
1663    handle won't get released. 
1664
1665    This does not return an ATR, so ccid_get_atr should be called right
1666    after this one.
1667 */
1668 int 
1669 ccid_shutdown_reader (ccid_driver_t handle)
1670 {
1671   int rc = 0;
1672   struct usb_device *dev = NULL;
1673   usb_dev_handle *idev = NULL;
1674   unsigned char *ifcdesc_extra = NULL;
1675   size_t ifcdesc_extra_len;
1676   int ifc_no, ep_bulk_out, ep_bulk_in, ep_intr;
1677
1678   if (!handle || !handle->rid)
1679     return CCID_DRIVER_ERR_INV_VALUE;
1680
1681   do_close_reader (handle);
1682
1683   if (scan_or_find_devices (-1, handle->rid, NULL, &dev,
1684                             &ifcdesc_extra, &ifcdesc_extra_len,
1685                             &ifc_no, &ep_bulk_out, &ep_bulk_in, &ep_intr,
1686                             &idev, NULL) || !idev)
1687     {
1688       DEBUGOUT_1 ("no CCID reader with ID %s\n", handle->rid);
1689       return CCID_DRIVER_ERR_NO_READER;
1690     }
1691
1692   if (idev)
1693     {
1694       handle->idev = idev;
1695       handle->ifc_no = ifc_no;
1696       handle->ep_bulk_out = ep_bulk_out;
1697       handle->ep_bulk_in = ep_bulk_in;
1698       handle->ep_intr = ep_intr;
1699
1700       if (parse_ccid_descriptor (handle, ifcdesc_extra, ifcdesc_extra_len))
1701         {
1702           DEBUGOUT ("device not supported\n");
1703           rc = CCID_DRIVER_ERR_NO_READER;
1704           goto leave;
1705         }
1706       
1707       rc = usb_claim_interface (idev, ifc_no);
1708       if (rc)
1709         {
1710           DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
1711           rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1712           goto leave;
1713         }
1714     }
1715
1716  leave:
1717   free (ifcdesc_extra);
1718   if (rc)
1719     {
1720       if (handle->idev)
1721         usb_close (handle->idev);
1722       handle->idev = NULL;
1723       if (handle->dev_fd != -1)
1724         close (handle->dev_fd);
1725       handle->dev_fd = -1;
1726     }
1727
1728   return rc;
1729
1730 }
1731
1732
1733 int 
1734 ccid_set_progress_cb (ccid_driver_t handle, 
1735                       void (*cb)(void *, const char *, int, int, int),
1736                       void *cb_arg)
1737 {
1738   if (!handle || !handle->rid)
1739     return CCID_DRIVER_ERR_INV_VALUE;
1740
1741   handle->progress_cb = cb;
1742   handle->progress_cb_arg = cb_arg;
1743   return 0;
1744 }
1745
1746
1747 /* Close the reader HANDLE. */
1748 int 
1749 ccid_close_reader (ccid_driver_t handle)
1750 {
1751   if (!handle || (!handle->idev && handle->dev_fd == -1))
1752     return 0;
1753
1754   do_close_reader (handle);
1755   free (handle->rid);
1756   free (handle);
1757   return 0;
1758 }
1759
1760
1761 /* Return False if a card is present and powered. */
1762 int
1763 ccid_check_card_presence (ccid_driver_t handle)
1764 {
1765   (void)handle;  /* Not yet implemented.  */
1766   return -1;
1767 }
1768
1769
1770 /* Write NBYTES of BUF to file descriptor FD. */
1771 static int
1772 writen (int fd, const void *buf, size_t nbytes)
1773 {
1774   size_t nleft = nbytes;
1775   int nwritten;
1776   
1777   while (nleft > 0)
1778     {
1779       nwritten = write (fd, buf, nleft);
1780       if (nwritten < 0)
1781         {
1782           if (errno == EINTR)
1783             nwritten = 0;
1784           else
1785             return -1;
1786         }
1787       nleft -= nwritten;
1788       buf = (const char*)buf + nwritten;
1789     }
1790     
1791   return 0;
1792 }
1793
1794
1795 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
1796    Returns 0 on success. */
1797 static int
1798 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen,
1799           int no_debug)
1800 {
1801   int rc;
1802
1803   /* No need to continue and clutter the log with USB write error
1804      messages after we got the first ENODEV.  */
1805   if (handle->enodev_seen)
1806     return CCID_DRIVER_ERR_NO_READER;
1807
1808   if (debug_level && (!no_debug || debug_level >= 3))
1809     {
1810       switch (msglen? msg[0]:0)
1811         {
1812         case PC_to_RDR_IccPowerOn:
1813           print_p2r_iccpoweron (msg, msglen);
1814           break;
1815         case PC_to_RDR_IccPowerOff:
1816           print_p2r_iccpoweroff (msg, msglen);
1817           break;
1818         case PC_to_RDR_GetSlotStatus:
1819           print_p2r_getslotstatus (msg, msglen);
1820           break;
1821         case PC_to_RDR_XfrBlock:
1822           print_p2r_xfrblock (msg, msglen);
1823           break;
1824         case PC_to_RDR_GetParameters:
1825           print_p2r_getparameters (msg, msglen);
1826           break;
1827         case PC_to_RDR_ResetParameters:
1828           print_p2r_resetparameters (msg, msglen);
1829           break;
1830         case PC_to_RDR_SetParameters:
1831           print_p2r_setparameters (msg, msglen);
1832           break;
1833         case PC_to_RDR_Escape:
1834           print_p2r_escape (msg, msglen);
1835           break;
1836         case PC_to_RDR_IccClock:
1837           print_p2r_iccclock (msg, msglen);
1838           break;
1839         case PC_to_RDR_T0APDU:
1840           print_p2r_to0apdu (msg, msglen);
1841           break;
1842         case PC_to_RDR_Secure:
1843           print_p2r_secure (msg, msglen);
1844           break;
1845         case PC_to_RDR_Mechanical:
1846           print_p2r_mechanical (msg, msglen);
1847           break;
1848         case PC_to_RDR_Abort:
1849           print_p2r_abort (msg, msglen);
1850           break;
1851         case PC_to_RDR_SetDataRate:
1852           print_p2r_setdatarate (msg, msglen);
1853           break;
1854         default:
1855           print_p2r_unknown (msg, msglen);
1856           break;
1857         }
1858     }
1859   
1860   if (handle->idev)
1861     {
1862       rc = usb_bulk_write (handle->idev, 
1863                            handle->ep_bulk_out,
1864                            (char*)msg, msglen,
1865                            5000 /* ms timeout */);
1866       if (rc == msglen)
1867         return 0;
1868 #ifdef ENODEV
1869       if (rc == -(ENODEV))
1870         {
1871           /* The Linux libusb returns a negative error value.  Catch
1872              the most important one.  */
1873           errno = ENODEV;
1874           rc = -1;
1875         }
1876 #endif /*ENODEV*/
1877
1878       if (rc == -1)
1879         {
1880           DEBUGOUT_1 ("usb_bulk_write error: %s\n", strerror (errno));
1881 #ifdef ENODEV
1882           if (errno == ENODEV)
1883             {
1884               handle->enodev_seen = 1;
1885               return CCID_DRIVER_ERR_NO_READER;
1886             }
1887 #endif /*ENODEV*/
1888         }
1889       else
1890         DEBUGOUT_1 ("usb_bulk_write failed: %d\n", rc);
1891     }
1892   else
1893     {
1894       rc = writen (handle->dev_fd, msg, msglen);
1895       if (!rc)
1896         return 0;
1897       DEBUGOUT_2 ("writen to %d failed: %s\n",
1898                   handle->dev_fd, strerror (errno));
1899       
1900     }
1901   return CCID_DRIVER_ERR_CARD_IO_ERROR;
1902 }
1903
1904
1905 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
1906    BUFFER and return the actual read number if bytes in NREAD. SEQNO
1907    is the sequence number used to send the request and EXPECTED_TYPE
1908    the type of message we expect. Does checks on the ccid
1909    header. TIMEOUT is the timeout value in ms. NO_DEBUG may be set to
1910    avoid debug messages in case of no error; this can be overriden
1911    with a glibal debug level of at least 3. Returns 0 on success. */
1912 static int
1913 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
1914          size_t *nread, int expected_type, int seqno, int timeout,
1915          int no_debug)
1916 {
1917   int rc;
1918   size_t msglen;
1919   int eagain_retries = 0;
1920
1921   /* Fixme: The next line for the current Valgrind without support
1922      for USB IOCTLs. */
1923   memset (buffer, 0, length);
1924  retry:
1925   if (handle->idev)
1926     {
1927       rc = usb_bulk_read (handle->idev, 
1928                           handle->ep_bulk_in,
1929                           (char*)buffer, length,
1930                           timeout);
1931       if (rc < 0)
1932         {
1933           rc = errno;
1934           DEBUGOUT_1 ("usb_bulk_read error: %s\n", strerror (rc));
1935           if (rc == EAGAIN && eagain_retries++ < 3)
1936             {
1937               my_sleep (1);
1938               goto retry;
1939             }
1940           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1941         }
1942       *nread = msglen = rc;
1943     }
1944   else
1945     {
1946       rc = read (handle->dev_fd, buffer, length);
1947       if (rc < 0)
1948         {
1949           rc = errno;
1950           DEBUGOUT_2 ("read from %d failed: %s\n",
1951                       handle->dev_fd, strerror (rc));
1952           if (rc == EAGAIN && eagain_retries++ < 5)
1953             {
1954               my_sleep (1);
1955               goto retry;
1956             }
1957           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1958         }
1959       *nread = msglen = rc;
1960     }
1961   eagain_retries = 0;
1962
1963   if (msglen < 10)
1964     {
1965       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
1966       abort_cmd (handle, seqno);
1967       return CCID_DRIVER_ERR_INV_VALUE;
1968     }
1969   if (buffer[5] != 0)    
1970     {
1971       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
1972       return CCID_DRIVER_ERR_INV_VALUE;
1973     }
1974   if (buffer[6] != seqno)    
1975     {
1976       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
1977                   seqno, buffer[6]);
1978       /* Retry until we are synced again.  */
1979       goto retry;
1980     }
1981
1982   /* We need to handle the time extension request before we check that
1983      we got the expected message type.  This is in particular required
1984      for the Cherry keyboard which sends a time extension request for
1985      each key hit.  */
1986   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
1987     { 
1988       /* Card present and active, time extension requested. */
1989       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
1990                   buffer[7], buffer[8]);
1991       goto retry;
1992     }
1993
1994   if (buffer[0] != expected_type)
1995     {
1996       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
1997       abort_cmd (handle, seqno);
1998       return CCID_DRIVER_ERR_INV_VALUE;
1999     }
2000
2001   if (debug_level && (!no_debug || debug_level >= 3))
2002     {
2003       switch (buffer[0])
2004         {
2005         case RDR_to_PC_DataBlock:
2006           print_r2p_datablock (buffer, msglen);
2007           break;
2008         case RDR_to_PC_SlotStatus:
2009           print_r2p_slotstatus (buffer, msglen);
2010           break;
2011         case RDR_to_PC_Parameters:
2012           print_r2p_parameters (buffer, msglen);
2013           break;
2014         case RDR_to_PC_Escape:
2015           print_r2p_escape (buffer, msglen);
2016           break;
2017         case RDR_to_PC_DataRate:
2018           print_r2p_datarate (buffer, msglen);
2019           break;
2020         default:
2021           print_r2p_unknown (buffer, msglen);
2022           break;
2023         }
2024     }
2025   if (CCID_COMMAND_FAILED (buffer))
2026     print_command_failed (buffer);
2027
2028   /* Check whether a card is at all available.  Note: If you add new
2029      error codes here, check whether they need to be ignored in
2030      send_escape_cmd. */
2031   switch ((buffer[7] & 0x03))
2032     {
2033     case 0: /* no error */ break;
2034     case 1: return CCID_DRIVER_ERR_CARD_INACTIVE;
2035     case 2: return CCID_DRIVER_ERR_NO_CARD;
2036     case 3: /* RFU */ break;
2037     }
2038   return 0;
2039 }
2040
2041
2042
2043 /* Send an abort sequence and wait until everything settled.  */
2044 static int
2045 abort_cmd (ccid_driver_t handle, int seqno)
2046 {
2047   int rc;
2048   char dummybuf[8];
2049   unsigned char msg[100];
2050   size_t msglen;
2051
2052   if (!handle->idev)
2053     {
2054       /* I don't know how to send an abort to non-USB devices.  */
2055       rc = CCID_DRIVER_ERR_NOT_SUPPORTED;
2056     }
2057   
2058   seqno &= 0xff;
2059   DEBUGOUT_1 ("sending abort sequence for seqno %d\n", seqno);
2060   /* Send the abort command to the control pipe.  Note that we don't
2061      need to keep track of sent abort commands because there should
2062      never be another thread using the same slot concurrently.  */
2063   rc = usb_control_msg (handle->idev, 
2064                         0x21,/* bmRequestType: host-to-device,
2065                                 class specific, to interface.  */
2066                         1,   /* ABORT */
2067                         (seqno << 8 | 0 /* slot */),
2068                         handle->ifc_no,
2069                         dummybuf, 0,
2070                         1000 /* ms timeout */);
2071   if (rc < 0)
2072     {
2073       DEBUGOUT_1 ("usb_control_msg error: %s\n", strerror (errno));
2074       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2075     }
2076
2077   /* Now send the abort command to the bulk out pipe using the same
2078      SEQNO and SLOT.  Do this in a loop to so that all seqno are
2079      tried.  */
2080   seqno--;  /* Adjust for next increment.  */
2081   do
2082     {
2083       seqno++; 
2084       msg[0] = PC_to_RDR_Abort;
2085       msg[5] = 0; /* slot */
2086       msg[6] = seqno;
2087       msg[7] = 0; /* RFU */
2088       msg[8] = 0; /* RFU */
2089       msg[9] = 0; /* RFU */
2090       msglen = 10;
2091       set_msg_len (msg, 0);
2092
2093       rc = usb_bulk_write (handle->idev, 
2094                            handle->ep_bulk_out,
2095                            (char*)msg, msglen,
2096                            5000 /* ms timeout */);
2097       if (rc == msglen)
2098         rc = 0;
2099       else if (rc == -1)
2100         DEBUGOUT_1 ("usb_bulk_write error in abort_cmd: %s\n", 
2101                     strerror (errno));
2102       else
2103         DEBUGOUT_1 ("usb_bulk_write failed in abort_cmd: %d\n", rc);
2104
2105       if (rc)
2106         return rc;
2107       
2108       rc = usb_bulk_read (handle->idev, 
2109                           handle->ep_bulk_in,
2110                           (char*)msg, sizeof msg, 
2111                           5000 /*ms timeout*/);
2112       if (rc < 0)
2113         {
2114           DEBUGOUT_1 ("usb_bulk_read error in abort_cmd: %s\n",
2115                       strerror (errno));
2116           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2117         }
2118       msglen = rc;
2119
2120       if (msglen < 10)
2121         {
2122           DEBUGOUT_1 ("bulk-in msg in abort_cmd too short (%u)\n",
2123                       (unsigned int)msglen);
2124           return CCID_DRIVER_ERR_INV_VALUE;
2125         }
2126       if (msg[5] != 0)    
2127         {
2128           DEBUGOUT_1 ("unexpected bulk-in slot (%d) in abort_cmd\n", msg[5]);
2129           return CCID_DRIVER_ERR_INV_VALUE;
2130         }
2131
2132       DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n",
2133                   msg[7], msg[8], msg[9]);
2134       if (CCID_COMMAND_FAILED (msg))
2135         print_command_failed (msg);
2136     }
2137   while (msg[0] != RDR_to_PC_SlotStatus && msg[5] != 0 && msg[6] != seqno);
2138
2139   handle->seqno = ((seqno + 1) & 0xff);
2140   DEBUGOUT ("sending abort sequence succeeded\n");
2141
2142   return 0;
2143 }
2144
2145
2146 /* Note that this function won't return the error codes NO_CARD or
2147    CARD_INACTIVE.  IF RESULT is not NULL, the result from the
2148    operation will get returned in RESULT and its length in RESULTLEN.
2149    If the response is larger than RESULTMAX, an error is returned and
2150    the required buffer length returned in RESULTLEN.  */
2151 static int 
2152 send_escape_cmd (ccid_driver_t handle,
2153                  const unsigned char *data, size_t datalen,
2154                  unsigned char *result, size_t resultmax, size_t *resultlen)
2155 {
2156   int rc;
2157   unsigned char msg[100];
2158   size_t msglen;
2159   unsigned char seqno;
2160
2161   if (resultlen)
2162     *resultlen = 0;
2163
2164   if (datalen > sizeof msg - 10)
2165     return CCID_DRIVER_ERR_INV_VALUE; /* Escape data too large.  */
2166
2167   msg[0] = PC_to_RDR_Escape;
2168   msg[5] = 0; /* slot */
2169   msg[6] = seqno = handle->seqno++;
2170   msg[7] = 0; /* RFU */
2171   msg[8] = 0; /* RFU */
2172   msg[9] = 0; /* RFU */
2173   memcpy (msg+10, data, datalen);
2174   msglen = 10 + datalen;
2175   set_msg_len (msg, datalen);
2176
2177   rc = bulk_out (handle, msg, msglen, 0);
2178   if (rc)
2179     return rc;
2180   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Escape,
2181                 seqno, 5000, 0);
2182   if (result)
2183     switch (rc)
2184       {
2185         /* We need to ignore certain errorcode here. */
2186       case 0:
2187       case CCID_DRIVER_ERR_CARD_INACTIVE:
2188       case CCID_DRIVER_ERR_NO_CARD:
2189         {
2190           if (msglen > resultmax)
2191             rc = CCID_DRIVER_ERR_INV_VALUE; /* Response too large. */
2192           else
2193             {
2194               memcpy (result, msg, msglen);
2195               *resultlen = msglen;
2196             }
2197           rc = 0;
2198         }
2199         break;
2200       default:
2201         break;
2202       }
2203   
2204   return rc;
2205 }
2206
2207
2208 int
2209 ccid_transceive_escape (ccid_driver_t handle,
2210                         const unsigned char *data, size_t datalen,
2211                         unsigned char *resp, size_t maxresplen, size_t *nresp)
2212 {
2213   return send_escape_cmd (handle, data, datalen, resp, maxresplen, nresp);
2214 }
2215
2216
2217
2218 /* experimental */
2219 int
2220 ccid_poll (ccid_driver_t handle)
2221 {
2222   int rc;
2223   unsigned char msg[10];
2224   size_t msglen;
2225   int i, j;
2226
2227   if (handle->idev)
2228     {
2229       rc = usb_bulk_read (handle->idev, 
2230                           handle->ep_intr,
2231                           (char*)msg, sizeof msg,
2232                           0 /* ms timeout */ );
2233       if (rc < 0 && errno == ETIMEDOUT)
2234         return 0;
2235     }
2236   else 
2237     return 0;
2238
2239   if (rc < 0)
2240     {
2241       DEBUGOUT_1 ("usb_intr_read error: %s\n", strerror (errno));
2242       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2243     }
2244
2245   msglen = rc;
2246   rc = 0;
2247
2248   if (msglen < 1)
2249     {
2250       DEBUGOUT ("intr-in msg too short\n");
2251       return CCID_DRIVER_ERR_INV_VALUE;
2252     }
2253
2254   if (msg[0] == RDR_to_PC_NotifySlotChange)
2255     {
2256       DEBUGOUT ("notify slot change:");
2257       for (i=1; i < msglen; i++)
2258         for (j=0; j < 4; j++)
2259           DEBUGOUT_CONT_3 (" %d:%c%c",
2260                            (i-1)*4+j, 
2261                            (msg[i] & (1<<(j*2)))? 'p':'-',
2262                            (msg[i] & (2<<(j*2)))? '*':' ');
2263       DEBUGOUT_LF ();
2264     }
2265   else if (msg[0] == RDR_to_PC_HardwareError)    
2266     {
2267       DEBUGOUT ("hardware error occured\n");
2268     }
2269   else
2270     {
2271       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
2272     }
2273
2274   return 0;
2275 }
2276
2277
2278 /* Note that this function won't return the error codes NO_CARD or
2279    CARD_INACTIVE */
2280 int 
2281 ccid_slot_status (ccid_driver_t handle, int *statusbits)
2282 {
2283   int rc;
2284   unsigned char msg[100];
2285   size_t msglen;
2286   unsigned char seqno;
2287   int retries = 0;
2288
2289  retry:
2290   msg[0] = PC_to_RDR_GetSlotStatus;
2291   msg[5] = 0; /* slot */
2292   msg[6] = seqno = handle->seqno++;
2293   msg[7] = 0; /* RFU */
2294   msg[8] = 0; /* RFU */
2295   msg[9] = 0; /* RFU */
2296   set_msg_len (msg, 0);
2297
2298   rc = bulk_out (handle, msg, 10, 1);
2299   if (rc)
2300     return rc;
2301   /* Note that we set the NO_DEBUG flag here, so that the logs won't
2302      get cluttered up by a ticker function checking for the slot
2303      status and debugging enabled. */
2304   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
2305                 seqno, retries? 1000 : 200, 1);
2306   if (rc == CCID_DRIVER_ERR_CARD_IO_ERROR && retries < 3)
2307     {
2308       if (!retries)
2309         {
2310           DEBUGOUT ("USB: CALLING USB_CLEAR_HALT\n");
2311           usb_clear_halt (handle->idev, handle->ep_bulk_in);
2312           usb_clear_halt (handle->idev, handle->ep_bulk_out);
2313         }
2314       else
2315           DEBUGOUT ("USB: RETRYING bulk_in AGAIN\n");
2316       retries++;
2317       goto retry;
2318     }
2319   if (rc && rc != CCID_DRIVER_ERR_NO_CARD
2320       && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
2321     return rc;
2322   *statusbits = (msg[7] & 3);
2323
2324   return 0;
2325 }
2326
2327
2328 /* Return the ATR of the card.  This is not a cached value and thus an
2329    actual reset is done.  */
2330 int 
2331 ccid_get_atr (ccid_driver_t handle,
2332               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
2333 {
2334   int rc;
2335   int statusbits;
2336   unsigned char msg[100];
2337   unsigned char *tpdu;
2338   size_t msglen, tpdulen;
2339   unsigned char seqno;
2340   int use_crc = 0;
2341   unsigned int edc;
2342   int tried_iso = 0;
2343   int got_param;
2344
2345   /* First check whether a card is available.  */
2346   rc = ccid_slot_status (handle, &statusbits);
2347   if (rc)
2348     return rc;
2349   if (statusbits == 2)
2350     return CCID_DRIVER_ERR_NO_CARD;
2351
2352   /* For an inactive and also for an active card, issue the PowerOn
2353      command to get the ATR.  */
2354  again:
2355   msg[0] = PC_to_RDR_IccPowerOn;
2356   msg[5] = 0; /* slot */
2357   msg[6] = seqno = handle->seqno++;
2358   msg[7] = 0; /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
2359   msg[8] = 0; /* RFU */
2360   msg[9] = 0; /* RFU */
2361   set_msg_len (msg, 0);
2362   msglen = 10;
2363
2364   rc = bulk_out (handle, msg, msglen, 0);
2365   if (rc)
2366     return rc;
2367   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2368                 seqno, 5000, 0);
2369   if (rc)
2370     return rc;
2371   if (!tried_iso && CCID_COMMAND_FAILED (msg) && CCID_ERROR_CODE (msg) == 0xbb
2372       && ((handle->id_vendor == VENDOR_CHERRY
2373            && handle->id_product == 0x0005)
2374           || (handle->id_vendor == VENDOR_GEMPC
2375               && handle->id_product == 0x4433)
2376           ))
2377     {
2378       tried_iso = 1;
2379       /* Try switching to ISO mode. */
2380       if (!send_escape_cmd (handle, (const unsigned char*)"\xF1\x01", 2,
2381                             NULL, 0, NULL))
2382         goto again;
2383     }
2384   else if (CCID_COMMAND_FAILED (msg))
2385     return CCID_DRIVER_ERR_CARD_IO_ERROR;
2386
2387
2388   handle->powered_off = 0;
2389   
2390   if (atr)
2391     {
2392       size_t n = msglen - 10;
2393
2394       if (n > maxatrlen)
2395         n = maxatrlen;
2396       memcpy (atr, msg+10, n);
2397       *atrlen = n;
2398     }
2399
2400   got_param = 0;
2401   msg[0] = PC_to_RDR_GetParameters;
2402   msg[5] = 0; /* slot */
2403   msg[6] = seqno = handle->seqno++;
2404   msg[7] = 0; /* RFU */
2405   msg[8] = 0; /* RFU */
2406   msg[9] = 0; /* RFU */
2407   set_msg_len (msg, 0);
2408   msglen = 10;
2409   rc = bulk_out (handle, msg, msglen, 0);
2410   if (!rc)
2411     rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2412                   seqno, 2000, 0);
2413   if (rc)
2414     DEBUGOUT ("GetParameters failed\n");
2415   else if (msglen == 17 && msg[9] == 1)
2416     got_param = 1;
2417
2418   /* Setup parameters to select T=1. */
2419   msg[0] = PC_to_RDR_SetParameters;
2420   msg[5] = 0; /* slot */
2421   msg[6] = seqno = handle->seqno++;
2422   msg[7] = 1; /* Select T=1. */
2423   msg[8] = 0; /* RFU */
2424   msg[9] = 0; /* RFU */
2425
2426   if (!got_param)
2427     {
2428       /* FIXME: Get those values from the ATR. */
2429       msg[10]= 0x01; /* Fi/Di */
2430       msg[11]= 0x10; /* LRC, direct convention. */
2431       msg[12]= 0;    /* Extra guardtime. */
2432       msg[13]= 0x41; /* BWI/CWI */
2433       msg[14]= 0;    /* No clock stoppping. */
2434       msg[15]= 254;  /* IFSC */
2435       msg[16]= 0;    /* Does not support non default NAD values. */
2436     }
2437   set_msg_len (msg, 7);
2438   msglen = 10 + 7;
2439
2440   rc = bulk_out (handle, msg, msglen, 0);
2441   if (rc)
2442     return rc;
2443   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2444                 seqno, 5000, 0);
2445   if (rc)
2446     DEBUGOUT ("SetParameters failed (ignored)\n");
2447
2448   if (!rc && msglen > 15 && msg[15] >= 16 && msg[15] <= 254 )
2449     handle->ifsc = msg[15];
2450   else
2451     handle->ifsc = 128; /* Something went wrong, assume 128 bytes.  */
2452
2453   handle->t1_ns = 0;
2454   handle->t1_nr = 0;
2455
2456   /* Send an S-Block with our maximum IFSD to the CCID.  */
2457   if (!handle->apdu_level && !handle->auto_ifsd)
2458     {
2459       tpdu = msg+10;
2460       /* NAD: DAD=1, SAD=0 */
2461       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2462       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
2463       tpdu[2] = 1;
2464       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32; 
2465       tpdulen = 4;
2466       edc = compute_edc (tpdu, tpdulen, use_crc);
2467       if (use_crc)
2468         tpdu[tpdulen++] = (edc >> 8);
2469       tpdu[tpdulen++] = edc;
2470
2471       msg[0] = PC_to_RDR_XfrBlock;
2472       msg[5] = 0; /* slot */
2473       msg[6] = seqno = handle->seqno++;
2474       msg[7] = 0; 
2475       msg[8] = 0; /* RFU */
2476       msg[9] = 0; /* RFU */
2477       set_msg_len (msg, tpdulen);
2478       msglen = 10 + tpdulen;
2479
2480       if (debug_level > 1)
2481         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
2482                       ((msg[11] & 0xc0) == 0x80)? 'R' :
2483                                 (msg[11] & 0x80)? 'S' : 'I',
2484                       ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2485                                        : !!(msg[11] & 0x40)),
2486                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2487
2488       rc = bulk_out (handle, msg, msglen, 0);
2489       if (rc)
2490         return rc;
2491
2492
2493       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2494                     RDR_to_PC_DataBlock, seqno, 5000, 0);
2495       if (rc)
2496         return rc;
2497       
2498       tpdu = msg + 10;
2499       tpdulen = msglen - 10;
2500       
2501       if (tpdulen < 4) 
2502         return CCID_DRIVER_ERR_ABORTED; 
2503
2504       if (debug_level > 1)
2505         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
2506                     ((msg[11] & 0xc0) == 0x80)? 'R' :
2507                               (msg[11] & 0x80)? 'S' : 'I',
2508                     ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2509                                      : !!(msg[11] & 0x40)),
2510                     ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
2511                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2512
2513       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
2514         {
2515           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
2516           return -1;
2517         }
2518       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
2519     }
2520
2521   return 0;
2522 }
2523
2524
2525 \f
2526
2527 static unsigned int 
2528 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
2529 {
2530   if (use_crc)
2531     {
2532       return 0x42; /* Not yet implemented. */
2533     }
2534   else
2535     {
2536       unsigned char crc = 0;
2537       
2538       for (; datalen; datalen--)
2539         crc ^= *data++;
2540       return crc;
2541     }
2542 }
2543
2544
2545 /* Return true if APDU is an extended length one.  */
2546 static int
2547 is_exlen_apdu (const unsigned char *apdu, size_t apdulen)
2548 {
2549   if (apdulen < 7 || apdu[4])
2550     return 0;  /* Too short or no Z byte.  */
2551   return 1;
2552 }
2553
2554
2555 /* Helper for ccid_transceive used for APDU level exchanges.  */
2556 static int
2557 ccid_transceive_apdu_level (ccid_driver_t handle,
2558                             const unsigned char *apdu_buf, size_t apdu_buflen,
2559                             unsigned char *resp, size_t maxresplen,
2560                             size_t *nresp)
2561 {
2562   int rc;
2563   unsigned char send_buffer[10+261+300], recv_buffer[10+261+300];
2564   const unsigned char *apdu;
2565   size_t apdulen;
2566   unsigned char *msg;
2567   size_t msglen;
2568   unsigned char seqno;
2569   int bwi = 4;
2570
2571   msg = send_buffer;
2572
2573   apdu = apdu_buf;
2574   apdulen = apdu_buflen;
2575   assert (apdulen);
2576
2577   /* The maximum length for a short APDU T=1 block is 261.  For an
2578      extended APDU T=1 block the maximum length 65544; however
2579      extended APDU exchange level is not yet supported.  */
2580   if (apdulen > 261)
2581     return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
2582   
2583   msg[0] = PC_to_RDR_XfrBlock;
2584   msg[5] = 0; /* slot */
2585   msg[6] = seqno = handle->seqno++;
2586   msg[7] = bwi; /* bBWI */
2587   msg[8] = 0; /* RFU */
2588   msg[9] = 0; /* RFU */
2589   memcpy (msg+10, apdu, apdulen);
2590   set_msg_len (msg, apdulen);
2591   msglen = 10 + apdulen;
2592
2593   rc = bulk_out (handle, msg, msglen, 0);
2594   if (rc)
2595     return rc;
2596
2597   msg = recv_buffer;
2598   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
2599                 RDR_to_PC_DataBlock, seqno, 5000, 0);
2600   if (rc)
2601     return rc;
2602       
2603   apdu = msg + 10;
2604   apdulen = msglen - 10;
2605       
2606   if (resp)
2607     {
2608       if (apdulen > maxresplen)
2609         {
2610           DEBUGOUT_2 ("provided buffer too short for received data "
2611                       "(%u/%u)\n",
2612                       (unsigned int)apdulen, (unsigned int)maxresplen);
2613           return CCID_DRIVER_ERR_INV_VALUE;
2614         }
2615       
2616       memcpy (resp, apdu, apdulen); 
2617       *nresp = apdulen;
2618     }
2619           
2620   return 0;
2621 }
2622
2623
2624
2625 /*
2626   Protocol T=1 overview
2627
2628   Block Structure:
2629            Prologue Field:
2630    1 byte     Node Address (NAD) 
2631    1 byte     Protocol Control Byte (PCB)
2632    1 byte     Length (LEN) 
2633            Information Field:
2634    0-254 byte APDU or Control Information (INF)
2635            Epilogue Field:
2636    1 byte     Error Detection Code (EDC)
2637
2638   NAD:  
2639    bit 7     unused
2640    bit 4..6  Destination Node Address (DAD)
2641    bit 3     unused
2642    bit 2..0  Source Node Address (SAD)
2643
2644    If node adresses are not used, SAD and DAD should be set to 0 on
2645    the first block sent to the card.  If they are used they should
2646    have different values (0 for one is okay); that first block sets up
2647    the addresses of the nodes.
2648
2649   PCB:
2650    Information Block (I-Block):
2651       bit 7    0
2652       bit 6    Sequence number (yep, that is modulo 2)
2653       bit 5    Chaining flag 
2654       bit 4..0 reserved
2655    Received-Ready Block (R-Block):
2656       bit 7    1
2657       bit 6    0
2658       bit 5    0
2659       bit 4    Sequence number
2660       bit 3..0  0 = no error
2661                 1 = EDC or parity error
2662                 2 = other error
2663                 other values are reserved
2664    Supervisory Block (S-Block):
2665       bit 7    1
2666       bit 6    1
2667       bit 5    clear=request,set=response
2668       bit 4..0  0 = resyncronisation request
2669                 1 = information field size request
2670                 2 = abort request
2671                 3 = extension of BWT request
2672                 4 = VPP error
2673                 other values are reserved
2674
2675 */
2676
2677 int
2678 ccid_transceive (ccid_driver_t handle,
2679                  const unsigned char *apdu_buf, size_t apdu_buflen,
2680                  unsigned char *resp, size_t maxresplen, size_t *nresp)
2681 {
2682   int rc;
2683   /* The size of the buffer used to be 10+259.  For the via_escape
2684      hack we need one extra byte, thus 11+259.  */
2685   unsigned char send_buffer[11+259], recv_buffer[11+259];
2686   const unsigned char *apdu;
2687   size_t apdulen;
2688   unsigned char *msg, *tpdu, *p;
2689   size_t msglen, tpdulen, last_tpdulen, n;
2690   unsigned char seqno;
2691   unsigned int edc;
2692   int use_crc = 0;
2693   int hdrlen, pcboff;
2694   size_t dummy_nresp;
2695   int via_escape = 0;
2696   int next_chunk = 1;
2697   int sending = 1;
2698   int retries = 0;
2699   int resyncing = 0;
2700   int nad_byte;
2701
2702   if (!nresp)
2703     nresp = &dummy_nresp;
2704   *nresp = 0;
2705
2706   /* Smarter readers allow to send APDUs directly; divert here. */
2707   if (handle->apdu_level)
2708     {
2709       /* We employ a hack for Omnikey readers which are able to send
2710          TPDUs using an escape sequence.  There is no documentation
2711          but the Windows driver does it this way.  Tested using a
2712          CM6121.  This method works also for the Cherry XX44
2713          keyboards; however there are problems with the
2714          ccid_tranceive_secure which leads to a loss of sync on the
2715          CCID level.  If Cherry wants to make their keyboard work
2716          again, they should hand over some docs. */
2717       if ((handle->id_vendor == VENDOR_OMNIKEY
2718            || (!handle->idev && handle->id_product == TRANSPORT_CM4040))
2719           && handle->apdu_level < 2
2720           && is_exlen_apdu (apdu_buf, apdu_buflen))
2721         via_escape = 1;
2722       else
2723         return ccid_transceive_apdu_level (handle, apdu_buf, apdu_buflen,
2724                                            resp, maxresplen, nresp);
2725     }
2726
2727   /* The other readers we support require sending TPDUs.  */
2728
2729   tpdulen = 0; /* Avoid compiler warning about no initialization. */
2730   msg = send_buffer;
2731   hdrlen = via_escape? 11 : 10;
2732
2733   /* NAD: DAD=1, SAD=0 */
2734   nad_byte = handle->nonnull_nad? ((1 << 4) | 0): 0;
2735   if (via_escape)
2736     nad_byte = 0;
2737
2738   last_tpdulen = 0;  /* Avoid gcc warning (controlled by RESYNCING). */
2739   for (;;)
2740     {
2741       if (next_chunk)
2742         {
2743           next_chunk = 0;
2744
2745           apdu = apdu_buf;
2746           apdulen = apdu_buflen;
2747           assert (apdulen);
2748
2749           /* Construct an I-Block. */
2750           tpdu = msg + hdrlen;
2751           tpdu[0] = nad_byte;
2752           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
2753           if (apdulen > handle->ifsc )
2754             {
2755               apdulen = handle->ifsc;
2756               apdu_buf += handle->ifsc;  
2757               apdu_buflen -= handle->ifsc;
2758               tpdu[1] |= (1 << 5); /* Set more bit. */
2759             }
2760           tpdu[2] = apdulen;
2761           memcpy (tpdu+3, apdu, apdulen);
2762           tpdulen = 3 + apdulen;
2763           edc = compute_edc (tpdu, tpdulen, use_crc);
2764           if (use_crc)
2765             tpdu[tpdulen++] = (edc >> 8);
2766           tpdu[tpdulen++] = edc;
2767         }
2768
2769       if (via_escape)
2770         {
2771           msg[0] = PC_to_RDR_Escape;
2772           msg[5] = 0; /* slot */
2773           msg[6] = seqno = handle->seqno++;
2774           msg[7] = 0; /* RFU */
2775           msg[8] = 0; /* RFU */
2776           msg[9] = 0; /* RFU */
2777           msg[10] = 0x1a; /* Omnikey command to send a TPDU.  */
2778           set_msg_len (msg, 1 + tpdulen);
2779         }
2780       else
2781         {
2782           msg[0] = PC_to_RDR_XfrBlock;
2783           msg[5] = 0; /* slot */
2784           msg[6] = seqno = handle->seqno++;
2785           msg[7] = 4; /* bBWI */
2786           msg[8] = 0; /* RFU */
2787           msg[9] = 0; /* RFU */
2788           set_msg_len (msg, tpdulen);
2789         }
2790       msglen = hdrlen + tpdulen;
2791       if (!resyncing)
2792         last_tpdulen = tpdulen;
2793       pcboff = hdrlen+1;
2794
2795       if (debug_level > 1)
2796         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
2797                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
2798                     (msg[pcboff] & 0x80)? 'S' : 'I',
2799                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
2800                      : !!(msg[pcboff] & 0x40)),
2801                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
2802                      " [more]":""));
2803       
2804       rc = bulk_out (handle, msg, msglen, 0);
2805       if (rc)
2806         return rc;
2807
2808       msg = recv_buffer;
2809       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
2810                     via_escape? RDR_to_PC_Escape : RDR_to_PC_DataBlock, 
2811                     seqno, 5000, 0);
2812       if (rc)
2813         return rc;
2814
2815       tpdu = msg + hdrlen;
2816       tpdulen = msglen - hdrlen;
2817       resyncing = 0;
2818             
2819       if (tpdulen < 4) 
2820         {
2821           usb_clear_halt (handle->idev, handle->ep_bulk_in);
2822           return CCID_DRIVER_ERR_ABORTED; 
2823         }
2824
2825       if (debug_level > 1)
2826         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
2827                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
2828                               (msg[pcboff] & 0x80)? 'S' : 'I',
2829                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
2830                      : !!(msg[pcboff] & 0x40)),
2831                     ((msg[pcboff] & 0xc0) == 0x80)? (msg[pcboff] & 0x0f) : 0,
2832                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
2833                      " [more]":""));
2834
2835       if (!(tpdu[1] & 0x80))
2836         { /* This is an I-block. */
2837           retries = 0;
2838           if (sending)
2839             { /* last block sent was successful. */
2840               handle->t1_ns ^= 1;
2841               sending = 0;
2842             }
2843
2844           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
2845             { /* Reponse does not match our sequence number. */
2846               msg = send_buffer;
2847               tpdu = msg + hdrlen;
2848               tpdu[0] = nad_byte;
2849               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
2850               tpdu[2] = 0;
2851               tpdulen = 3;
2852               edc = compute_edc (tpdu, tpdulen, use_crc);
2853               if (use_crc)
2854                 tpdu[tpdulen++] = (edc >> 8);
2855               tpdu[tpdulen++] = edc;
2856
2857               continue;
2858             }
2859
2860           handle->t1_nr ^= 1;
2861
2862           p = tpdu + 3; /* Skip the prologue field. */
2863           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
2864           /* fixme: verify the checksum. */
2865           if (resp)
2866             {
2867               if (n > maxresplen)
2868                 {
2869                   DEBUGOUT_2 ("provided buffer too short for received data "
2870                               "(%u/%u)\n",
2871                               (unsigned int)n, (unsigned int)maxresplen);
2872                   return CCID_DRIVER_ERR_INV_VALUE;
2873                 }
2874               
2875               memcpy (resp, p, n); 
2876               resp += n;
2877               *nresp += n;
2878               maxresplen -= n;
2879             }
2880           
2881           if (!(tpdu[1] & 0x20))
2882             return 0; /* No chaining requested - ready. */
2883           
2884           msg = send_buffer;
2885           tpdu = msg + hdrlen;
2886           tpdu[0] = nad_byte;
2887           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
2888           tpdu[2] = 0;
2889           tpdulen = 3;
2890           edc = compute_edc (tpdu, tpdulen, use_crc);
2891           if (use_crc)
2892             tpdu[tpdulen++] = (edc >> 8);
2893           tpdu[tpdulen++] = edc;
2894         }
2895       else if ((tpdu[1] & 0xc0) == 0x80)
2896         { /* This is a R-block. */
2897           if ( (tpdu[1] & 0x0f)) 
2898             { 
2899               retries++;
2900               if (via_escape && retries == 1 && (msg[pcboff] & 0x0f))
2901                 {
2902                   /* Error probably due to switching to TPDU.  Send a
2903                      resync request.  We use the recv_buffer so that
2904                      we don't corrupt the send_buffer.  */
2905                   msg = recv_buffer;
2906                   tpdu = msg + hdrlen;
2907                   tpdu[0] = nad_byte;
2908                   tpdu[1] = 0xc0; /* S-block resync request. */
2909                   tpdu[2] = 0;
2910                   tpdulen = 3;
2911                   edc = compute_edc (tpdu, tpdulen, use_crc);
2912                   if (use_crc)
2913                     tpdu[tpdulen++] = (edc >> 8);
2914                   tpdu[tpdulen++] = edc;
2915                   resyncing = 1;
2916                   DEBUGOUT ("T=1: requesting resync\n");
2917                 }
2918               else if (retries > 3)
2919                 {
2920                   DEBUGOUT ("T=1: 3 failed retries\n");
2921                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
2922                 }
2923               else
2924                 {
2925                   /* Error: repeat last block */
2926                   msg = send_buffer;
2927                   tpdulen = last_tpdulen;
2928                 }
2929             }
2930           else if (sending && !!(tpdu[1] & 0x10) == handle->t1_ns)
2931             { /* Response does not match our sequence number. */
2932               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
2933               return CCID_DRIVER_ERR_CARD_IO_ERROR;
2934             }
2935           else if (sending)
2936             { /* Send next chunk. */
2937               retries = 0;
2938               msg = send_buffer;
2939               next_chunk = 1;
2940               handle->t1_ns ^= 1;
2941             }
2942           else
2943             {
2944               DEBUGOUT ("unexpected ACK R-block received\n");
2945               return CCID_DRIVER_ERR_CARD_IO_ERROR;
2946             }
2947         }
2948       else 
2949         { /* This is a S-block. */
2950           retries = 0;
2951           DEBUGOUT_2 ("T=1: S-block %s received cmd=%d\n",
2952                       (tpdu[1] & 0x20)? "response": "request",
2953                       (tpdu[1] & 0x1f));
2954           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 1 && tpdu[2] == 1)
2955             {
2956               /* Information field size request.  */
2957               unsigned char ifsc = tpdu[3];
2958
2959               if (ifsc < 16 || ifsc > 254)
2960                 return CCID_DRIVER_ERR_CARD_IO_ERROR;
2961
2962               msg = send_buffer;
2963               tpdu = msg + hdrlen;
2964               tpdu[0] = nad_byte;
2965               tpdu[1] = (0xc0 | 0x20 | 1); /* S-block response */
2966               tpdu[2] = 1;
2967               tpdu[3] = ifsc;
2968               tpdulen = 4;
2969               edc = compute_edc (tpdu, tpdulen, use_crc);
2970               if (use_crc)
2971                 tpdu[tpdulen++] = (edc >> 8);
2972               tpdu[tpdulen++] = edc;
2973               DEBUGOUT_1 ("T=1: requesting an ifsc=%d\n", ifsc);
2974             }
2975           else if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
2976             {
2977               /* Wait time extension request. */
2978               unsigned char bwi = tpdu[3];
2979               msg = send_buffer;
2980               tpdu = msg + hdrlen;
2981               tpdu[0] = nad_byte;
2982               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
2983               tpdu[2] = 1;
2984               tpdu[3] = bwi;
2985               tpdulen = 4;
2986               edc = compute_edc (tpdu, tpdulen, use_crc);
2987               if (use_crc)
2988                 tpdu[tpdulen++] = (edc >> 8);
2989               tpdu[tpdulen++] = edc;
2990               DEBUGOUT_1 ("T=1: waittime extension of bwi=%d\n", bwi);
2991               print_progress (handle);
2992             }
2993           else if ( (tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 0 && !tpdu[2])
2994             {
2995               DEBUGOUT ("T=1: resync ack from reader\n");
2996               /* Repeat previous block.  */
2997               msg = send_buffer;
2998               tpdulen = last_tpdulen;
2999             }
3000           else
3001             return CCID_DRIVER_ERR_CARD_IO_ERROR;
3002         }
3003     } /* end T=1 protocol loop. */
3004
3005   return 0;
3006 }
3007
3008
3009 /* Send the CCID Secure command to the reader.  APDU_BUF should
3010    contain the APDU template.  PIN_MODE defines how the pin gets
3011    formatted:
3012    
3013      1 := The PIN is ASCII encoded and of variable length.  The
3014           length of the PIN entered will be put into Lc by the reader.
3015           The APDU should me made up of 4 bytes without Lc.
3016
3017    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
3018    may be used t enable reasonable defaults.  PIN_PADLEN should be 0.
3019    
3020    When called with RESP and NRESP set to NULL, the function will
3021    merely check whether the reader supports the secure command for the
3022    given APDU and PIN_MODE. */
3023 int
3024 ccid_transceive_secure (ccid_driver_t handle,
3025                         const unsigned char *apdu_buf, size_t apdu_buflen,
3026                         int pin_mode, int pinlen_min, int pinlen_max,
3027                         int pin_padlen, 
3028                         unsigned char *resp, size_t maxresplen, size_t *nresp)
3029 {
3030   int rc;
3031   unsigned char send_buffer[10+259], recv_buffer[10+259];
3032   unsigned char *msg, *tpdu, *p;
3033   size_t msglen, tpdulen, n;
3034   unsigned char seqno;
3035   size_t dummy_nresp;
3036   int testmode;
3037   int cherry_mode = 0;
3038
3039   testmode = !resp && !nresp;
3040
3041   if (!nresp)
3042     nresp = &dummy_nresp;
3043   *nresp = 0;
3044
3045   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
3046     ;
3047   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
3048     return CCID_DRIVER_ERR_NOT_SUPPORTED; /* Not yet by our code. */
3049   else
3050     return CCID_DRIVER_ERR_NO_KEYPAD;
3051     
3052   if (pin_mode != 1)
3053     return CCID_DRIVER_ERR_NOT_SUPPORTED;
3054
3055   if (pin_padlen != 0)
3056     return CCID_DRIVER_ERR_NOT_SUPPORTED;
3057
3058   if (!pinlen_min)
3059     pinlen_min = 1;
3060   if (!pinlen_max)
3061     pinlen_max = 25;
3062
3063   /* Note that the 25 is the maximum value the SPR532 allows.  */
3064   if (pinlen_min < 1 || pinlen_min > 25
3065       || pinlen_max < 1 || pinlen_max > 25 
3066       || pinlen_min > pinlen_max)
3067     return CCID_DRIVER_ERR_INV_VALUE;
3068
3069   /* We have only tested a few readers so better don't risk anything
3070      and do not allow the use with other readers. */
3071   switch (handle->id_vendor)
3072     {
3073     case VENDOR_SCM:  /* Tested with SPR 532. */
3074     case VENDOR_KAAN: /* Tested with KAAN Advanced (1.02). */
3075       break;
3076     case VENDOR_CHERRY:
3077       /* The CHERRY XX44 keyboard echos an asterisk for each entered
3078          character on the keyboard channel.  We use a special variant
3079          of PC_to_RDR_Secure which directs these characters to the
3080          smart card's bulk-in channel.  We also need to append a zero
3081          Lc byte to the APDU.  It seems that it will be replaced with
3082          the actual length instead of being appended before the APDU
3083          is send to the card. */
3084       cherry_mode = 1;
3085       break;
3086     default:
3087      return CCID_DRIVER_ERR_NOT_SUPPORTED;
3088     }
3089
3090   if (testmode)
3091     return 0; /* Success */
3092     
3093   msg = send_buffer;
3094   if (handle->id_vendor == VENDOR_SCM)
3095     {
3096       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
3097       rc = send_escape_cmd (handle, (const unsigned char*)"\x80\x02\x00", 3,
3098                             NULL, 0, NULL);
3099       if (rc)
3100         return rc;
3101     }
3102
3103   msg[0] = cherry_mode? 0x89 : PC_to_RDR_Secure;
3104   msg[5] = 0; /* slot */
3105   msg[6] = seqno = handle->seqno++;
3106   msg[7] = 0; /* bBWI */
3107   msg[8] = 0; /* RFU */
3108   msg[9] = 0; /* RFU */
3109   msg[10] = 0; /* Perform PIN verification. */
3110   msg[11] = 0; /* Timeout in seconds. */
3111   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
3112   if (handle->id_vendor == VENDOR_SCM)
3113     {
3114       /* For the SPR532 the next 2 bytes need to be zero.  We do this
3115          for all SCM products.  Kudos to Martin Paljak for this
3116          hint.  */
3117       msg[13] = msg[14] = 0;
3118     }
3119   else
3120     {
3121       msg[13] = 0x00; /* bmPINBlockString:
3122                          0 bits of pin length to insert. 
3123                          0 bytes of PIN block size.  */
3124       msg[14] = 0x00; /* bmPINLengthFormat:
3125                          Units are bytes, position is 0. */
3126     }
3127
3128   /* The following is a little endian word. */
3129   msg[15] = pinlen_max;   /* wPINMaxExtraDigit-Maximum.  */
3130   msg[16] = pinlen_min;   /* wPINMaxExtraDigit-Minimum.  */
3131
3132   msg[17] = 0x02; /* bEntryValidationCondition:
3133                      Validation key pressed */
3134   if (pinlen_min && pinlen_max && pinlen_min == pinlen_max)
3135     msg[17] |= 0x01; /* Max size reached.  */
3136   msg[18] = 0xff; /* bNumberMessage: Default. */
3137   msg[19] = 0x04; /* wLangId-High. */
3138   msg[20] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
3139   msg[21] = 0;    /* bMsgIndex. */
3140   /* bTeoProlog follows: */
3141   msg[22] = handle->nonnull_nad? ((1 << 4) | 0): 0;
3142   msg[23] = ((handle->t1_ns & 1) << 6); /* I-block */
3143   msg[24] = 0; /* The apdulen will be filled in by the reader.  */
3144   /* APDU follows:  */
3145   msg[25] = apdu_buf[0]; /* CLA */
3146   msg[26] = apdu_buf[1]; /* INS */
3147   msg[27] = apdu_buf[2]; /* P1 */
3148   msg[28] = apdu_buf[3]; /* P2 */
3149   msglen = 29;
3150   if (cherry_mode)
3151     msg[msglen++] = 0;
3152   /* An EDC is not required. */
3153   set_msg_len (msg, msglen - 10);
3154
3155   rc = bulk_out (handle, msg, msglen, 0);
3156   if (rc)
3157     return rc;
3158   
3159   msg = recv_buffer;
3160   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3161                 RDR_to_PC_DataBlock, seqno, 30000, 0);
3162   if (rc)
3163     return rc;
3164   
3165   tpdu = msg + 10;
3166   tpdulen = msglen - 10;
3167
3168   if (handle->apdu_level)
3169     {
3170       if (resp)
3171         {
3172           if (tpdulen > maxresplen)
3173             {
3174               DEBUGOUT_2 ("provided buffer too short for received data "
3175                           "(%u/%u)\n",
3176                           (unsigned int)tpdulen, (unsigned int)maxresplen);
3177               return CCID_DRIVER_ERR_INV_VALUE;
3178             }
3179           
3180           memcpy (resp, tpdu, tpdulen); 
3181           *nresp = tpdulen;
3182         }
3183       return 0;
3184     }
3185   
3186   if (tpdulen < 4) 
3187     {
3188       usb_clear_halt (handle->idev, handle->ep_bulk_in);
3189       return CCID_DRIVER_ERR_ABORTED; 
3190     }
3191   if (debug_level > 1)
3192     DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3193                 ((msg[11] & 0xc0) == 0x80)? 'R' :
3194                           (msg[11] & 0x80)? 'S' : 'I',
3195                 ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
3196                 ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
3197                 (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
3198
3199   if (!(tpdu[1] & 0x80))
3200     { /* This is an I-block. */
3201       /* Last block sent was successful. */
3202       handle->t1_ns ^= 1;
3203
3204       if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3205         { /* Reponse does not match our sequence number. */
3206           DEBUGOUT ("I-block with wrong seqno received\n");
3207           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3208         }
3209
3210       handle->t1_nr ^= 1;
3211
3212       p = tpdu + 3; /* Skip the prologue field. */
3213       n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3214       /* fixme: verify the checksum. */
3215       if (resp)
3216         {
3217           if (n > maxresplen)
3218             {
3219               DEBUGOUT_2 ("provided buffer too short for received data "
3220                           "(%u/%u)\n",
3221                           (unsigned int)n, (unsigned int)maxresplen);
3222               return CCID_DRIVER_ERR_INV_VALUE;
3223             }
3224               
3225           memcpy (resp, p, n); 
3226           resp += n;
3227           *nresp += n;
3228           maxresplen -= n;
3229         }
3230           
3231       if (!(tpdu[1] & 0x20))
3232         return 0; /* No chaining requested - ready. */
3233       
3234       DEBUGOUT ("chaining requested but not supported for Secure operation\n");
3235       return CCID_DRIVER_ERR_CARD_IO_ERROR;
3236     }
3237   else if ((tpdu[1] & 0xc0) == 0x80)
3238     { /* This is a R-block. */
3239       if ( (tpdu[1] & 0x0f)) 
3240         { /* Error: repeat last block */
3241           DEBUGOUT ("No retries supported for Secure operation\n");
3242           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3243         }
3244       else if (!!(tpdu[1] & 0x10) == handle->t1_ns)
3245         { /* Reponse does not match our sequence number. */
3246           DEBUGOUT ("R-block with wrong seqno received on more bit\n");
3247           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3248         }
3249       else
3250         { /* Send next chunk. */
3251           DEBUGOUT ("chaining not supported on Secure operation\n");
3252           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3253         }
3254     }
3255   else 
3256     { /* This is a S-block. */
3257       DEBUGOUT_2 ("T=1: S-block %s received cmd=%d for Secure operation\n",
3258                   (tpdu[1] & 0x20)? "response": "request",
3259                   (tpdu[1] & 0x1f));
3260       return CCID_DRIVER_ERR_CARD_IO_ERROR;
3261     } 
3262
3263   return 0;
3264 }
3265
3266
3267
3268
3269 #ifdef TEST
3270
3271
3272 static void
3273 print_error (int err)
3274 {
3275   const char *p;
3276   char buf[50];
3277
3278   switch (err)
3279     {
3280     case 0: p = "success";
3281     case CCID_DRIVER_ERR_OUT_OF_CORE: p = "out of core"; break;
3282     case CCID_DRIVER_ERR_INV_VALUE: p = "invalid value"; break;
3283     case CCID_DRIVER_ERR_NO_DRIVER: p = "no driver"; break;
3284     case CCID_DRIVER_ERR_NOT_SUPPORTED: p = "not supported"; break;
3285     case CCID_DRIVER_ERR_LOCKING_FAILED: p = "locking failed"; break;
3286     case CCID_DRIVER_ERR_BUSY: p = "busy"; break;
3287     case CCID_DRIVER_ERR_NO_CARD: p = "no card"; break;
3288     case CCID_DRIVER_ERR_CARD_INACTIVE: p = "card inactive"; break;
3289     case CCID_DRIVER_ERR_CARD_IO_ERROR: p = "card I/O error"; break;
3290     case CCID_DRIVER_ERR_GENERAL_ERROR: p = "general error"; break;
3291     case CCID_DRIVER_ERR_NO_READER: p = "no reader"; break;
3292     case CCID_DRIVER_ERR_ABORTED: p = "aborted"; break;
3293     default: sprintf (buf, "0x%05x", err); p = buf; break;
3294     }
3295   fprintf (stderr, "operation failed: %s\n", p);
3296 }
3297
3298
3299 static void
3300 print_data (const unsigned char *data, size_t length)
3301 {
3302   if (length >= 2)
3303     {
3304       fprintf (stderr, "operation status: %02X%02X\n",
3305                data[length-2], data[length-1]);
3306       length -= 2;
3307     }
3308   if (length)
3309     {
3310         fputs ("   returned data:", stderr);
3311         for (; length; length--, data++)
3312           fprintf (stderr, " %02X", *data);
3313         putc ('\n', stderr);
3314     }
3315 }
3316
3317 static void
3318 print_result (int rc, const unsigned char *data, size_t length)
3319 {
3320   if (rc)
3321     print_error (rc);
3322   else if (data)
3323     print_data (data, length);
3324 }
3325
3326 int
3327 main (int argc, char **argv)
3328 {
3329   int rc;
3330   ccid_driver_t ccid;
3331   int slotstat;
3332   unsigned char result[512];
3333   size_t resultlen;
3334   int no_pinpad = 0;
3335   int verify_123456 = 0;
3336   int did_verify = 0;
3337   int no_poll = 0;
3338
3339   if (argc)
3340     {
3341       argc--;
3342       argv++;
3343     }
3344
3345   while (argc)
3346     {
3347       if ( !strcmp (*argv, "--list"))
3348         {
3349           char *p;
3350           p = ccid_get_reader_list ();
3351           if (!p)
3352             return 1;
3353           fputs (p, stderr);
3354           free (p);
3355           return 0;
3356         }
3357       else if ( !strcmp (*argv, "--debug"))
3358         {
3359           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
3360           argc--; argv++;
3361         }
3362       else if ( !strcmp (*argv, "--no-poll"))
3363         {
3364           no_poll = 1;
3365           argc--; argv++;
3366         }
3367       else if ( !strcmp (*argv, "--no-pinpad"))
3368         {
3369           no_pinpad = 1;
3370           argc--; argv++;
3371         }
3372       else if ( !strcmp (*argv, "--verify-123456"))
3373         {
3374           verify_123456 = 1;
3375           argc--; argv++;
3376         }
3377       else
3378         break;
3379     }
3380
3381   rc = ccid_open_reader (&ccid, argc? *argv:NULL);
3382   if (rc)
3383     return 1;
3384
3385   if (!no_poll)
3386     ccid_poll (ccid);
3387   fputs ("getting ATR ...\n", stderr);
3388   rc = ccid_get_atr (ccid, NULL, 0, NULL);
3389   if (rc)
3390     {
3391       print_error (rc);
3392       return 1;
3393     }
3394
3395   if (!no_poll)
3396     ccid_poll (ccid);
3397   fputs ("getting slot status ...\n", stderr);
3398   rc = ccid_slot_status (ccid, &slotstat);
3399   if (rc)
3400     {
3401       print_error (rc);
3402       return 1;
3403     }
3404
3405   if (!no_poll)
3406     ccid_poll (ccid);
3407
3408   fputs ("selecting application OpenPGP ....\n", stderr);
3409   {
3410     static unsigned char apdu[] = {
3411       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
3412     rc = ccid_transceive (ccid,
3413                           apdu, sizeof apdu,
3414                           result, sizeof result, &resultlen);
3415     print_result (rc, result, resultlen);
3416   }
3417   
3418
3419   if (!no_poll)
3420     ccid_poll (ccid);
3421
3422   fputs ("getting OpenPGP DO 0x65 ....\n", stderr);
3423   {
3424     static unsigned char apdu[] = { 0, 0xCA, 0, 0x65, 254 };
3425     rc = ccid_transceive (ccid, apdu, sizeof apdu,
3426                           result, sizeof result, &resultlen);
3427     print_result (rc, result, resultlen);
3428   }
3429
3430   if (!no_pinpad)
3431     {
3432     }
3433
3434   if (!no_pinpad)
3435     {
3436       static unsigned char apdu[] = { 0, 0x20, 0, 0x81 };
3437
3438       
3439       if (ccid_transceive_secure (ccid,
3440                                   apdu, sizeof apdu,
3441                                   1, 0, 0, 0,
3442                                   NULL, 0, NULL))
3443         fputs ("can't verify using a PIN-Pad reader\n", stderr);
3444       else
3445         {
3446           fputs ("verifying CHV1 using the PINPad ....\n", stderr);
3447           
3448           rc = ccid_transceive_secure (ccid,
3449                                        apdu, sizeof apdu,
3450                                        1, 0, 0, 0,
3451                                        result, sizeof result, &resultlen);
3452           print_result (rc, result, resultlen);
3453           did_verify = 1;
3454         }
3455     }
3456   
3457   if (verify_123456 && !did_verify)
3458     {
3459       fputs ("verifying that CHV1 is 123456....\n", stderr);
3460       {
3461         static unsigned char apdu[] = {0, 0x20, 0, 0x81,
3462                                        6, '1','2','3','4','5','6'};
3463         rc = ccid_transceive (ccid, apdu, sizeof apdu,
3464                               result, sizeof result, &resultlen);
3465         print_result (rc, result, resultlen);
3466       }
3467     }
3468
3469   if (!rc)
3470     {
3471       fputs ("getting OpenPGP DO 0x5E ....\n", stderr);
3472       {
3473         static unsigned char apdu[] = { 0, 0xCA, 0, 0x5E, 254 };
3474         rc = ccid_transceive (ccid, apdu, sizeof apdu,
3475                               result, sizeof result, &resultlen);
3476         print_result (rc, result, resultlen);
3477       }
3478     }
3479
3480   ccid_close_reader (ccid);
3481
3482   return 0;
3483 }
3484
3485 /*
3486  * Local Variables:
3487  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
3488  * End:
3489  */
3490 #endif /*TEST*/
3491 #endif /*HAVE_LIBUSB*/