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