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