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