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