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