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