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