Make bug reporting address easier changeable.
[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 ("  [%04d] ", 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 negotation 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 negotation 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     DEBUGOUT ("  junk             ");
923     for (i=54; i < buf[0]-54; i++)
924       DEBUGOUT_CONT_1 (" %02X", buf[i]);
925     DEBUGOUT_LF ();
926   }
927
928   if (!have_t1 || !(have_tpdu  || handle->apdu_level) || !have_auto_conf)
929     {
930       DEBUGOUT ("this drivers requires that the reader supports T=1, "
931                 "TPDU or APDU level exchange and auto configuration - "
932                 "this is not available\n");
933       return -1;
934     }
935
936
937   /* SCM drivers get stuck in their internal USB stack if they try to
938      send a frame of n*wMaxPacketSize back to us.  Given that
939      wMaxPacketSize is 64 for these readers we set the IFSD to a value
940      lower than that:
941         64 - 10 CCID header -  4 T1frame - 2 reserved = 48
942      Product Ids:
943          0xe001 - SCR 331 
944          0x5111 - SCR 331-DI 
945          0x5115 - SCR 335 
946          0xe003 - SPR 532 
947   */
948   if (handle->id_vendor == VENDOR_SCM
949       && handle->max_ifsd > 48      
950       && (  (handle->id_product == 0xe001 && handle->bcd_device < 0x0516)
951           ||(handle->id_product == 0x5111 && handle->bcd_device < 0x0620)
952           ||(handle->id_product == 0x5115 && handle->bcd_device < 0x0514)
953           ||(handle->id_product == 0xe003 && handle->bcd_device < 0x0504)
954           ))
955     {
956       DEBUGOUT ("enabling workaround for buggy SCM readers\n");
957       handle->max_ifsd = 48;
958     }
959
960
961   return 0;
962 }
963
964
965 static char *
966 get_escaped_usb_string (usb_dev_handle *idev, int idx,
967                         const char *prefix, const char *suffix)
968 {
969   int rc;
970   unsigned char buf[280];
971   unsigned char *s;
972   unsigned int langid;
973   size_t i, n, len;
974   char *result;
975
976   if (!idx)
977     return NULL;
978
979   /* Fixme: The next line is for the current Valgrid without support
980      for USB IOCTLs. */
981   memset (buf, 0, sizeof buf);
982
983   /* First get the list of supported languages and use the first one.
984      If we do don't find it we try to use English.  Note that this is
985      all in a 2 bute Unicode encoding using little endian. */
986   rc = usb_control_msg (idev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
987                         (USB_DT_STRING << 8), 0, 
988                         (char*)buf, sizeof buf, 1000 /* ms timeout */);
989   if (rc < 4)
990     langid = 0x0409; /* English.  */
991   else
992     langid = (buf[3] << 8) | buf[2];
993
994   rc = usb_control_msg (idev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
995                         (USB_DT_STRING << 8) + idx, langid,
996                         (char*)buf, sizeof buf, 1000 /* ms timeout */);
997   if (rc < 2 || buf[1] != USB_DT_STRING)
998     return NULL; /* Error or not a string. */
999   len = buf[0];
1000   if (len > rc)
1001     return NULL; /* Larger than our buffer. */
1002
1003   for (s=buf+2, i=2, n=0; i+1 < len; i += 2, s += 2)
1004     {
1005       if (s[1])
1006         n++; /* High byte set. */
1007       else if (*s <= 0x20 || *s >= 0x7f || *s == '%' || *s == ':')
1008         n += 3 ;
1009       else 
1010         n++;
1011     }
1012
1013   result = malloc (strlen (prefix) + n + strlen (suffix) + 1);
1014   if (!result)
1015     return NULL;
1016
1017   strcpy (result, prefix);
1018   n = strlen (prefix);
1019   for (s=buf+2, i=2; i+1 < len; i += 2, s += 2)
1020     {
1021       if (s[1])
1022         result[n++] = '\xff'; /* High byte set. */
1023       else if (*s <= 0x20 || *s >= 0x7f || *s == '%' || *s == ':')
1024         {
1025           sprintf (result+n, "%%%02X", *s);
1026           n += 3;
1027         }
1028       else 
1029         result[n++] = *s;
1030     }
1031   strcpy (result+n, suffix);
1032
1033   return result;
1034 }
1035
1036 /* This function creates an reader id to be used to find the same
1037    physical reader after a reset.  It returns an allocated and possibly
1038    percent escaped string or NULL if not enough memory is available. */
1039 static char *
1040 make_reader_id (usb_dev_handle *idev,
1041                 unsigned int vendor, unsigned int product,
1042                 unsigned char serialno_index)
1043 {
1044   char *rid;
1045   char prefix[20];
1046
1047   sprintf (prefix, "%04X:%04X:", (vendor & 0xffff), (product & 0xffff));
1048   rid = get_escaped_usb_string (idev, serialno_index, prefix, ":0");
1049   if (!rid)
1050     {
1051       rid = malloc (strlen (prefix) + 3 + 1);
1052       if (!rid)
1053         return NULL;
1054       strcpy (rid, prefix);
1055       strcat (rid, "X:0");
1056     }
1057   return rid;
1058 }
1059
1060
1061 /* Helper to find the endpoint from an interface descriptor.  */
1062 static int
1063 find_endpoint (struct usb_interface_descriptor *ifcdesc, int mode)
1064 {
1065   int no;
1066   int want_bulk_in = 0;
1067
1068   if (mode == 1)
1069     want_bulk_in = 0x80;
1070   for (no=0; no < ifcdesc->bNumEndpoints; no++)
1071     {
1072       struct usb_endpoint_descriptor *ep = ifcdesc->endpoint + no;
1073       if (ep->bDescriptorType != USB_DT_ENDPOINT)
1074         ;
1075       else if (mode == 2
1076           && ((ep->bmAttributes & USB_ENDPOINT_TYPE_MASK)
1077               == USB_ENDPOINT_TYPE_INTERRUPT)
1078           && (ep->bEndpointAddress & 0x80))
1079         return (ep->bEndpointAddress & 0x0f);
1080       else if (((ep->bmAttributes & USB_ENDPOINT_TYPE_MASK)
1081                 == USB_ENDPOINT_TYPE_BULK)
1082                && (ep->bEndpointAddress & 0x80) == want_bulk_in)
1083         return (ep->bEndpointAddress & 0x0f);
1084     }
1085   /* Should never happen.  */
1086   return mode == 2? 0x83 : mode == 1? 0x82 :1;
1087 }
1088
1089
1090 /* Helper for scan_or_find_devices. This function returns true if a
1091    requested device has been found or the caller should stop scanning
1092    for other reasons. */
1093 static int
1094 scan_or_find_usb_device (int scan_mode,
1095                          int *readerno, int *count, char **rid_list,
1096                          const char *readerid,
1097                          struct usb_device *dev,
1098                          char **r_rid,
1099                          struct usb_device **r_dev,
1100                          usb_dev_handle **r_idev,
1101                          unsigned char **ifcdesc_extra,
1102                          size_t *ifcdesc_extra_len,
1103                          int *interface_number,
1104                          int *ep_bulk_out, int *ep_bulk_in, int *ep_intr)
1105 {
1106   int cfg_no;
1107   int ifc_no;
1108   int set_no;
1109   struct usb_config_descriptor *config;
1110   struct usb_interface *interface;          
1111   struct usb_interface_descriptor *ifcdesc;
1112   char *rid;
1113   usb_dev_handle *idev;
1114
1115   *r_idev = NULL;
1116
1117   for (cfg_no=0; cfg_no < dev->descriptor.bNumConfigurations; cfg_no++)
1118     {
1119       config = dev->config + cfg_no;
1120       if(!config)
1121         continue;
1122
1123       for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
1124         {
1125           interface = config->interface + ifc_no;
1126           if (!interface)
1127             continue;
1128                   
1129           for (set_no=0; set_no < interface->num_altsetting; set_no++)
1130             {
1131               ifcdesc = (interface->altsetting + set_no);
1132               /* The second condition is for older SCM SPR 532 who did
1133                  not know about the assigned CCID class.  Instead of
1134                  trying to interpret the strings we simply check the
1135                  product ID. */
1136               if (ifcdesc && ifcdesc->extra
1137                   && ((ifcdesc->bInterfaceClass == 11
1138                        && ifcdesc->bInterfaceSubClass == 0
1139                        && ifcdesc->bInterfaceProtocol == 0)
1140                       || (ifcdesc->bInterfaceClass == 255
1141                           && dev->descriptor.idVendor == VENDOR_SCM
1142                           && dev->descriptor.idProduct == 0xe003)))
1143                 {
1144                   idev = usb_open (dev);
1145                   if (!idev)
1146                     {
1147                       DEBUGOUT_1 ("usb_open failed: %s\n",
1148                                   strerror (errno));
1149                       continue; /* with next setting. */
1150                     }
1151                   
1152                   rid = make_reader_id (idev,
1153                                         dev->descriptor.idVendor,
1154                                         dev->descriptor.idProduct,
1155                                         dev->descriptor.iSerialNumber);
1156                   if (rid)
1157                     {
1158                       if (scan_mode)
1159                         {
1160                           char *p;
1161                           
1162                           /* We are collecting infos about all
1163                              available CCID readers.  Store them and
1164                              continue. */
1165                           DEBUGOUT_2 ("found CCID reader %d (ID=%s)\n",
1166                                       *count, rid );
1167                           p = malloc ((*rid_list? strlen (*rid_list):0) + 1
1168                                       + strlen (rid) + 1);
1169                           if (p)
1170                             {
1171                               *p = 0;
1172                               if (*rid_list)
1173                                 {
1174                                   strcat (p, *rid_list);
1175                                   free (*rid_list);
1176                                 }
1177                               strcat (p, rid);
1178                               strcat (p, "\n");
1179                               *rid_list = p;
1180                             }
1181                           else /* Out of memory. */
1182                             free (rid);
1183                           
1184                           rid = NULL;
1185                           ++*count;
1186                         }
1187                       else if (!*readerno
1188                                || (*readerno < 0
1189                                    && readerid
1190                                    && !strcmp (readerid, rid)))
1191                         {
1192                           /* We found the requested reader. */
1193                           if (ifcdesc_extra && ifcdesc_extra_len)
1194                             {
1195                               *ifcdesc_extra = malloc (ifcdesc
1196                                                        ->extralen);
1197                               if (!*ifcdesc_extra)
1198                                 {
1199                                   usb_close (idev);
1200                                   free (rid);
1201                                   return 1; /* Out of core. */
1202                                 }
1203                               memcpy (*ifcdesc_extra, ifcdesc->extra,
1204                                       ifcdesc->extralen);
1205                               *ifcdesc_extra_len = ifcdesc->extralen;
1206                             }
1207
1208                           if (interface_number)
1209                             *interface_number = (ifcdesc->bInterfaceNumber);
1210
1211                           if (ep_bulk_out)
1212                             *ep_bulk_out = find_endpoint (ifcdesc, 0);
1213                           if (ep_bulk_in)
1214                             *ep_bulk_in = find_endpoint (ifcdesc, 1);
1215                           if (ep_intr)
1216                             *ep_intr = find_endpoint (ifcdesc, 2);
1217
1218                           if (r_dev)
1219                             *r_dev = dev;
1220                           if (r_rid)
1221                             {
1222                               *r_rid = rid;
1223                               rid = NULL;
1224                             }
1225                           else
1226                             free (rid);
1227                           
1228                           *r_idev = idev;
1229                           return 1; /* Found requested device. */
1230                         }
1231                       else
1232                         {
1233                           /* This is not yet the reader we want.
1234                              fixme: We should avoid the extra usb_open
1235                              in this case. */
1236                           if (*readerno >= 0)
1237                             --*readerno;
1238                         }
1239                       free (rid);
1240                     }
1241                   
1242                   usb_close (idev);
1243                   idev = NULL;
1244                   return 0;
1245                 }
1246             }
1247         }
1248     }
1249
1250   return 0;
1251 }
1252
1253 /* Combination function to either scan all CCID devices or to find and
1254    open one specific device. 
1255
1256    The function returns 0 if a reader has been found or when a scan
1257    returned without error.
1258
1259    With READERNO = -1 and READERID is NULL, scan mode is used and
1260    R_RID should be the address where to store the list of reader_ids
1261    we found.  If on return this list is empty, no CCID device has been
1262    found; otherwise it points to an allocated linked list of reader
1263    IDs.  Note that in this mode the function always returns NULL.
1264
1265    With READERNO >= 0 or READERID is not NULL find mode is used.  This
1266    uses the same algorithm as the scan mode but stops and returns at
1267    the entry number READERNO and return the handle for the the opened
1268    USB device. If R_RID is not NULL it will receive the reader ID of
1269    that device.  If R_DEV is not NULL it will the device pointer of
1270    that device.  If IFCDESC_EXTRA is NOT NULL it will receive a
1271    malloced copy of the interfaces "extra: data filed;
1272    IFCDESC_EXTRA_LEN receive the length of this field.  If there is
1273    no reader with number READERNO or that reader is not usable by our
1274    implementation NULL will be returned.  The caller must close a
1275    returned USB device handle and free (if not passed as NULL) the
1276    returned reader ID info as well as the IFCDESC_EXTRA.  On error
1277    NULL will get stored at R_RID, R_DEV, IFCDESC_EXTRA and
1278    IFCDESC_EXTRA_LEN.  With READERID being -1 the function stops if
1279    the READERID was found.
1280
1281    If R_FD is not -1 on return the device is not using USB for
1282    transport but the device associated with that file descriptor.  In
1283    this case INTERFACE will receive the transport type and the other
1284    USB specific return values are not used; the return value is
1285    (void*)(1).
1286
1287    Note that the first entry of the returned reader ID list in scan mode
1288    corresponds with a READERNO of 0 in find mode.
1289 */
1290 static int
1291 scan_or_find_devices (int readerno, const char *readerid,
1292                       char **r_rid,
1293                       struct usb_device **r_dev,
1294                       unsigned char **ifcdesc_extra,
1295                       size_t *ifcdesc_extra_len,
1296                       int *interface_number,
1297                       int *ep_bulk_out, int *ep_bulk_in, int *ep_intr,
1298                       usb_dev_handle **r_idev,
1299                       int *r_fd)
1300 {
1301   char *rid_list = NULL;
1302   int count = 0;
1303   struct usb_bus *busses, *bus;
1304   struct usb_device *dev = NULL;
1305   usb_dev_handle *idev = NULL;
1306   int scan_mode = (readerno == -1 && !readerid);
1307   int i;
1308
1309   /* Set return values to a default. */
1310   if (r_rid)
1311     *r_rid = NULL;
1312   if (r_dev)
1313     *r_dev = NULL; 
1314   if (ifcdesc_extra)
1315     *ifcdesc_extra = NULL;
1316   if (ifcdesc_extra_len)
1317     *ifcdesc_extra_len = 0;
1318   if (interface_number)
1319     *interface_number = 0;
1320   if (r_idev)
1321     *r_idev = NULL;
1322   if (r_fd)
1323     *r_fd = -1;
1324
1325   /* See whether we want scan or find mode. */
1326   if (scan_mode) 
1327     {
1328       assert (r_rid);
1329     }
1330
1331   usb_find_busses();
1332   usb_find_devices();
1333
1334 #ifdef HAVE_USB_GET_BUSSES
1335   busses = usb_get_busses();
1336 #else
1337   busses = usb_busses;
1338 #endif
1339
1340   for (bus = busses; bus; bus = bus->next) 
1341     {
1342       for (dev = bus->devices; dev; dev = dev->next)
1343         {
1344           if (scan_or_find_usb_device (scan_mode, &readerno, &count, &rid_list,
1345                                        readerid,
1346                                        dev,
1347                                        r_rid,
1348                                        r_dev,
1349                                        &idev,
1350                                        ifcdesc_extra,
1351                                        ifcdesc_extra_len,
1352                                        interface_number,
1353                                        ep_bulk_out, ep_bulk_in, ep_intr))
1354             {
1355               /* Found requested device or out of core. */
1356               if (!idev)
1357                 {
1358                   free (rid_list);
1359                   return -1; /* error */
1360                 }
1361               *r_idev = idev;
1362               return 0; 
1363             }
1364         }
1365     }
1366
1367   /* Now check whether there are any devices with special transport types. */
1368   for (i=0; transports[i].name; i++)
1369     {
1370       int fd;
1371       char *rid, *p;
1372
1373       fd = open (transports[i].name, O_RDWR);
1374       if (fd == -1 && scan_mode && errno == EBUSY)
1375         {
1376           /* Ignore this error in scan mode because it indicates that
1377              the device exists but is already open (most likely by us)
1378              and thus in general suitable as a reader.  */
1379         }
1380       else if (fd == -1)
1381         {
1382           DEBUGOUT_2 ("failed to open `%s': %s\n",
1383                      transports[i].name, strerror (errno));
1384           continue;
1385         }
1386
1387       rid = malloc (strlen (transports[i].name) + 30 + 10);
1388       if (!rid)
1389         {
1390           if (fd != -1)
1391             close (fd);
1392           free (rid_list);
1393           return -1; /* Error. */
1394         }
1395       sprintf (rid, "0000:%04X:%s:0", transports[i].type, transports[i].name);
1396       if (scan_mode)
1397         {
1398           DEBUGOUT_2 ("found CCID reader %d (ID=%s)\n", count, rid);
1399           p = malloc ((rid_list? strlen (rid_list):0) + 1 + strlen (rid) + 1);
1400           if (!p)
1401             {
1402               if (fd != -1)
1403                 close (fd);
1404               free (rid_list);
1405               free (rid);
1406               return -1; /* Error. */
1407             }
1408           *p = 0;
1409           if (rid_list)
1410             {
1411               strcat (p, rid_list);
1412               free (rid_list);
1413             }
1414           strcat (p, rid);
1415           strcat (p, "\n");
1416           rid_list = p;
1417           ++count;
1418         }
1419       else if (!readerno ||
1420                (readerno < 0 && readerid && !strcmp (readerid, rid)))
1421         {
1422           /* Found requested device. */
1423           if (interface_number)
1424             *interface_number = transports[i].type;
1425           if (r_rid)
1426             *r_rid = rid;
1427           else
1428             free (rid);
1429           if (r_fd)
1430             *r_fd = fd;
1431           return 0; /* Okay, found device */
1432         }
1433       else /* This is not yet the reader we want. */
1434         {
1435           if (readerno >= 0)
1436             --readerno;
1437         }
1438       free (rid);
1439       if (fd != -1)
1440         close (fd);
1441     }
1442
1443   if (scan_mode)
1444     {
1445       *r_rid = rid_list;
1446       return 0;
1447     }
1448   else
1449     return -1;
1450 }
1451
1452
1453 /* Set the level of debugging to LEVEL and return the old level.  -1
1454    just returns the old level.  A level of 0 disables debugging, 1
1455    enables debugging, 2 enables additional tracing of the T=1
1456    protocol, 3 additionally enables debugging for GetSlotStatus, other
1457    values are not yet defined.
1458
1459    Note that libusb may provide its own debugging feature which is
1460    enabled by setting the envvar USB_DEBUG.  */
1461 int
1462 ccid_set_debug_level (int level)
1463 {
1464   int old = debug_level;
1465   if (level != -1)
1466     debug_level = level;
1467   return old;
1468 }
1469
1470
1471 char *
1472 ccid_get_reader_list (void)
1473 {
1474   char *reader_list;
1475
1476   if (!initialized_usb)
1477     {
1478       usb_init ();
1479       initialized_usb = 1;
1480     }
1481
1482   if (scan_or_find_devices (-1, NULL, &reader_list, NULL, NULL, NULL, NULL,
1483                             NULL, NULL, NULL, NULL, NULL))
1484     return NULL; /* Error. */
1485   return reader_list;
1486 }
1487
1488
1489 /* Open the reader with the internal number READERNO and return a 
1490    pointer to be used as handle in HANDLE.  Returns 0 on success. */
1491 int 
1492 ccid_open_reader (ccid_driver_t *handle, const char *readerid)
1493 {
1494   int rc = 0;
1495   struct usb_device *dev = NULL;
1496   usb_dev_handle *idev = NULL;
1497   int dev_fd = -1;
1498   char *rid = NULL;
1499   unsigned char *ifcdesc_extra = NULL;
1500   size_t ifcdesc_extra_len;
1501   int readerno;
1502   int ifc_no, ep_bulk_out, ep_bulk_in, ep_intr;
1503
1504   *handle = NULL;
1505
1506   if (!initialized_usb)
1507     {
1508       usb_init ();
1509       initialized_usb = 1;
1510     }
1511
1512   /* See whether we want to use the reader ID string or a reader
1513      number. A readerno of -1 indicates that the reader ID string is
1514      to be used. */
1515   if (readerid && strchr (readerid, ':'))
1516     readerno = -1; /* We want to use the readerid.  */
1517   else if (readerid)
1518     {
1519       readerno = atoi (readerid);
1520       if (readerno < 0)
1521         {
1522           DEBUGOUT ("no CCID readers found\n");
1523           rc = CCID_DRIVER_ERR_NO_READER;
1524           goto leave;
1525         }
1526     }
1527   else
1528     readerno = 0;  /* Default. */
1529
1530   if (scan_or_find_devices (readerno, readerid, &rid, &dev,
1531                             &ifcdesc_extra, &ifcdesc_extra_len,
1532                             &ifc_no, &ep_bulk_out, &ep_bulk_in, &ep_intr,
1533                             &idev, &dev_fd) )
1534     {
1535       if (readerno == -1)
1536         DEBUGOUT_1 ("no CCID reader with ID %s\n", readerid );
1537       else
1538         DEBUGOUT_1 ("no CCID reader with number %d\n", readerno );
1539       rc = CCID_DRIVER_ERR_NO_READER;
1540       goto leave;
1541     }
1542
1543   /* Okay, this is a CCID reader. */
1544   *handle = calloc (1, sizeof **handle);
1545   if (!*handle)
1546     {
1547       DEBUGOUT ("out of memory\n");
1548       rc = CCID_DRIVER_ERR_OUT_OF_CORE;
1549       goto leave;
1550     }
1551   (*handle)->rid = rid;
1552   if (idev) /* Regular USB transport. */
1553     {
1554       (*handle)->idev = idev;
1555       (*handle)->dev_fd = -1;
1556       (*handle)->id_vendor = dev->descriptor.idVendor;
1557       (*handle)->id_product = dev->descriptor.idProduct;
1558       (*handle)->bcd_device = dev->descriptor.bcdDevice;
1559       (*handle)->ifc_no = ifc_no;
1560       (*handle)->ep_bulk_out = ep_bulk_out;
1561       (*handle)->ep_bulk_in = ep_bulk_in;
1562       (*handle)->ep_intr = ep_intr;
1563     }
1564   else if (dev_fd != -1) /* Device transport. */
1565     {
1566       (*handle)->idev = NULL;
1567       (*handle)->dev_fd = dev_fd;
1568       (*handle)->id_vendor = 0;  /* Magic vendor for special transport. */
1569       (*handle)->id_product = ifc_no; /* Transport type */
1570       prepare_special_transport (*handle);
1571     }
1572   else
1573     {
1574       assert (!"no transport"); /* Bug. */
1575     }
1576
1577   DEBUGOUT_2 ("using CCID reader %d (ID=%s)\n",  readerno, rid );
1578
1579   if (idev)
1580     {
1581       if (parse_ccid_descriptor (*handle, ifcdesc_extra, ifcdesc_extra_len))
1582         {
1583           DEBUGOUT ("device not supported\n");
1584           rc = CCID_DRIVER_ERR_NO_READER;
1585           goto leave;
1586         }
1587       
1588       rc = usb_claim_interface (idev, ifc_no);
1589       if (rc)
1590         {
1591           DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
1592           rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1593           goto leave;
1594         }
1595     }
1596
1597  leave:
1598   free (ifcdesc_extra);
1599   if (rc)
1600     {
1601       free (rid);
1602       if (idev)
1603         usb_close (idev);
1604       if (dev_fd != -1)
1605         close (dev_fd);
1606       free (*handle);
1607       *handle = NULL;
1608     }
1609
1610   return rc;
1611 }
1612
1613
1614 static void
1615 do_close_reader (ccid_driver_t handle)
1616 {
1617   int rc;
1618   unsigned char msg[100];
1619   size_t msglen;
1620   unsigned char seqno;
1621   
1622   if (!handle->powered_off)
1623     {
1624       msg[0] = PC_to_RDR_IccPowerOff;
1625       msg[5] = 0; /* slot */
1626       msg[6] = seqno = handle->seqno++;
1627       msg[7] = 0; /* RFU */
1628       msg[8] = 0; /* RFU */
1629       msg[9] = 0; /* RFU */
1630       set_msg_len (msg, 0);
1631       msglen = 10;
1632       
1633       rc = bulk_out (handle, msg, msglen, 0);
1634       if (!rc)
1635         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
1636                  seqno, 2000, 0);
1637       handle->powered_off = 1;
1638     }
1639   if (handle->idev)
1640     {
1641       usb_release_interface (handle->idev, handle->ifc_no);
1642       usb_close (handle->idev);
1643       handle->idev = NULL;
1644     }
1645   if (handle->dev_fd != -1)
1646     {
1647       close (handle->dev_fd);
1648       handle->dev_fd = -1;
1649     }
1650 }
1651
1652
1653 /* Reset a reader on HANDLE.  This is useful in case a reader has been
1654    plugged of and inserted at a different port.  By resetting the
1655    handle, the same reader will be get used.  Note, that on error the
1656    handle won't get released. 
1657
1658    This does not return an ATR, so ccid_get_atr should be called right
1659    after this one.
1660 */
1661 int 
1662 ccid_shutdown_reader (ccid_driver_t handle)
1663 {
1664   int rc = 0;
1665   struct usb_device *dev = NULL;
1666   usb_dev_handle *idev = NULL;
1667   unsigned char *ifcdesc_extra = NULL;
1668   size_t ifcdesc_extra_len;
1669   int ifc_no, ep_bulk_out, ep_bulk_in, ep_intr;
1670
1671   if (!handle || !handle->rid)
1672     return CCID_DRIVER_ERR_INV_VALUE;
1673
1674   do_close_reader (handle);
1675
1676   if (scan_or_find_devices (-1, handle->rid, NULL, &dev,
1677                             &ifcdesc_extra, &ifcdesc_extra_len,
1678                             &ifc_no, &ep_bulk_out, &ep_bulk_in, &ep_intr,
1679                             &idev, NULL) || !idev)
1680     {
1681       DEBUGOUT_1 ("no CCID reader with ID %s\n", handle->rid);
1682       return CCID_DRIVER_ERR_NO_READER;
1683     }
1684
1685   if (idev)
1686     {
1687       handle->idev = idev;
1688       handle->ifc_no = ifc_no;
1689       handle->ep_bulk_out = ep_bulk_out;
1690       handle->ep_bulk_in = ep_bulk_in;
1691       handle->ep_intr = ep_intr;
1692
1693       if (parse_ccid_descriptor (handle, ifcdesc_extra, ifcdesc_extra_len))
1694         {
1695           DEBUGOUT ("device not supported\n");
1696           rc = CCID_DRIVER_ERR_NO_READER;
1697           goto leave;
1698         }
1699       
1700       rc = usb_claim_interface (idev, ifc_no);
1701       if (rc)
1702         {
1703           DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
1704           rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1705           goto leave;
1706         }
1707     }
1708
1709  leave:
1710   free (ifcdesc_extra);
1711   if (rc)
1712     {
1713       if (handle->idev)
1714         usb_close (handle->idev);
1715       handle->idev = NULL;
1716       if (handle->dev_fd != -1)
1717         close (handle->dev_fd);
1718       handle->dev_fd = -1;
1719     }
1720
1721   return rc;
1722
1723 }
1724
1725
1726 int 
1727 ccid_set_progress_cb (ccid_driver_t handle, 
1728                       void (*cb)(void *, const char *, int, int, int),
1729                       void *cb_arg)
1730 {
1731   if (!handle || !handle->rid)
1732     return CCID_DRIVER_ERR_INV_VALUE;
1733
1734   handle->progress_cb = cb;
1735   handle->progress_cb_arg = cb_arg;
1736   return 0;
1737 }
1738
1739
1740 /* Close the reader HANDLE. */
1741 int 
1742 ccid_close_reader (ccid_driver_t handle)
1743 {
1744   if (!handle || (!handle->idev && handle->dev_fd == -1))
1745     return 0;
1746
1747   do_close_reader (handle);
1748   free (handle->rid);
1749   free (handle);
1750   return 0;
1751 }
1752
1753
1754 /* Return False if a card is present and powered. */
1755 int
1756 ccid_check_card_presence (ccid_driver_t handle)
1757 {
1758   (void)handle;  /* Not yet implemented.  */
1759   return -1;
1760 }
1761
1762
1763 /* Write NBYTES of BUF to file descriptor FD. */
1764 static int
1765 writen (int fd, const void *buf, size_t nbytes)
1766 {
1767   size_t nleft = nbytes;
1768   int nwritten;
1769   
1770   while (nleft > 0)
1771     {
1772       nwritten = write (fd, buf, nleft);
1773       if (nwritten < 0)
1774         {
1775           if (errno == EINTR)
1776             nwritten = 0;
1777           else
1778             return -1;
1779         }
1780       nleft -= nwritten;
1781       buf = (const char*)buf + nwritten;
1782     }
1783     
1784   return 0;
1785 }
1786
1787
1788 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
1789    Returns 0 on success. */
1790 static int
1791 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen,
1792           int no_debug)
1793 {
1794   int rc;
1795
1796   /* No need to continue and clutter the log with USB write error
1797      messages after we got the first ENODEV.  */
1798   if (handle->enodev_seen)
1799     return CCID_DRIVER_ERR_NO_READER;
1800
1801   if (debug_level && (!no_debug || debug_level >= 3))
1802     {
1803       switch (msglen? msg[0]:0)
1804         {
1805         case PC_to_RDR_IccPowerOn:
1806           print_p2r_iccpoweron (msg, msglen);
1807           break;
1808         case PC_to_RDR_IccPowerOff:
1809           print_p2r_iccpoweroff (msg, msglen);
1810           break;
1811         case PC_to_RDR_GetSlotStatus:
1812           print_p2r_getslotstatus (msg, msglen);
1813           break;
1814         case PC_to_RDR_XfrBlock:
1815           print_p2r_xfrblock (msg, msglen);
1816           break;
1817         case PC_to_RDR_GetParameters:
1818           print_p2r_getparameters (msg, msglen);
1819           break;
1820         case PC_to_RDR_ResetParameters:
1821           print_p2r_resetparameters (msg, msglen);
1822           break;
1823         case PC_to_RDR_SetParameters:
1824           print_p2r_setparameters (msg, msglen);
1825           break;
1826         case PC_to_RDR_Escape:
1827           print_p2r_escape (msg, msglen);
1828           break;
1829         case PC_to_RDR_IccClock:
1830           print_p2r_iccclock (msg, msglen);
1831           break;
1832         case PC_to_RDR_T0APDU:
1833           print_p2r_to0apdu (msg, msglen);
1834           break;
1835         case PC_to_RDR_Secure:
1836           print_p2r_secure (msg, msglen);
1837           break;
1838         case PC_to_RDR_Mechanical:
1839           print_p2r_mechanical (msg, msglen);
1840           break;
1841         case PC_to_RDR_Abort:
1842           print_p2r_abort (msg, msglen);
1843           break;
1844         case PC_to_RDR_SetDataRate:
1845           print_p2r_setdatarate (msg, msglen);
1846           break;
1847         default:
1848           print_p2r_unknown (msg, msglen);
1849           break;
1850         }
1851     }
1852   
1853   if (handle->idev)
1854     {
1855       rc = usb_bulk_write (handle->idev, 
1856                            handle->ep_bulk_out,
1857                            (char*)msg, msglen,
1858                            5000 /* ms timeout */);
1859       if (rc == msglen)
1860         return 0;
1861 #ifdef ENODEV
1862       if (rc == -(ENODEV))
1863         {
1864           /* The Linux libusb returns a negative error value.  Catch
1865              the most important one.  */
1866           errno = ENODEV;
1867           rc = -1;
1868         }
1869 #endif /*ENODEV*/
1870
1871       if (rc == -1)
1872         {
1873           DEBUGOUT_1 ("usb_bulk_write error: %s\n", strerror (errno));
1874 #ifdef ENODEV
1875           if (errno == ENODEV)
1876             {
1877               handle->enodev_seen = 1;
1878               return CCID_DRIVER_ERR_NO_READER;
1879             }
1880 #endif /*ENODEV*/
1881         }
1882       else
1883         DEBUGOUT_1 ("usb_bulk_write failed: %d\n", rc);
1884     }
1885   else
1886     {
1887       rc = writen (handle->dev_fd, msg, msglen);
1888       if (!rc)
1889         return 0;
1890       DEBUGOUT_2 ("writen to %d failed: %s\n",
1891                   handle->dev_fd, strerror (errno));
1892       
1893     }
1894   return CCID_DRIVER_ERR_CARD_IO_ERROR;
1895 }
1896
1897
1898 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
1899    BUFFER and return the actual read number if bytes in NREAD. SEQNO
1900    is the sequence number used to send the request and EXPECTED_TYPE
1901    the type of message we expect. Does checks on the ccid
1902    header. TIMEOUT is the timeout value in ms. NO_DEBUG may be set to
1903    avoid debug messages in case of no error; this can be overriden
1904    with a glibal debug level of at least 3. Returns 0 on success. */
1905 static int
1906 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
1907          size_t *nread, int expected_type, int seqno, int timeout,
1908          int no_debug)
1909 {
1910   int rc;
1911   size_t msglen;
1912   int eagain_retries = 0;
1913
1914   /* Fixme: The next line for the current Valgrind without support
1915      for USB IOCTLs. */
1916   memset (buffer, 0, length);
1917  retry:
1918   if (handle->idev)
1919     {
1920       rc = usb_bulk_read (handle->idev, 
1921                           handle->ep_bulk_in,
1922                           (char*)buffer, length,
1923                           timeout);
1924       if (rc < 0)
1925         {
1926           rc = errno;
1927           DEBUGOUT_1 ("usb_bulk_read error: %s\n", strerror (rc));
1928           if (rc == EAGAIN && eagain_retries++ < 3)
1929             {
1930               my_sleep (1);
1931               goto retry;
1932             }
1933           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1934         }
1935       *nread = msglen = rc;
1936     }
1937   else
1938     {
1939       rc = read (handle->dev_fd, buffer, length);
1940       if (rc < 0)
1941         {
1942           rc = errno;
1943           DEBUGOUT_2 ("read from %d failed: %s\n",
1944                       handle->dev_fd, strerror (rc));
1945           if (rc == EAGAIN && eagain_retries++ < 5)
1946             {
1947               my_sleep (1);
1948               goto retry;
1949             }
1950           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1951         }
1952       *nread = msglen = rc;
1953     }
1954   eagain_retries = 0;
1955
1956   if (msglen < 10)
1957     {
1958       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
1959       abort_cmd (handle, seqno);
1960       return CCID_DRIVER_ERR_INV_VALUE;
1961     }
1962   if (buffer[5] != 0)    
1963     {
1964       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
1965       return CCID_DRIVER_ERR_INV_VALUE;
1966     }
1967   if (buffer[6] != seqno)    
1968     {
1969       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
1970                   seqno, buffer[6]);
1971       /* Retry until we are synced again.  */
1972       goto retry;
1973     }
1974
1975   /* We need to handle the time extension request before we check that
1976      we got the expected message type.  This is in particular required
1977      for the Cherry keyboard which sends a time extension request for
1978      each key hit.  */
1979   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
1980     { 
1981       /* Card present and active, time extension requested. */
1982       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
1983                   buffer[7], buffer[8]);
1984       goto retry;
1985     }
1986
1987   if (buffer[0] != expected_type)
1988     {
1989       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
1990       abort_cmd (handle, seqno);
1991       return CCID_DRIVER_ERR_INV_VALUE;
1992     }
1993
1994   if (debug_level && (!no_debug || debug_level >= 3))
1995     {
1996       switch (buffer[0])
1997         {
1998         case RDR_to_PC_DataBlock:
1999           print_r2p_datablock (buffer, msglen);
2000           break;
2001         case RDR_to_PC_SlotStatus:
2002           print_r2p_slotstatus (buffer, msglen);
2003           break;
2004         case RDR_to_PC_Parameters:
2005           print_r2p_parameters (buffer, msglen);
2006           break;
2007         case RDR_to_PC_Escape:
2008           print_r2p_escape (buffer, msglen);
2009           break;
2010         case RDR_to_PC_DataRate:
2011           print_r2p_datarate (buffer, msglen);
2012           break;
2013         default:
2014           print_r2p_unknown (buffer, msglen);
2015           break;
2016         }
2017     }
2018   if (CCID_COMMAND_FAILED (buffer))
2019     print_command_failed (buffer);
2020
2021   /* Check whether a card is at all available.  Note: If you add new
2022      error codes here, check whether they need to be ignored in
2023      send_escape_cmd. */
2024   switch ((buffer[7] & 0x03))
2025     {
2026     case 0: /* no error */ break;
2027     case 1: return CCID_DRIVER_ERR_CARD_INACTIVE;
2028     case 2: return CCID_DRIVER_ERR_NO_CARD;
2029     case 3: /* RFU */ break;
2030     }
2031   return 0;
2032 }
2033
2034
2035
2036 /* Send an abort sequence and wait until everything settled.  */
2037 static int
2038 abort_cmd (ccid_driver_t handle, int seqno)
2039 {
2040   int rc;
2041   char dummybuf[8];
2042   unsigned char msg[100];
2043   size_t msglen;
2044
2045   if (!handle->idev)
2046     {
2047       /* I don't know how to send an abort to non-USB devices.  */
2048       rc = CCID_DRIVER_ERR_NOT_SUPPORTED;
2049     }
2050   
2051   seqno &= 0xff;
2052   DEBUGOUT_1 ("sending abort sequence for seqno %d\n", seqno);
2053   /* Send the abort command to the control pipe.  Note that we don't
2054      need to keep track of sent abort commands because there should
2055      never be another thread using the same slot concurrently.  */
2056   rc = usb_control_msg (handle->idev, 
2057                         0x21,/* bmRequestType: host-to-device,
2058                                 class specific, to interface.  */
2059                         1,   /* ABORT */
2060                         (seqno << 8 | 0 /* slot */),
2061                         handle->ifc_no,
2062                         dummybuf, 0,
2063                         1000 /* ms timeout */);
2064   if (rc < 0)
2065     {
2066       DEBUGOUT_1 ("usb_control_msg error: %s\n", strerror (errno));
2067       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2068     }
2069
2070   /* Now send the abort command to the bulk out pipe using the same
2071      SEQNO and SLOT.  Do this in a loop to so that all seqno are
2072      tried.  */
2073   seqno--;  /* Adjust for next increment.  */
2074   do
2075     {
2076       seqno++; 
2077       msg[0] = PC_to_RDR_Abort;
2078       msg[5] = 0; /* slot */
2079       msg[6] = seqno;
2080       msg[7] = 0; /* RFU */
2081       msg[8] = 0; /* RFU */
2082       msg[9] = 0; /* RFU */
2083       msglen = 10;
2084       set_msg_len (msg, 0);
2085
2086       rc = usb_bulk_write (handle->idev, 
2087                            handle->ep_bulk_out,
2088                            (char*)msg, msglen,
2089                            5000 /* ms timeout */);
2090       if (rc == msglen)
2091         rc = 0;
2092       else if (rc == -1)
2093         DEBUGOUT_1 ("usb_bulk_write error in abort_cmd: %s\n", 
2094                     strerror (errno));
2095       else
2096         DEBUGOUT_1 ("usb_bulk_write failed in abort_cmd: %d\n", rc);
2097
2098       if (rc)
2099         return rc;
2100       
2101       rc = usb_bulk_read (handle->idev, 
2102                           handle->ep_bulk_in,
2103                           (char*)msg, sizeof msg, 
2104                           5000 /*ms timeout*/);
2105       if (rc < 0)
2106         {
2107           DEBUGOUT_1 ("usb_bulk_read error in abort_cmd: %s\n",
2108                       strerror (errno));
2109           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2110         }
2111       msglen = rc;
2112
2113       if (msglen < 10)
2114         {
2115           DEBUGOUT_1 ("bulk-in msg in abort_cmd too short (%u)\n",
2116                       (unsigned int)msglen);
2117           return CCID_DRIVER_ERR_INV_VALUE;
2118         }
2119       if (msg[5] != 0)    
2120         {
2121           DEBUGOUT_1 ("unexpected bulk-in slot (%d) in abort_cmd\n", msg[5]);
2122           return CCID_DRIVER_ERR_INV_VALUE;
2123         }
2124
2125       DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n",
2126                   msg[7], msg[8], msg[9]);
2127       if (CCID_COMMAND_FAILED (msg))
2128         print_command_failed (msg);
2129     }
2130   while (msg[0] != RDR_to_PC_SlotStatus && msg[5] != 0 && msg[6] != seqno);
2131
2132   handle->seqno = ((seqno + 1) & 0xff);
2133   DEBUGOUT ("sending abort sequence succeeded\n");
2134
2135   return 0;
2136 }
2137
2138
2139 /* Note that this function won't return the error codes NO_CARD or
2140    CARD_INACTIVE.  IF RESULT is not NULL, the result from the
2141    operation will get returned in RESULT and its length in RESULTLEN.
2142    If the response is larger than RESULTMAX, an error is returned and
2143    the required buffer length returned in RESULTLEN.  */
2144 static int 
2145 send_escape_cmd (ccid_driver_t handle,
2146                  const unsigned char *data, size_t datalen,
2147                  unsigned char *result, size_t resultmax, size_t *resultlen)
2148 {
2149   int rc;
2150   unsigned char msg[100];
2151   size_t msglen;
2152   unsigned char seqno;
2153
2154   if (resultlen)
2155     *resultlen = 0;
2156
2157   if (datalen > sizeof msg - 10)
2158     return CCID_DRIVER_ERR_INV_VALUE; /* Escape data too large.  */
2159
2160   msg[0] = PC_to_RDR_Escape;
2161   msg[5] = 0; /* slot */
2162   msg[6] = seqno = handle->seqno++;
2163   msg[7] = 0; /* RFU */
2164   msg[8] = 0; /* RFU */
2165   msg[9] = 0; /* RFU */
2166   memcpy (msg+10, data, datalen);
2167   msglen = 10 + datalen;
2168   set_msg_len (msg, datalen);
2169
2170   rc = bulk_out (handle, msg, msglen, 0);
2171   if (rc)
2172     return rc;
2173   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Escape,
2174                 seqno, 5000, 0);
2175   if (result)
2176     switch (rc)
2177       {
2178         /* We need to ignore certain errorcode here. */
2179       case 0:
2180       case CCID_DRIVER_ERR_CARD_INACTIVE:
2181       case CCID_DRIVER_ERR_NO_CARD:
2182         {
2183           if (msglen > resultmax)
2184             rc = CCID_DRIVER_ERR_INV_VALUE; /* Response too large. */
2185           else
2186             {
2187               memcpy (result, msg, msglen);
2188               *resultlen = msglen;
2189             }
2190           rc = 0;
2191         }
2192         break;
2193       default:
2194         break;
2195       }
2196   
2197   return rc;
2198 }
2199
2200
2201 int
2202 ccid_transceive_escape (ccid_driver_t handle,
2203                         const unsigned char *data, size_t datalen,
2204                         unsigned char *resp, size_t maxresplen, size_t *nresp)
2205 {
2206   return send_escape_cmd (handle, data, datalen, resp, maxresplen, nresp);
2207 }
2208
2209
2210
2211 /* experimental */
2212 int
2213 ccid_poll (ccid_driver_t handle)
2214 {
2215   int rc;
2216   unsigned char msg[10];
2217   size_t msglen;
2218   int i, j;
2219
2220   if (handle->idev)
2221     {
2222       rc = usb_bulk_read (handle->idev, 
2223                           handle->ep_intr,
2224                           (char*)msg, sizeof msg,
2225                           0 /* ms timeout */ );
2226       if (rc < 0 && errno == ETIMEDOUT)
2227         return 0;
2228     }
2229   else 
2230     return 0;
2231
2232   if (rc < 0)
2233     {
2234       DEBUGOUT_1 ("usb_intr_read error: %s\n", strerror (errno));
2235       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2236     }
2237
2238   msglen = rc;
2239   rc = 0;
2240
2241   if (msglen < 1)
2242     {
2243       DEBUGOUT ("intr-in msg too short\n");
2244       return CCID_DRIVER_ERR_INV_VALUE;
2245     }
2246
2247   if (msg[0] == RDR_to_PC_NotifySlotChange)
2248     {
2249       DEBUGOUT ("notify slot change:");
2250       for (i=1; i < msglen; i++)
2251         for (j=0; j < 4; j++)
2252           DEBUGOUT_CONT_3 (" %d:%c%c",
2253                            (i-1)*4+j, 
2254                            (msg[i] & (1<<(j*2)))? 'p':'-',
2255                            (msg[i] & (2<<(j*2)))? '*':' ');
2256       DEBUGOUT_LF ();
2257     }
2258   else if (msg[0] == RDR_to_PC_HardwareError)    
2259     {
2260       DEBUGOUT ("hardware error occured\n");
2261     }
2262   else
2263     {
2264       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
2265     }
2266
2267   return 0;
2268 }
2269
2270
2271 /* Note that this function won't return the error codes NO_CARD or
2272    CARD_INACTIVE */
2273 int 
2274 ccid_slot_status (ccid_driver_t handle, int *statusbits)
2275 {
2276   int rc;
2277   unsigned char msg[100];
2278   size_t msglen;
2279   unsigned char seqno;
2280   int retries = 0;
2281
2282  retry:
2283   msg[0] = PC_to_RDR_GetSlotStatus;
2284   msg[5] = 0; /* slot */
2285   msg[6] = seqno = handle->seqno++;
2286   msg[7] = 0; /* RFU */
2287   msg[8] = 0; /* RFU */
2288   msg[9] = 0; /* RFU */
2289   set_msg_len (msg, 0);
2290
2291   rc = bulk_out (handle, msg, 10, 1);
2292   if (rc)
2293     return rc;
2294   /* Note that we set the NO_DEBUG flag here, so that the logs won't
2295      get cluttered up by a ticker function checking for the slot
2296      status and debugging enabled. */
2297   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
2298                 seqno, retries? 1000 : 200, 1);
2299   if (rc == CCID_DRIVER_ERR_CARD_IO_ERROR && retries < 3)
2300     {
2301       if (!retries)
2302         {
2303           DEBUGOUT ("USB: CALLING USB_CLEAR_HALT\n");
2304           usb_clear_halt (handle->idev, handle->ep_bulk_in);
2305           usb_clear_halt (handle->idev, handle->ep_bulk_out);
2306         }
2307       else
2308           DEBUGOUT ("USB: RETRYING bulk_in AGAIN\n");
2309       retries++;
2310       goto retry;
2311     }
2312   if (rc && rc != CCID_DRIVER_ERR_NO_CARD
2313       && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
2314     return rc;
2315   *statusbits = (msg[7] & 3);
2316
2317   return 0;
2318 }
2319
2320
2321 /* Return the ATR of the card.  This is not a cached value and thus an
2322    actual reset is done.  */
2323 int 
2324 ccid_get_atr (ccid_driver_t handle,
2325               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
2326 {
2327   int rc;
2328   int statusbits;
2329   unsigned char msg[100];
2330   unsigned char *tpdu;
2331   size_t msglen, tpdulen;
2332   unsigned char seqno;
2333   int use_crc = 0;
2334   unsigned int edc;
2335   int tried_iso = 0;
2336   int got_param;
2337
2338   /* First check whether a card is available.  */
2339   rc = ccid_slot_status (handle, &statusbits);
2340   if (rc)
2341     return rc;
2342   if (statusbits == 2)
2343     return CCID_DRIVER_ERR_NO_CARD;
2344
2345   /* For an inactive and also for an active card, issue the PowerOn
2346      command to get the ATR.  */
2347  again:
2348   msg[0] = PC_to_RDR_IccPowerOn;
2349   msg[5] = 0; /* slot */
2350   msg[6] = seqno = handle->seqno++;
2351   msg[7] = 0; /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
2352   msg[8] = 0; /* RFU */
2353   msg[9] = 0; /* RFU */
2354   set_msg_len (msg, 0);
2355   msglen = 10;
2356
2357   rc = bulk_out (handle, msg, msglen, 0);
2358   if (rc)
2359     return rc;
2360   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2361                 seqno, 5000, 0);
2362   if (rc)
2363     return rc;
2364   if (!tried_iso && CCID_COMMAND_FAILED (msg) && CCID_ERROR_CODE (msg) == 0xbb
2365       && ((handle->id_vendor == VENDOR_CHERRY
2366            && handle->id_product == 0x0005)
2367           || (handle->id_vendor == VENDOR_GEMPC
2368               && handle->id_product == 0x4433)
2369           ))
2370     {
2371       tried_iso = 1;
2372       /* Try switching to ISO mode. */
2373       if (!send_escape_cmd (handle, (const unsigned char*)"\xF1\x01", 2,
2374                             NULL, 0, NULL))
2375         goto again;
2376     }
2377   else if (CCID_COMMAND_FAILED (msg))
2378     return CCID_DRIVER_ERR_CARD_IO_ERROR;
2379
2380
2381   handle->powered_off = 0;
2382   
2383   if (atr)
2384     {
2385       size_t n = msglen - 10;
2386
2387       if (n > maxatrlen)
2388         n = maxatrlen;
2389       memcpy (atr, msg+10, n);
2390       *atrlen = n;
2391     }
2392
2393   got_param = 0;
2394   msg[0] = PC_to_RDR_GetParameters;
2395   msg[5] = 0; /* slot */
2396   msg[6] = seqno = handle->seqno++;
2397   msg[7] = 0; /* RFU */
2398   msg[8] = 0; /* RFU */
2399   msg[9] = 0; /* RFU */
2400   set_msg_len (msg, 0);
2401   msglen = 10;
2402   rc = bulk_out (handle, msg, msglen, 0);
2403   if (!rc)
2404     rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2405                   seqno, 2000, 0);
2406   if (rc)
2407     DEBUGOUT ("GetParameters failed\n");
2408   else if (msglen == 17 && msg[9] == 1)
2409     got_param = 1;
2410
2411   /* Setup parameters to select T=1. */
2412   msg[0] = PC_to_RDR_SetParameters;
2413   msg[5] = 0; /* slot */
2414   msg[6] = seqno = handle->seqno++;
2415   msg[7] = 1; /* Select T=1. */
2416   msg[8] = 0; /* RFU */
2417   msg[9] = 0; /* RFU */
2418
2419   if (!got_param)
2420     {
2421       /* FIXME: Get those values from the ATR. */
2422       msg[10]= 0x01; /* Fi/Di */
2423       msg[11]= 0x10; /* LRC, direct convention. */
2424       msg[12]= 0;    /* Extra guardtime. */
2425       msg[13]= 0x41; /* BWI/CWI */
2426       msg[14]= 0;    /* No clock stoppping. */
2427       msg[15]= 254;  /* IFSC */
2428       msg[16]= 0;    /* Does not support non default NAD values. */
2429     }
2430   set_msg_len (msg, 7);
2431   msglen = 10 + 7;
2432
2433   rc = bulk_out (handle, msg, msglen, 0);
2434   if (rc)
2435     return rc;
2436   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2437                 seqno, 5000, 0);
2438   if (rc)
2439     DEBUGOUT ("SetParameters failed (ignored)\n");
2440
2441   if (!rc && msglen > 15 && msg[15] >= 16 && msg[15] <= 254 )
2442     handle->ifsc = msg[15];
2443   else
2444     handle->ifsc = 128; /* Something went wrong, assume 128 bytes.  */
2445
2446   handle->t1_ns = 0;
2447   handle->t1_nr = 0;
2448
2449   /* Send an S-Block with our maximum IFSD to the CCID.  */
2450   if (!handle->apdu_level && !handle->auto_ifsd)
2451     {
2452       tpdu = msg+10;
2453       /* NAD: DAD=1, SAD=0 */
2454       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2455       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
2456       tpdu[2] = 1;
2457       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32; 
2458       tpdulen = 4;
2459       edc = compute_edc (tpdu, tpdulen, use_crc);
2460       if (use_crc)
2461         tpdu[tpdulen++] = (edc >> 8);
2462       tpdu[tpdulen++] = edc;
2463
2464       msg[0] = PC_to_RDR_XfrBlock;
2465       msg[5] = 0; /* slot */
2466       msg[6] = seqno = handle->seqno++;
2467       msg[7] = 0; 
2468       msg[8] = 0; /* RFU */
2469       msg[9] = 0; /* RFU */
2470       set_msg_len (msg, tpdulen);
2471       msglen = 10 + tpdulen;
2472
2473       if (debug_level > 1)
2474         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
2475                       ((msg[11] & 0xc0) == 0x80)? 'R' :
2476                                 (msg[11] & 0x80)? 'S' : 'I',
2477                       ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2478                                        : !!(msg[11] & 0x40)),
2479                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2480
2481       rc = bulk_out (handle, msg, msglen, 0);
2482       if (rc)
2483         return rc;
2484
2485
2486       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2487                     RDR_to_PC_DataBlock, seqno, 5000, 0);
2488       if (rc)
2489         return rc;
2490       
2491       tpdu = msg + 10;
2492       tpdulen = msglen - 10;
2493       
2494       if (tpdulen < 4) 
2495         return CCID_DRIVER_ERR_ABORTED; 
2496
2497       if (debug_level > 1)
2498         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
2499                     ((msg[11] & 0xc0) == 0x80)? 'R' :
2500                               (msg[11] & 0x80)? 'S' : 'I',
2501                     ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2502                                      : !!(msg[11] & 0x40)),
2503                     ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
2504                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2505
2506       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
2507         {
2508           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
2509           return -1;
2510         }
2511       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
2512     }
2513
2514   return 0;
2515 }
2516
2517
2518 \f
2519
2520 static unsigned int 
2521 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
2522 {
2523   if (use_crc)
2524     {
2525       return 0x42; /* Not yet implemented. */
2526     }
2527   else
2528     {
2529       unsigned char crc = 0;
2530       
2531       for (; datalen; datalen--)
2532         crc ^= *data++;
2533       return crc;
2534     }
2535 }
2536
2537
2538 /* Return true if APDU is an extended length one.  */
2539 static int
2540 is_exlen_apdu (const unsigned char *apdu, size_t apdulen)
2541 {
2542   if (apdulen < 7 || apdu[4])
2543     return 0;  /* Too short or no Z byte.  */
2544   return 1;
2545 }
2546
2547
2548 /* Helper for ccid_transceive used for APDU level exchanges.  */
2549 static int
2550 ccid_transceive_apdu_level (ccid_driver_t handle,
2551                             const unsigned char *apdu_buf, size_t apdu_buflen,
2552                             unsigned char *resp, size_t maxresplen,
2553                             size_t *nresp)
2554 {
2555   int rc;
2556   unsigned char send_buffer[10+261+300], recv_buffer[10+261+300];
2557   const unsigned char *apdu;
2558   size_t apdulen;
2559   unsigned char *msg;
2560   size_t msglen;
2561   unsigned char seqno;
2562   int bwi = 4;
2563
2564   msg = send_buffer;
2565
2566   apdu = apdu_buf;
2567   apdulen = apdu_buflen;
2568   assert (apdulen);
2569
2570   /* The maximum length for a short APDU T=1 block is 261.  For an
2571      extended APDU T=1 block the maximum length 65544; however
2572      extended APDU exchange level is not yet supported.  */
2573   if (apdulen > 261)
2574     return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
2575   
2576   msg[0] = PC_to_RDR_XfrBlock;
2577   msg[5] = 0; /* slot */
2578   msg[6] = seqno = handle->seqno++;
2579   msg[7] = bwi; /* bBWI */
2580   msg[8] = 0; /* RFU */
2581   msg[9] = 0; /* RFU */
2582   memcpy (msg+10, apdu, apdulen);
2583   set_msg_len (msg, apdulen);
2584   msglen = 10 + apdulen;
2585
2586   rc = bulk_out (handle, msg, msglen, 0);
2587   if (rc)
2588     return rc;
2589
2590   msg = recv_buffer;
2591   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
2592                 RDR_to_PC_DataBlock, seqno, 5000, 0);
2593   if (rc)
2594     return rc;
2595       
2596   apdu = msg + 10;
2597   apdulen = msglen - 10;
2598       
2599   if (resp)
2600     {
2601       if (apdulen > maxresplen)
2602         {
2603           DEBUGOUT_2 ("provided buffer too short for received data "
2604                       "(%u/%u)\n",
2605                       (unsigned int)apdulen, (unsigned int)maxresplen);
2606           return CCID_DRIVER_ERR_INV_VALUE;
2607         }
2608       
2609       memcpy (resp, apdu, apdulen); 
2610       *nresp = apdulen;
2611     }
2612           
2613   return 0;
2614 }
2615
2616
2617
2618 /*
2619   Protocol T=1 overview
2620
2621   Block Structure:
2622            Prologue Field:
2623    1 byte     Node Address (NAD) 
2624    1 byte     Protocol Control Byte (PCB)
2625    1 byte     Length (LEN) 
2626            Information Field:
2627    0-254 byte APDU or Control Information (INF)
2628            Epilogue Field:
2629    1 byte     Error Detection Code (EDC)
2630
2631   NAD:  
2632    bit 7     unused
2633    bit 4..6  Destination Node Address (DAD)
2634    bit 3     unused
2635    bit 2..0  Source Node Address (SAD)
2636
2637    If node adresses are not used, SAD and DAD should be set to 0 on
2638    the first block sent to the card.  If they are used they should
2639    have different values (0 for one is okay); that first block sets up
2640    the addresses of the nodes.
2641
2642   PCB:
2643    Information Block (I-Block):
2644       bit 7    0
2645       bit 6    Sequence number (yep, that is modulo 2)
2646       bit 5    Chaining flag 
2647       bit 4..0 reserved
2648    Received-Ready Block (R-Block):
2649       bit 7    1
2650       bit 6    0
2651       bit 5    0
2652       bit 4    Sequence number
2653       bit 3..0  0 = no error
2654                 1 = EDC or parity error
2655                 2 = other error
2656                 other values are reserved
2657    Supervisory Block (S-Block):
2658       bit 7    1
2659       bit 6    1
2660       bit 5    clear=request,set=response
2661       bit 4..0  0 = resyncronisation request
2662                 1 = information field size request
2663                 2 = abort request
2664                 3 = extension of BWT request
2665                 4 = VPP error
2666                 other values are reserved
2667
2668 */
2669
2670 int
2671 ccid_transceive (ccid_driver_t handle,
2672                  const unsigned char *apdu_buf, size_t apdu_buflen,
2673                  unsigned char *resp, size_t maxresplen, size_t *nresp)
2674 {
2675   int rc;
2676   /* The size of the buffer used to be 10+259.  For the via_escape
2677      hack we need one extra byte, thus 11+259.  */
2678   unsigned char send_buffer[11+259], recv_buffer[11+259];
2679   const unsigned char *apdu;
2680   size_t apdulen;
2681   unsigned char *msg, *tpdu, *p;
2682   size_t msglen, tpdulen, last_tpdulen, n;
2683   unsigned char seqno;
2684   unsigned int edc;
2685   int use_crc = 0;
2686   int hdrlen, pcboff;
2687   size_t dummy_nresp;
2688   int via_escape = 0;
2689   int next_chunk = 1;
2690   int sending = 1;
2691   int retries = 0;
2692   int resyncing = 0;
2693   int nad_byte;
2694
2695   if (!nresp)
2696     nresp = &dummy_nresp;
2697   *nresp = 0;
2698
2699   /* Smarter readers allow to send APDUs directly; divert here. */
2700   if (handle->apdu_level)
2701     {
2702       /* We employ a hack for Omnikey readers which are able to send
2703          TPDUs using an escape sequence.  There is no documentation
2704          but the Windows driver does it this way.  Tested using a
2705          CM6121.  This method works also for the Cherry XX44
2706          keyboards; however there are problems with the
2707          ccid_tranceive_secure which leads to a loss of sync on the
2708          CCID level.  If Cherry wants to make their keyboard work
2709          again, they should hand over some docs. */
2710       if ((handle->id_vendor == VENDOR_OMNIKEY
2711            || (!handle->idev && handle->id_product == TRANSPORT_CM4040))
2712           && handle->apdu_level < 2
2713           && is_exlen_apdu (apdu_buf, apdu_buflen))
2714         via_escape = 1;
2715       else
2716         return ccid_transceive_apdu_level (handle, apdu_buf, apdu_buflen,
2717                                            resp, maxresplen, nresp);
2718     }
2719
2720   /* The other readers we support require sending TPDUs.  */
2721
2722   tpdulen = 0; /* Avoid compiler warning about no initialization. */
2723   msg = send_buffer;
2724   hdrlen = via_escape? 11 : 10;
2725
2726   /* NAD: DAD=1, SAD=0 */
2727   nad_byte = handle->nonnull_nad? ((1 << 4) | 0): 0;
2728   if (via_escape)
2729     nad_byte = 0;
2730
2731   last_tpdulen = 0;  /* Avoid gcc warning (controlled by RESYNCING). */
2732   for (;;)
2733     {
2734       if (next_chunk)
2735         {
2736           next_chunk = 0;
2737
2738           apdu = apdu_buf;
2739           apdulen = apdu_buflen;
2740           assert (apdulen);
2741
2742           /* Construct an I-Block. */
2743           tpdu = msg + hdrlen;
2744           tpdu[0] = nad_byte;
2745           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
2746           if (apdulen > handle->ifsc )
2747             {
2748               apdulen = handle->ifsc;
2749               apdu_buf += handle->ifsc;  
2750               apdu_buflen -= handle->ifsc;
2751               tpdu[1] |= (1 << 5); /* Set more bit. */
2752             }
2753           tpdu[2] = apdulen;
2754           memcpy (tpdu+3, apdu, apdulen);
2755           tpdulen = 3 + apdulen;
2756           edc = compute_edc (tpdu, tpdulen, use_crc);
2757           if (use_crc)
2758             tpdu[tpdulen++] = (edc >> 8);
2759           tpdu[tpdulen++] = edc;
2760         }
2761
2762       if (via_escape)
2763         {
2764           msg[0] = PC_to_RDR_Escape;
2765           msg[5] = 0; /* slot */
2766           msg[6] = seqno = handle->seqno++;
2767           msg[7] = 0; /* RFU */
2768           msg[8] = 0; /* RFU */
2769           msg[9] = 0; /* RFU */
2770           msg[10] = 0x1a; /* Omnikey command to send a TPDU.  */
2771           set_msg_len (msg, 1 + tpdulen);
2772         }
2773       else
2774         {
2775           msg[0] = PC_to_RDR_XfrBlock;
2776           msg[5] = 0; /* slot */
2777           msg[6] = seqno = handle->seqno++;
2778           msg[7] = 4; /* bBWI */
2779           msg[8] = 0; /* RFU */
2780           msg[9] = 0; /* RFU */
2781           set_msg_len (msg, tpdulen);
2782         }
2783       msglen = hdrlen + tpdulen;
2784       if (!resyncing)
2785         last_tpdulen = tpdulen;
2786       pcboff = hdrlen+1;
2787
2788       if (debug_level > 1)
2789         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
2790                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
2791                     (msg[pcboff] & 0x80)? 'S' : 'I',
2792                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
2793                      : !!(msg[pcboff] & 0x40)),
2794                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
2795                      " [more]":""));
2796       
2797       rc = bulk_out (handle, msg, msglen, 0);
2798       if (rc)
2799         return rc;
2800
2801       msg = recv_buffer;
2802       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
2803                     via_escape? RDR_to_PC_Escape : RDR_to_PC_DataBlock, 
2804                     seqno, 5000, 0);
2805       if (rc)
2806         return rc;
2807
2808       tpdu = msg + hdrlen;
2809       tpdulen = msglen - hdrlen;
2810       resyncing = 0;
2811             
2812       if (tpdulen < 4) 
2813         {
2814           usb_clear_halt (handle->idev, handle->ep_bulk_in);
2815           return CCID_DRIVER_ERR_ABORTED; 
2816         }
2817
2818       if (debug_level > 1)
2819         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
2820                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
2821                               (msg[pcboff] & 0x80)? 'S' : 'I',
2822                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
2823                      : !!(msg[pcboff] & 0x40)),
2824                     ((msg[pcboff] & 0xc0) == 0x80)? (msg[pcboff] & 0x0f) : 0,
2825                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
2826                      " [more]":""));
2827
2828       if (!(tpdu[1] & 0x80))
2829         { /* This is an I-block. */
2830           retries = 0;
2831           if (sending)
2832             { /* last block sent was successful. */
2833               handle->t1_ns ^= 1;
2834               sending = 0;
2835             }
2836
2837           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
2838             { /* Reponse does not match our sequence number. */
2839               msg = send_buffer;
2840               tpdu = msg + hdrlen;
2841               tpdu[0] = nad_byte;
2842               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
2843               tpdu[2] = 0;
2844               tpdulen = 3;
2845               edc = compute_edc (tpdu, tpdulen, use_crc);
2846               if (use_crc)
2847                 tpdu[tpdulen++] = (edc >> 8);
2848               tpdu[tpdulen++] = edc;
2849
2850               continue;
2851             }
2852
2853           handle->t1_nr ^= 1;
2854
2855           p = tpdu + 3; /* Skip the prologue field. */
2856           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
2857           /* fixme: verify the checksum. */
2858           if (resp)
2859             {
2860               if (n > maxresplen)
2861                 {
2862                   DEBUGOUT_2 ("provided buffer too short for received data "
2863                               "(%u/%u)\n",
2864                               (unsigned int)n, (unsigned int)maxresplen);
2865                   return CCID_DRIVER_ERR_INV_VALUE;
2866                 }
2867               
2868               memcpy (resp, p, n); 
2869               resp += n;
2870               *nresp += n;
2871               maxresplen -= n;
2872             }
2873           
2874           if (!(tpdu[1] & 0x20))
2875             return 0; /* No chaining requested - ready. */
2876           
2877           msg = send_buffer;
2878           tpdu = msg + hdrlen;
2879           tpdu[0] = nad_byte;
2880           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
2881           tpdu[2] = 0;
2882           tpdulen = 3;
2883           edc = compute_edc (tpdu, tpdulen, use_crc);
2884           if (use_crc)
2885             tpdu[tpdulen++] = (edc >> 8);
2886           tpdu[tpdulen++] = edc;
2887         }
2888       else if ((tpdu[1] & 0xc0) == 0x80)
2889         { /* This is a R-block. */
2890           if ( (tpdu[1] & 0x0f)) 
2891             { 
2892               retries++;
2893               if (via_escape && retries == 1 && (msg[pcboff] & 0x0f))
2894                 {
2895                   /* Error probably due to switching to TPDU.  Send a
2896                      resync request.  We use the recv_buffer so that
2897                      we don't corrupt the send_buffer.  */
2898                   msg = recv_buffer;
2899                   tpdu = msg + hdrlen;
2900                   tpdu[0] = nad_byte;
2901                   tpdu[1] = 0xc0; /* S-block resync request. */
2902                   tpdu[2] = 0;
2903                   tpdulen = 3;
2904                   edc = compute_edc (tpdu, tpdulen, use_crc);
2905                   if (use_crc)
2906                     tpdu[tpdulen++] = (edc >> 8);
2907                   tpdu[tpdulen++] = edc;
2908                   resyncing = 1;
2909                   DEBUGOUT ("T=1: requesting resync\n");
2910                 }
2911               else if (retries > 3)
2912                 {
2913                   DEBUGOUT ("T=1: 3 failed retries\n");
2914                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
2915                 }
2916               else
2917                 {
2918                   /* Error: repeat last block */
2919                   msg = send_buffer;
2920                   tpdulen = last_tpdulen;
2921                 }
2922             }
2923           else if (sending && !!(tpdu[1] & 0x10) == handle->t1_ns)
2924             { /* Response does not match our sequence number. */
2925               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
2926               return CCID_DRIVER_ERR_CARD_IO_ERROR;
2927             }
2928           else if (sending)
2929             { /* Send next chunk. */
2930               retries = 0;
2931               msg = send_buffer;
2932               next_chunk = 1;
2933               handle->t1_ns ^= 1;
2934             }
2935           else
2936             {
2937               DEBUGOUT ("unexpected ACK R-block received\n");
2938               return CCID_DRIVER_ERR_CARD_IO_ERROR;
2939             }
2940         }
2941       else 
2942         { /* This is a S-block. */
2943           retries = 0;
2944           DEBUGOUT_2 ("T=1: S-block %s received cmd=%d\n",
2945                       (tpdu[1] & 0x20)? "response": "request",
2946                       (tpdu[1] & 0x1f));
2947           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 1 && tpdu[2] == 1)
2948             {
2949               /* Information field size request.  */
2950               unsigned char ifsc = tpdu[3];
2951
2952               if (ifsc < 16 || ifsc > 254)
2953                 return CCID_DRIVER_ERR_CARD_IO_ERROR;
2954
2955               msg = send_buffer;
2956               tpdu = msg + hdrlen;
2957               tpdu[0] = nad_byte;
2958               tpdu[1] = (0xc0 | 0x20 | 1); /* S-block response */
2959               tpdu[2] = 1;
2960               tpdu[3] = ifsc;
2961               tpdulen = 4;
2962               edc = compute_edc (tpdu, tpdulen, use_crc);
2963               if (use_crc)
2964                 tpdu[tpdulen++] = (edc >> 8);
2965               tpdu[tpdulen++] = edc;
2966               DEBUGOUT_1 ("T=1: requesting an ifsc=%d\n", ifsc);
2967             }
2968           else if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
2969             {
2970               /* Wait time extension request. */
2971               unsigned char bwi = tpdu[3];
2972               msg = send_buffer;
2973               tpdu = msg + hdrlen;
2974               tpdu[0] = nad_byte;
2975               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
2976               tpdu[2] = 1;
2977               tpdu[3] = bwi;
2978               tpdulen = 4;
2979               edc = compute_edc (tpdu, tpdulen, use_crc);
2980               if (use_crc)
2981                 tpdu[tpdulen++] = (edc >> 8);
2982               tpdu[tpdulen++] = edc;
2983               DEBUGOUT_1 ("T=1: waittime extension of bwi=%d\n", bwi);
2984               print_progress (handle);
2985             }
2986           else if ( (tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 0 && !tpdu[2])
2987             {
2988               DEBUGOUT ("T=1: resync ack from reader\n");
2989               /* Repeat previous block.  */
2990               msg = send_buffer;
2991               tpdulen = last_tpdulen;
2992             }
2993           else
2994             return CCID_DRIVER_ERR_CARD_IO_ERROR;
2995         }
2996     } /* end T=1 protocol loop. */
2997
2998   return 0;
2999 }
3000
3001
3002 /* Send the CCID Secure command to the reader.  APDU_BUF should
3003    contain the APDU template.  PIN_MODE defines how the pin gets
3004    formatted:
3005    
3006      1 := The PIN is ASCII encoded and of variable length.  The
3007           length of the PIN entered will be put into Lc by the reader.
3008           The APDU should me made up of 4 bytes without Lc.
3009
3010    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
3011    may be used t enable reasonable defaults.  PIN_PADLEN should be 0.
3012    
3013    When called with RESP and NRESP set to NULL, the function will
3014    merely check whether the reader supports the secure command for the
3015    given APDU and PIN_MODE. */
3016 int
3017 ccid_transceive_secure (ccid_driver_t handle,
3018                         const unsigned char *apdu_buf, size_t apdu_buflen,
3019                         int pin_mode, int pinlen_min, int pinlen_max,
3020                         int pin_padlen, 
3021                         unsigned char *resp, size_t maxresplen, size_t *nresp)
3022 {
3023   int rc;
3024   unsigned char send_buffer[10+259], recv_buffer[10+259];
3025   unsigned char *msg, *tpdu, *p;
3026   size_t msglen, tpdulen, n;
3027   unsigned char seqno;
3028   size_t dummy_nresp;
3029   int testmode;
3030   int cherry_mode = 0;
3031
3032   testmode = !resp && !nresp;
3033
3034   if (!nresp)
3035     nresp = &dummy_nresp;
3036   *nresp = 0;
3037
3038   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
3039     ;
3040   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
3041     return CCID_DRIVER_ERR_NOT_SUPPORTED; /* Not yet by our code. */
3042   else
3043     return CCID_DRIVER_ERR_NO_KEYPAD;
3044     
3045   if (pin_mode != 1)
3046     return CCID_DRIVER_ERR_NOT_SUPPORTED;
3047
3048   if (pin_padlen != 0)
3049     return CCID_DRIVER_ERR_NOT_SUPPORTED;
3050
3051   if (!pinlen_min)
3052     pinlen_min = 1;
3053   if (!pinlen_max)
3054     pinlen_max = 25;
3055
3056   /* Note that the 25 is the maximum value the SPR532 allows.  */
3057   if (pinlen_min < 1 || pinlen_min > 25
3058       || pinlen_max < 1 || pinlen_max > 25 
3059       || pinlen_min > pinlen_max)
3060     return CCID_DRIVER_ERR_INV_VALUE;
3061
3062   /* We have only tested a few readers so better don't risk anything
3063      and do not allow the use with other readers. */
3064   switch (handle->id_vendor)
3065     {
3066     case VENDOR_SCM:  /* Tested with SPR 532. */
3067     case VENDOR_KAAN: /* Tested with KAAN Advanced (1.02). */
3068       break;
3069     case VENDOR_CHERRY:
3070       /* The CHERRY XX44 keyboard echos an asterisk for each entered
3071          character on the keyboard channel.  We use a special variant
3072          of PC_to_RDR_Secure which directs these characters to the
3073          smart card's bulk-in channel.  We also need to append a zero
3074          Lc byte to the APDU.  It seems that it will be replaced with
3075          the actual length instead of being appended before the APDU
3076          is send to the card. */
3077       cherry_mode = 1;
3078       break;
3079     default:
3080      return CCID_DRIVER_ERR_NOT_SUPPORTED;
3081     }
3082
3083   if (testmode)
3084     return 0; /* Success */
3085     
3086   msg = send_buffer;
3087   if (handle->id_vendor == VENDOR_SCM)
3088     {
3089       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
3090       rc = send_escape_cmd (handle, (const unsigned char*)"\x80\x02\x00", 3,
3091                             NULL, 0, NULL);
3092       if (rc)
3093         return rc;
3094     }
3095
3096   msg[0] = cherry_mode? 0x89 : PC_to_RDR_Secure;
3097   msg[5] = 0; /* slot */
3098   msg[6] = seqno = handle->seqno++;
3099   msg[7] = 0; /* bBWI */
3100   msg[8] = 0; /* RFU */
3101   msg[9] = 0; /* RFU */
3102   msg[10] = 0; /* Perform PIN verification. */
3103   msg[11] = 0; /* Timeout in seconds. */
3104   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
3105   if (handle->id_vendor == VENDOR_SCM)
3106     {
3107       /* For the SPR532 the next 2 bytes need to be zero.  We do this
3108          for all SCM products.  Kudos to Martin Paljak for this
3109          hint.  */
3110       msg[13] = msg[14] = 0;
3111     }
3112   else
3113     {
3114       msg[13] = 0x00; /* bmPINBlockString:
3115                          0 bits of pin length to insert. 
3116                          0 bytes of PIN block size.  */
3117       msg[14] = 0x00; /* bmPINLengthFormat:
3118                          Units are bytes, position is 0. */
3119     }
3120
3121   /* The following is a little endian word. */
3122   msg[15] = pinlen_max;   /* wPINMaxExtraDigit-Maximum.  */
3123   msg[16] = pinlen_min;   /* wPINMaxExtraDigit-Minimum.  */
3124
3125   msg[17] = 0x02; /* bEntryValidationCondition:
3126                      Validation key pressed */
3127   if (pinlen_min && pinlen_max && pinlen_min == pinlen_max)
3128     msg[17] |= 0x01; /* Max size reached.  */
3129   msg[18] = 0xff; /* bNumberMessage: Default. */
3130   msg[19] = 0x04; /* wLangId-High. */
3131   msg[20] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
3132   msg[21] = 0;    /* bMsgIndex. */
3133   /* bTeoProlog follows: */
3134   msg[22] = handle->nonnull_nad? ((1 << 4) | 0): 0;
3135   msg[23] = ((handle->t1_ns & 1) << 6); /* I-block */
3136   msg[24] = 0; /* The apdulen will be filled in by the reader.  */
3137   /* APDU follows:  */
3138   msg[25] = apdu_buf[0]; /* CLA */
3139   msg[26] = apdu_buf[1]; /* INS */
3140   msg[27] = apdu_buf[2]; /* P1 */
3141   msg[28] = apdu_buf[3]; /* P2 */
3142   msglen = 29;
3143   if (cherry_mode)
3144     msg[msglen++] = 0;
3145   /* An EDC is not required. */
3146   set_msg_len (msg, msglen - 10);
3147
3148   rc = bulk_out (handle, msg, msglen, 0);
3149   if (rc)
3150     return rc;
3151   
3152   msg = recv_buffer;
3153   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3154                 RDR_to_PC_DataBlock, seqno, 30000, 0);
3155   if (rc)
3156     return rc;
3157   
3158   tpdu = msg + 10;
3159   tpdulen = msglen - 10;
3160
3161   if (handle->apdu_level)
3162     {
3163       if (resp)
3164         {
3165           if (tpdulen > maxresplen)
3166             {
3167               DEBUGOUT_2 ("provided buffer too short for received data "
3168                           "(%u/%u)\n",
3169                           (unsigned int)tpdulen, (unsigned int)maxresplen);
3170               return CCID_DRIVER_ERR_INV_VALUE;
3171             }
3172           
3173           memcpy (resp, tpdu, tpdulen); 
3174           *nresp = tpdulen;
3175         }
3176       return 0;
3177     }
3178   
3179   if (tpdulen < 4) 
3180     {
3181       usb_clear_halt (handle->idev, handle->ep_bulk_in);
3182       return CCID_DRIVER_ERR_ABORTED; 
3183     }
3184   if (debug_level > 1)
3185     DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3186                 ((msg[11] & 0xc0) == 0x80)? 'R' :
3187                           (msg[11] & 0x80)? 'S' : 'I',
3188                 ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
3189                 ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
3190                 (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
3191
3192   if (!(tpdu[1] & 0x80))
3193     { /* This is an I-block. */
3194       /* Last block sent was successful. */
3195       handle->t1_ns ^= 1;
3196
3197       if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3198         { /* Reponse does not match our sequence number. */
3199           DEBUGOUT ("I-block with wrong seqno received\n");
3200           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3201         }
3202
3203       handle->t1_nr ^= 1;
3204
3205       p = tpdu + 3; /* Skip the prologue field. */
3206       n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3207       /* fixme: verify the checksum. */
3208       if (resp)
3209         {
3210           if (n > maxresplen)
3211             {
3212               DEBUGOUT_2 ("provided buffer too short for received data "
3213                           "(%u/%u)\n",
3214                           (unsigned int)n, (unsigned int)maxresplen);
3215               return CCID_DRIVER_ERR_INV_VALUE;
3216             }
3217               
3218           memcpy (resp, p, n); 
3219           resp += n;
3220           *nresp += n;
3221           maxresplen -= n;
3222         }
3223           
3224       if (!(tpdu[1] & 0x20))
3225         return 0; /* No chaining requested - ready. */
3226       
3227       DEBUGOUT ("chaining requested but not supported for Secure operation\n");
3228       return CCID_DRIVER_ERR_CARD_IO_ERROR;
3229     }
3230   else if ((tpdu[1] & 0xc0) == 0x80)
3231     { /* This is a R-block. */
3232       if ( (tpdu[1] & 0x0f)) 
3233         { /* Error: repeat last block */
3234           DEBUGOUT ("No retries supported for Secure operation\n");
3235           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3236         }
3237       else if (!!(tpdu[1] & 0x10) == handle->t1_ns)
3238         { /* Reponse does not match our sequence number. */
3239           DEBUGOUT ("R-block with wrong seqno received on more bit\n");
3240           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3241         }
3242       else
3243         { /* Send next chunk. */
3244           DEBUGOUT ("chaining not supported on Secure operation\n");
3245           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3246         }
3247     }
3248   else 
3249     { /* This is a S-block. */
3250       DEBUGOUT_2 ("T=1: S-block %s received cmd=%d for Secure operation\n",
3251                   (tpdu[1] & 0x20)? "response": "request",
3252                   (tpdu[1] & 0x1f));
3253       return CCID_DRIVER_ERR_CARD_IO_ERROR;
3254     } 
3255
3256   return 0;
3257 }
3258
3259
3260
3261
3262 #ifdef TEST
3263
3264
3265 static void
3266 print_error (int err)
3267 {
3268   const char *p;
3269   char buf[50];
3270
3271   switch (err)
3272     {
3273     case 0: p = "success";
3274     case CCID_DRIVER_ERR_OUT_OF_CORE: p = "out of core"; break;
3275     case CCID_DRIVER_ERR_INV_VALUE: p = "invalid value"; break;
3276     case CCID_DRIVER_ERR_NO_DRIVER: p = "no driver"; break;
3277     case CCID_DRIVER_ERR_NOT_SUPPORTED: p = "not supported"; break;
3278     case CCID_DRIVER_ERR_LOCKING_FAILED: p = "locking failed"; break;
3279     case CCID_DRIVER_ERR_BUSY: p = "busy"; break;
3280     case CCID_DRIVER_ERR_NO_CARD: p = "no card"; break;
3281     case CCID_DRIVER_ERR_CARD_INACTIVE: p = "card inactive"; break;
3282     case CCID_DRIVER_ERR_CARD_IO_ERROR: p = "card I/O error"; break;
3283     case CCID_DRIVER_ERR_GENERAL_ERROR: p = "general error"; break;
3284     case CCID_DRIVER_ERR_NO_READER: p = "no reader"; break;
3285     case CCID_DRIVER_ERR_ABORTED: p = "aborted"; break;
3286     default: sprintf (buf, "0x%05x", err); p = buf; break;
3287     }
3288   fprintf (stderr, "operation failed: %s\n", p);
3289 }
3290
3291
3292 static void
3293 print_data (const unsigned char *data, size_t length)
3294 {
3295   if (length >= 2)
3296     {
3297       fprintf (stderr, "operation status: %02X%02X\n",
3298                data[length-2], data[length-1]);
3299       length -= 2;
3300     }
3301   if (length)
3302     {
3303         fputs ("   returned data:", stderr);
3304         for (; length; length--, data++)
3305           fprintf (stderr, " %02X", *data);
3306         putc ('\n', stderr);
3307     }
3308 }
3309
3310 static void
3311 print_result (int rc, const unsigned char *data, size_t length)
3312 {
3313   if (rc)
3314     print_error (rc);
3315   else if (data)
3316     print_data (data, length);
3317 }
3318
3319 int
3320 main (int argc, char **argv)
3321 {
3322   int rc;
3323   ccid_driver_t ccid;
3324   int slotstat;
3325   unsigned char result[512];
3326   size_t resultlen;
3327   int no_pinpad = 0;
3328   int verify_123456 = 0;
3329   int did_verify = 0;
3330   int no_poll = 0;
3331
3332   if (argc)
3333     {
3334       argc--;
3335       argv++;
3336     }
3337
3338   while (argc)
3339     {
3340       if ( !strcmp (*argv, "--list"))
3341         {
3342           char *p;
3343           p = ccid_get_reader_list ();
3344           if (!p)
3345             return 1;
3346           fputs (p, stderr);
3347           free (p);
3348           return 0;
3349         }
3350       else if ( !strcmp (*argv, "--debug"))
3351         {
3352           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
3353           argc--; argv++;
3354         }
3355       else if ( !strcmp (*argv, "--no-poll"))
3356         {
3357           no_poll = 1;
3358           argc--; argv++;
3359         }
3360       else if ( !strcmp (*argv, "--no-pinpad"))
3361         {
3362           no_pinpad = 1;
3363           argc--; argv++;
3364         }
3365       else if ( !strcmp (*argv, "--verify-123456"))
3366         {
3367           verify_123456 = 1;
3368           argc--; argv++;
3369         }
3370       else
3371         break;
3372     }
3373
3374   rc = ccid_open_reader (&ccid, argc? *argv:NULL);
3375   if (rc)
3376     return 1;
3377
3378   if (!no_poll)
3379     ccid_poll (ccid);
3380   fputs ("getting ATR ...\n", stderr);
3381   rc = ccid_get_atr (ccid, NULL, 0, NULL);
3382   if (rc)
3383     {
3384       print_error (rc);
3385       return 1;
3386     }
3387
3388   if (!no_poll)
3389     ccid_poll (ccid);
3390   fputs ("getting slot status ...\n", stderr);
3391   rc = ccid_slot_status (ccid, &slotstat);
3392   if (rc)
3393     {
3394       print_error (rc);
3395       return 1;
3396     }
3397
3398   if (!no_poll)
3399     ccid_poll (ccid);
3400
3401   fputs ("selecting application OpenPGP ....\n", stderr);
3402   {
3403     static unsigned char apdu[] = {
3404       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
3405     rc = ccid_transceive (ccid,
3406                           apdu, sizeof apdu,
3407                           result, sizeof result, &resultlen);
3408     print_result (rc, result, resultlen);
3409   }
3410   
3411
3412   if (!no_poll)
3413     ccid_poll (ccid);
3414
3415   fputs ("getting OpenPGP DO 0x65 ....\n", stderr);
3416   {
3417     static unsigned char apdu[] = { 0, 0xCA, 0, 0x65, 254 };
3418     rc = ccid_transceive (ccid, apdu, sizeof apdu,
3419                           result, sizeof result, &resultlen);
3420     print_result (rc, result, resultlen);
3421   }
3422
3423   if (!no_pinpad)
3424     {
3425     }
3426
3427   if (!no_pinpad)
3428     {
3429       static unsigned char apdu[] = { 0, 0x20, 0, 0x81 };
3430
3431       
3432       if (ccid_transceive_secure (ccid,
3433                                   apdu, sizeof apdu,
3434                                   1, 0, 0, 0,
3435                                   NULL, 0, NULL))
3436         fputs ("can't verify using a PIN-Pad reader\n", stderr);
3437       else
3438         {
3439           fputs ("verifying CHV1 using the PINPad ....\n", stderr);
3440           
3441           rc = ccid_transceive_secure (ccid,
3442                                        apdu, sizeof apdu,
3443                                        1, 0, 0, 0,
3444                                        result, sizeof result, &resultlen);
3445           print_result (rc, result, resultlen);
3446           did_verify = 1;
3447         }
3448     }
3449   
3450   if (verify_123456 && !did_verify)
3451     {
3452       fputs ("verifying that CHV1 is 123456....\n", stderr);
3453       {
3454         static unsigned char apdu[] = {0, 0x20, 0, 0x81,
3455                                        6, '1','2','3','4','5','6'};
3456         rc = ccid_transceive (ccid, apdu, sizeof apdu,
3457                               result, sizeof result, &resultlen);
3458         print_result (rc, result, resultlen);
3459       }
3460     }
3461
3462   if (!rc)
3463     {
3464       fputs ("getting OpenPGP DO 0x5E ....\n", stderr);
3465       {
3466         static unsigned char apdu[] = { 0, 0xCA, 0, 0x5E, 254 };
3467         rc = ccid_transceive (ccid, apdu, sizeof apdu,
3468                               result, sizeof result, &resultlen);
3469         print_result (rc, result, resultlen);
3470       }
3471     }
3472
3473   ccid_close_reader (ccid);
3474
3475   return 0;
3476 }
3477
3478 /*
3479  * Local Variables:
3480  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
3481  * End:
3482  */
3483 #endif /*TEST*/
3484 #endif /*HAVE_LIBUSB*/