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