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