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