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