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