scd: Migrate to new API of libusb 1.0.
[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->num_altsetting; set_no++)
1159             {
1160               ifcdesc = (config->interface->altsetting + set_no);
1161               /* The second condition is for older SCM SPR 532 who did
1162                  not know about the assigned CCID class.  The third
1163                  condition does the same for a Cherry SmartTerminal
1164                  ST-2000.  Instead of trying to interpret the strings
1165                  we simply check the product ID. */
1166               if (ifcdesc && ifcdesc->extra
1167                   && ((ifcdesc->bInterfaceClass == 11
1168                        && ifcdesc->bInterfaceSubClass == 0
1169                        && ifcdesc->bInterfaceProtocol == 0)
1170                       || (ifcdesc->bInterfaceClass == 255
1171                           && desc->idVendor == VENDOR_SCM
1172                           && desc->idProduct == SCM_SPR532)
1173                       || (ifcdesc->bInterfaceClass == 255
1174                           && desc->idVendor == VENDOR_CHERRY
1175                           && desc->idProduct == CHERRY_ST2000)))
1176                 {
1177                   err = libusb_open (dev, &idev);
1178                   if (err < 0)
1179                     {
1180                       DEBUGOUT_1 ("usb_open failed: %s\n",
1181                                   libusb_error_name (err));
1182                       continue; /* with next setting. */
1183                     }
1184
1185                   rid = make_reader_id (idev,
1186                                         desc->idVendor,
1187                                         desc->idProduct,
1188                                         desc->iSerialNumber);
1189                   if (rid)
1190                     {
1191                       if (scan_mode)
1192                         {
1193                           char *p;
1194
1195                           /* We are collecting infos about all
1196                              available CCID readers.  Store them and
1197                              continue. */
1198                           DEBUGOUT_2 ("found CCID reader %d (ID=%s)\n",
1199                                       *count, rid );
1200                           p = malloc ((*rid_list? strlen (*rid_list):0) + 1
1201                                       + strlen (rid) + 1);
1202                           if (p)
1203                             {
1204                               *p = 0;
1205                               if (*rid_list)
1206                                 {
1207                                   strcat (p, *rid_list);
1208                                   free (*rid_list);
1209                                 }
1210                               strcat (p, rid);
1211                               strcat (p, "\n");
1212                               *rid_list = p;
1213                             }
1214                           else /* Out of memory. */
1215                             free (rid);
1216
1217                           rid = NULL;
1218                           ++*count;
1219                         }
1220                       else if (!*readerno
1221                                || (*readerno < 0
1222                                    && readerid
1223                                    && !strcmp (readerid, rid)))
1224                         {
1225                           /* We found the requested reader. */
1226                           if (ifcdesc_extra && ifcdesc_extra_len)
1227                             {
1228                               *ifcdesc_extra = malloc (ifcdesc
1229                                                        ->extra_length);
1230                               if (!*ifcdesc_extra)
1231                                 {
1232                                   libusb_close (idev);
1233                                   free (rid);
1234                                   return 1; /* Out of core. */
1235                                 }
1236                               memcpy (*ifcdesc_extra, ifcdesc->extra,
1237                                       ifcdesc->extra_length);
1238                               *ifcdesc_extra_len = ifcdesc->extra_length;
1239                             }
1240
1241                           if (interface_number)
1242                             *interface_number = (ifcdesc->bInterfaceNumber);
1243
1244                           if (ep_bulk_out)
1245                             *ep_bulk_out = find_endpoint (ifcdesc, 0);
1246                           if (ep_bulk_in)
1247                             *ep_bulk_in = find_endpoint (ifcdesc, 1);
1248                           if (ep_intr)
1249                             *ep_intr = find_endpoint (ifcdesc, 2);
1250
1251                           if (r_rid)
1252                             {
1253                               *r_rid = rid;
1254                               rid = NULL;
1255                             }
1256                           else
1257                             free (rid);
1258
1259                           *r_idev = idev;
1260                           return 1; /* Found requested device. */
1261                         }
1262                       else
1263                         {
1264                           /* This is not yet the reader we want.
1265                              fixme: We should avoid the extra usb_open
1266                              in this case. */
1267                           if (*readerno >= 0)
1268                             --*readerno;
1269                         }
1270                       free (rid);
1271                     }
1272
1273                   libusb_close (idev);
1274                   idev = NULL;
1275                   return 0;
1276                 }
1277             }
1278         }
1279     }
1280
1281   return 0;
1282 }
1283
1284 /* Combination function to either scan all CCID devices or to find and
1285    open one specific device.
1286
1287    The function returns 0 if a reader has been found or when a scan
1288    returned without error.
1289
1290    With READERNO = -1 and READERID is NULL, scan mode is used and
1291    R_RID should be the address where to store the list of reader_ids
1292    we found.  If on return this list is empty, no CCID device has been
1293    found; otherwise it points to an allocated linked list of reader
1294    IDs.  Note that in this mode the function always returns NULL.
1295
1296    With READERNO >= 0 or READERID is not NULL find mode is used.  This
1297    uses the same algorithm as the scan mode but stops and returns at
1298    the entry number READERNO and return the handle for the the opened
1299    USB device. If R_RID is not NULL it will receive the reader ID of
1300    that device.  If R_DEV is not NULL it will the device pointer of
1301    that device.  If IFCDESC_EXTRA is NOT NULL it will receive a
1302    malloced copy of the interfaces "extra: data filed;
1303    IFCDESC_EXTRA_LEN receive the length of this field.  If there is
1304    no reader with number READERNO or that reader is not usable by our
1305    implementation NULL will be returned.  The caller must close a
1306    returned USB device handle and free (if not passed as NULL) the
1307    returned reader ID info as well as the IFCDESC_EXTRA.  On error
1308    NULL will get stored at R_RID, R_DEV, IFCDESC_EXTRA and
1309    IFCDESC_EXTRA_LEN.  With READERID being -1 the function stops if
1310    the READERID was found.
1311
1312    If R_FD is not -1 on return the device is not using USB for
1313    transport but the device associated with that file descriptor.  In
1314    this case INTERFACE will receive the transport type and the other
1315    USB specific return values are not used; the return value is
1316    (void*)(1).
1317
1318    Note that the first entry of the returned reader ID list in scan mode
1319    corresponds with a READERNO of 0 in find mode.
1320 */
1321 static int
1322 scan_or_find_devices (int readerno, const char *readerid,
1323                       char **r_rid,
1324                       struct libusb_device_descriptor *r_desc,
1325                       unsigned char **ifcdesc_extra,
1326                       size_t *ifcdesc_extra_len,
1327                       int *interface_number,
1328                       int *ep_bulk_out, int *ep_bulk_in, int *ep_intr,
1329                       libusb_device_handle **r_idev,
1330                       int *r_fd)
1331 {
1332   char *rid_list = NULL;
1333   int count = 0;
1334   libusb_device **dev_list = NULL;
1335   libusb_device *dev;
1336   libusb_device_handle *idev = NULL;
1337   int scan_mode = (readerno == -1 && !readerid);
1338   int i;
1339   ssize_t n;
1340   struct libusb_device_descriptor desc;
1341
1342   /* Set return values to a default. */
1343   if (r_rid)
1344     *r_rid = NULL;
1345   if (ifcdesc_extra)
1346     *ifcdesc_extra = NULL;
1347   if (ifcdesc_extra_len)
1348     *ifcdesc_extra_len = 0;
1349   if (interface_number)
1350     *interface_number = 0;
1351   if (r_idev)
1352     *r_idev = NULL;
1353   if (r_fd)
1354     *r_fd = -1;
1355
1356   /* See whether we want scan or find mode. */
1357   if (scan_mode)
1358     {
1359       assert (r_rid);
1360     }
1361
1362   n = libusb_get_device_list (NULL, &dev_list);
1363
1364   for (i = 0; i < n; i++)
1365     {
1366       dev = dev_list[i];
1367       if (scan_or_find_usb_device (scan_mode, &readerno, &count, &rid_list,
1368                                    readerid,
1369                                    dev,
1370                                    r_rid,
1371                                    &desc,
1372                                    &idev,
1373                                    ifcdesc_extra,
1374                                    ifcdesc_extra_len,
1375                                    interface_number,
1376                                    ep_bulk_out, ep_bulk_in, ep_intr))
1377         {
1378           /* Found requested device or out of core. */
1379           if (!idev)
1380             {
1381               free (rid_list);
1382               return -1; /* error */
1383             }
1384           *r_idev = idev;
1385           if (r_desc)
1386             memcpy (r_desc, &desc, sizeof (struct libusb_device_descriptor));
1387           return 0;
1388         }
1389     }
1390
1391   /* Now check whether there are any devices with special transport types. */
1392   for (i=0; transports[i].name; i++)
1393     {
1394       int fd;
1395       char *rid, *p;
1396
1397       fd = open (transports[i].name, O_RDWR);
1398       if (fd == -1 && scan_mode && errno == EBUSY)
1399         {
1400           /* Ignore this error in scan mode because it indicates that
1401              the device exists but is already open (most likely by us)
1402              and thus in general suitable as a reader.  */
1403         }
1404       else if (fd == -1)
1405         {
1406           DEBUGOUT_2 ("failed to open '%s': %s\n",
1407                      transports[i].name, strerror (errno));
1408           continue;
1409         }
1410
1411       rid = malloc (strlen (transports[i].name) + 30 + 10);
1412       if (!rid)
1413         {
1414           if (fd != -1)
1415             close (fd);
1416           free (rid_list);
1417           return -1; /* Error. */
1418         }
1419       sprintf (rid, "0000:%04X:%s:0", transports[i].type, transports[i].name);
1420       if (scan_mode)
1421         {
1422           DEBUGOUT_2 ("found CCID reader %d (ID=%s)\n", count, rid);
1423           p = malloc ((rid_list? strlen (rid_list):0) + 1 + strlen (rid) + 1);
1424           if (!p)
1425             {
1426               if (fd != -1)
1427                 close (fd);
1428               free (rid_list);
1429               free (rid);
1430               return -1; /* Error. */
1431             }
1432           *p = 0;
1433           if (rid_list)
1434             {
1435               strcat (p, rid_list);
1436               free (rid_list);
1437             }
1438           strcat (p, rid);
1439           strcat (p, "\n");
1440           rid_list = p;
1441           ++count;
1442         }
1443       else if (!readerno ||
1444                (readerno < 0 && readerid && !strcmp (readerid, rid)))
1445         {
1446           /* Found requested device. */
1447           if (interface_number)
1448             *interface_number = transports[i].type;
1449           if (r_rid)
1450             *r_rid = rid;
1451           else
1452             free (rid);
1453           if (r_fd)
1454             *r_fd = fd;
1455           return 0; /* Okay, found device */
1456         }
1457       else /* This is not yet the reader we want. */
1458         {
1459           if (readerno >= 0)
1460             --readerno;
1461         }
1462       free (rid);
1463       if (fd != -1)
1464         close (fd);
1465     }
1466
1467   if (scan_mode)
1468     {
1469       *r_rid = rid_list;
1470       return 0;
1471     }
1472   else
1473     return -1;
1474 }
1475
1476
1477 /* Set the level of debugging to LEVEL and return the old level.  -1
1478    just returns the old level.  A level of 0 disables debugging, 1
1479    enables debugging, 2 enables additional tracing of the T=1
1480    protocol, 3 additionally enables debugging for GetSlotStatus, other
1481    values are not yet defined.
1482
1483    Note that libusb may provide its own debugging feature which is
1484    enabled by setting the envvar USB_DEBUG.  */
1485 int
1486 ccid_set_debug_level (int level)
1487 {
1488   int old = debug_level;
1489   if (level != -1)
1490     debug_level = level;
1491   return old;
1492 }
1493
1494
1495 char *
1496 ccid_get_reader_list (void)
1497 {
1498   char *reader_list;
1499
1500   if (!initialized_usb)
1501     {
1502       libusb_init (NULL);
1503       initialized_usb = 1;
1504     }
1505
1506   if (scan_or_find_devices (-1, NULL, &reader_list, NULL, NULL, NULL, NULL,
1507                             NULL, NULL, NULL, NULL, NULL))
1508     return NULL; /* Error. */
1509   return reader_list;
1510 }
1511
1512
1513 /* Vendor specific custom initialization.  */
1514 static int
1515 ccid_vendor_specific_init (ccid_driver_t handle)
1516 {
1517   if (handle->id_vendor == VENDOR_VEGA && handle->id_product == VEGA_ALPHA)
1518     {
1519       int r;
1520       /*
1521        * Vega alpha has a feature to show retry counter on the pinpad
1522        * display.  But it assumes that the card returns the value of
1523        * retry counter by VERIFY with empty data (return code of
1524        * 63Cx).  Unfortunately, existing OpenPGP cards don't support
1525        * VERIFY command with empty data.  This vendor specific command
1526        * sequence is to disable the feature.
1527        */
1528       const unsigned char cmd[] = { '\xb5', '\x01', '\x00', '\x03', '\x00' };
1529
1530       r = send_escape_cmd (handle, cmd, sizeof (cmd), NULL, 0, NULL);
1531       if (r != 0 && r != CCID_DRIVER_ERR_CARD_INACTIVE
1532           && r != CCID_DRIVER_ERR_NO_CARD)
1533         return r;
1534     }
1535
1536   return 0;
1537 }
1538
1539
1540 /* Open the reader with the internal number READERNO and return a
1541    pointer to be used as handle in HANDLE.  Returns 0 on success. */
1542 int
1543 ccid_open_reader (ccid_driver_t *handle, const char *readerid,
1544                   const char **rdrname_p)
1545 {
1546   int rc = 0;
1547   libusb_device_handle *idev = NULL;
1548   int dev_fd = -1;
1549   char *rid = NULL;
1550   unsigned char *ifcdesc_extra = NULL;
1551   size_t ifcdesc_extra_len;
1552   int readerno;
1553   int ifc_no, ep_bulk_out, ep_bulk_in, ep_intr;
1554   struct libusb_device_descriptor desc;
1555
1556   *handle = NULL;
1557
1558   if (!initialized_usb)
1559     {
1560       libusb_init (NULL);
1561       initialized_usb = 1;
1562     }
1563
1564   /* See whether we want to use the reader ID string or a reader
1565      number. A readerno of -1 indicates that the reader ID string is
1566      to be used. */
1567   if (readerid && strchr (readerid, ':'))
1568     readerno = -1; /* We want to use the readerid.  */
1569   else if (readerid)
1570     {
1571       readerno = atoi (readerid);
1572       if (readerno < 0)
1573         {
1574           DEBUGOUT ("no CCID readers found\n");
1575           rc = CCID_DRIVER_ERR_NO_READER;
1576           goto leave;
1577         }
1578     }
1579   else
1580     readerno = 0;  /* Default. */
1581
1582   if (scan_or_find_devices (readerno, readerid, &rid, &desc,
1583                             &ifcdesc_extra, &ifcdesc_extra_len,
1584                             &ifc_no, &ep_bulk_out, &ep_bulk_in, &ep_intr,
1585                             &idev, &dev_fd) )
1586     {
1587       if (readerno == -1)
1588         DEBUGOUT_1 ("no CCID reader with ID %s\n", readerid );
1589       else
1590         DEBUGOUT_1 ("no CCID reader with number %d\n", readerno );
1591       rc = CCID_DRIVER_ERR_NO_READER;
1592       goto leave;
1593     }
1594
1595   /* Okay, this is a CCID reader. */
1596   *handle = calloc (1, sizeof **handle);
1597   if (!*handle)
1598     {
1599       DEBUGOUT ("out of memory\n");
1600       rc = CCID_DRIVER_ERR_OUT_OF_CORE;
1601       goto leave;
1602     }
1603   (*handle)->rid = rid;
1604   if (idev) /* Regular USB transport. */
1605     {
1606       (*handle)->idev = idev;
1607       (*handle)->dev_fd = -1;
1608       (*handle)->id_vendor = desc.idVendor;
1609       (*handle)->id_product = desc.idProduct;
1610       (*handle)->bcd_device = desc.bcdDevice;
1611       (*handle)->ifc_no = ifc_no;
1612       (*handle)->ep_bulk_out = ep_bulk_out;
1613       (*handle)->ep_bulk_in = ep_bulk_in;
1614       (*handle)->ep_intr = ep_intr;
1615     }
1616   else if (dev_fd != -1) /* Device transport. */
1617     {
1618       (*handle)->idev = NULL;
1619       (*handle)->dev_fd = dev_fd;
1620       (*handle)->id_vendor = 0;  /* Magic vendor for special transport. */
1621       (*handle)->id_product = ifc_no; /* Transport type */
1622       prepare_special_transport (*handle);
1623     }
1624   else
1625     {
1626       assert (!"no transport"); /* Bug. */
1627     }
1628
1629   DEBUGOUT_2 ("using CCID reader %d (ID=%s)\n",  readerno, rid );
1630
1631   if (idev)
1632     {
1633       if (parse_ccid_descriptor (*handle, ifcdesc_extra, ifcdesc_extra_len))
1634         {
1635           DEBUGOUT ("device not supported\n");
1636           rc = CCID_DRIVER_ERR_NO_READER;
1637           goto leave;
1638         }
1639
1640       rc = libusb_claim_interface (idev, ifc_no);
1641       if (rc < 0)
1642         {
1643           DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
1644           rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1645           goto leave;
1646         }
1647     }
1648
1649   rc = ccid_vendor_specific_init (*handle);
1650
1651  leave:
1652   free (ifcdesc_extra);
1653   if (rc)
1654     {
1655       free (rid);
1656       if (idev)
1657         libusb_close (idev);
1658       if (dev_fd != -1)
1659         close (dev_fd);
1660       free (*handle);
1661       *handle = NULL;
1662     }
1663   else
1664     if (rdrname_p)
1665       *rdrname_p = (*handle)->rid;
1666
1667   return rc;
1668 }
1669
1670
1671 static void
1672 do_close_reader (ccid_driver_t handle)
1673 {
1674   int rc;
1675   unsigned char msg[100];
1676   size_t msglen;
1677   unsigned char seqno;
1678
1679   if (!handle->powered_off)
1680     {
1681       msg[0] = PC_to_RDR_IccPowerOff;
1682       msg[5] = 0; /* slot */
1683       msg[6] = seqno = handle->seqno++;
1684       msg[7] = 0; /* RFU */
1685       msg[8] = 0; /* RFU */
1686       msg[9] = 0; /* RFU */
1687       set_msg_len (msg, 0);
1688       msglen = 10;
1689
1690       rc = bulk_out (handle, msg, msglen, 0);
1691       if (!rc)
1692         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
1693                  seqno, 2000, 0);
1694       handle->powered_off = 1;
1695     }
1696   if (handle->idev)
1697     {
1698       libusb_release_interface (handle->idev, handle->ifc_no);
1699       libusb_close (handle->idev);
1700       handle->idev = NULL;
1701     }
1702   if (handle->dev_fd != -1)
1703     {
1704       close (handle->dev_fd);
1705       handle->dev_fd = -1;
1706     }
1707 }
1708
1709
1710 /* Reset a reader on HANDLE.  This is useful in case a reader has been
1711    plugged of and inserted at a different port.  By resetting the
1712    handle, the same reader will be get used.  Note, that on error the
1713    handle won't get released.
1714
1715    This does not return an ATR, so ccid_get_atr should be called right
1716    after this one.
1717 */
1718 int
1719 ccid_shutdown_reader (ccid_driver_t handle)
1720 {
1721   int rc = 0;
1722   libusb_device_handle *idev = NULL;
1723   unsigned char *ifcdesc_extra = NULL;
1724   size_t ifcdesc_extra_len;
1725   int ifc_no, ep_bulk_out, ep_bulk_in, ep_intr;
1726
1727   if (!handle || !handle->rid)
1728     return CCID_DRIVER_ERR_INV_VALUE;
1729
1730   do_close_reader (handle);
1731
1732   if (scan_or_find_devices (-1, handle->rid, NULL, NULL,
1733                             &ifcdesc_extra, &ifcdesc_extra_len,
1734                             &ifc_no, &ep_bulk_out, &ep_bulk_in, &ep_intr,
1735                             &idev, NULL) || !idev)
1736     {
1737       DEBUGOUT_1 ("no CCID reader with ID %s\n", handle->rid);
1738       return CCID_DRIVER_ERR_NO_READER;
1739     }
1740
1741   if (idev)
1742     {
1743       handle->idev = idev;
1744       handle->ifc_no = ifc_no;
1745       handle->ep_bulk_out = ep_bulk_out;
1746       handle->ep_bulk_in = ep_bulk_in;
1747       handle->ep_intr = ep_intr;
1748
1749       if (parse_ccid_descriptor (handle, ifcdesc_extra, ifcdesc_extra_len))
1750         {
1751           DEBUGOUT ("device not supported\n");
1752           rc = CCID_DRIVER_ERR_NO_READER;
1753           goto leave;
1754         }
1755
1756       rc = libusb_claim_interface (idev, ifc_no);
1757       if (rc)
1758         {
1759           DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
1760           rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1761           goto leave;
1762         }
1763     }
1764
1765  leave:
1766   free (ifcdesc_extra);
1767   if (rc)
1768     {
1769       if (handle->idev)
1770         libusb_close (handle->idev);
1771       handle->idev = NULL;
1772       if (handle->dev_fd != -1)
1773         close (handle->dev_fd);
1774       handle->dev_fd = -1;
1775     }
1776
1777   return rc;
1778
1779 }
1780
1781
1782 int
1783 ccid_set_progress_cb (ccid_driver_t handle,
1784                       void (*cb)(void *, const char *, int, int, int),
1785                       void *cb_arg)
1786 {
1787   if (!handle || !handle->rid)
1788     return CCID_DRIVER_ERR_INV_VALUE;
1789
1790   handle->progress_cb = cb;
1791   handle->progress_cb_arg = cb_arg;
1792   return 0;
1793 }
1794
1795
1796 /* Close the reader HANDLE. */
1797 int
1798 ccid_close_reader (ccid_driver_t handle)
1799 {
1800   if (!handle || (!handle->idev && handle->dev_fd == -1))
1801     return 0;
1802
1803   do_close_reader (handle);
1804   free (handle->rid);
1805   free (handle);
1806   return 0;
1807 }
1808
1809
1810 /* Return False if a card is present and powered. */
1811 int
1812 ccid_check_card_presence (ccid_driver_t handle)
1813 {
1814   (void)handle;  /* Not yet implemented.  */
1815   return -1;
1816 }
1817
1818
1819 /* Write NBYTES of BUF to file descriptor FD. */
1820 static int
1821 writen (int fd, const void *buf, size_t nbytes)
1822 {
1823   size_t nleft = nbytes;
1824   int nwritten;
1825
1826   while (nleft > 0)
1827     {
1828       nwritten = write (fd, buf, nleft);
1829       if (nwritten < 0)
1830         {
1831           if (errno == EINTR)
1832             nwritten = 0;
1833           else
1834             return -1;
1835         }
1836       nleft -= nwritten;
1837       buf = (const char*)buf + nwritten;
1838     }
1839
1840   return 0;
1841 }
1842
1843
1844 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
1845    Returns 0 on success. */
1846 static int
1847 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen,
1848           int no_debug)
1849 {
1850   int rc;
1851
1852   /* No need to continue and clutter the log with USB write error
1853      messages after we got the first ENODEV.  */
1854   if (handle->enodev_seen)
1855     return CCID_DRIVER_ERR_NO_READER;
1856
1857   if (debug_level && (!no_debug || debug_level >= 3))
1858     {
1859       switch (msglen? msg[0]:0)
1860         {
1861         case PC_to_RDR_IccPowerOn:
1862           print_p2r_iccpoweron (msg, msglen);
1863           break;
1864         case PC_to_RDR_IccPowerOff:
1865           print_p2r_iccpoweroff (msg, msglen);
1866           break;
1867         case PC_to_RDR_GetSlotStatus:
1868           print_p2r_getslotstatus (msg, msglen);
1869           break;
1870         case PC_to_RDR_XfrBlock:
1871           print_p2r_xfrblock (msg, msglen);
1872           break;
1873         case PC_to_RDR_GetParameters:
1874           print_p2r_getparameters (msg, msglen);
1875           break;
1876         case PC_to_RDR_ResetParameters:
1877           print_p2r_resetparameters (msg, msglen);
1878           break;
1879         case PC_to_RDR_SetParameters:
1880           print_p2r_setparameters (msg, msglen);
1881           break;
1882         case PC_to_RDR_Escape:
1883           print_p2r_escape (msg, msglen);
1884           break;
1885         case PC_to_RDR_IccClock:
1886           print_p2r_iccclock (msg, msglen);
1887           break;
1888         case PC_to_RDR_T0APDU:
1889           print_p2r_to0apdu (msg, msglen);
1890           break;
1891         case PC_to_RDR_Secure:
1892           print_p2r_secure (msg, msglen);
1893           break;
1894         case PC_to_RDR_Mechanical:
1895           print_p2r_mechanical (msg, msglen);
1896           break;
1897         case PC_to_RDR_Abort:
1898           print_p2r_abort (msg, msglen);
1899           break;
1900         case PC_to_RDR_SetDataRate:
1901           print_p2r_setdatarate (msg, msglen);
1902           break;
1903         default:
1904           print_p2r_unknown (msg, msglen);
1905           break;
1906         }
1907     }
1908
1909   if (handle->idev)
1910     {
1911       int transferred;
1912
1913       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
1914                                  (char*)msg, msglen, &transferred,
1915                                  5000 /* ms timeout */);
1916       if (rc == 0 && transferred == msglen)
1917         return 0;
1918
1919       if (rc < 0)
1920         {
1921           DEBUGOUT_1 ("usb_bulk_write error: %s\n", libusb_error_name (rc));
1922           if (rc == LIBUSB_ERROR_NO_DEVICE)
1923             {
1924               handle->enodev_seen = 1;
1925               return CCID_DRIVER_ERR_NO_READER;
1926             }
1927         }
1928     }
1929   else
1930     {
1931       rc = writen (handle->dev_fd, msg, msglen);
1932       if (!rc)
1933         return 0;
1934       DEBUGOUT_2 ("writen to %d failed: %s\n",
1935                   handle->dev_fd, strerror (errno));
1936
1937     }
1938   return CCID_DRIVER_ERR_CARD_IO_ERROR;
1939 }
1940
1941
1942 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
1943    BUFFER and return the actual read number if bytes in NREAD. SEQNO
1944    is the sequence number used to send the request and EXPECTED_TYPE
1945    the type of message we expect. Does checks on the ccid
1946    header. TIMEOUT is the timeout value in ms. NO_DEBUG may be set to
1947    avoid debug messages in case of no error; this can be overriden
1948    with a glibal debug level of at least 3. Returns 0 on success. */
1949 static int
1950 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
1951          size_t *nread, int expected_type, int seqno, int timeout,
1952          int no_debug)
1953 {
1954   int rc;
1955   size_t msglen;
1956   int eagain_retries = 0;
1957
1958   /* Fixme: The next line for the current Valgrind without support
1959      for USB IOCTLs. */
1960   memset (buffer, 0, length);
1961  retry:
1962   if (handle->idev)
1963     {
1964       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
1965                                  (char*)buffer, length, &msglen, timeout);
1966       if (rc < 0)
1967         {
1968           DEBUGOUT_1 ("usb_bulk_read error: %s\n", libusb_error_name (rc));
1969           if (rc == EAGAIN && eagain_retries++ < 3)
1970             {
1971               my_sleep (1);
1972               goto retry;
1973             }
1974           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1975         }
1976       *nread = msglen;
1977     }
1978   else
1979     {
1980       rc = read (handle->dev_fd, buffer, length);
1981       if (rc < 0)
1982         {
1983           rc = errno;
1984           DEBUGOUT_2 ("read from %d failed: %s\n",
1985                       handle->dev_fd, strerror (rc));
1986           if (rc == EAGAIN && eagain_retries++ < 5)
1987             {
1988               my_sleep (1);
1989               goto retry;
1990             }
1991           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1992         }
1993       *nread = msglen = rc;
1994     }
1995   eagain_retries = 0;
1996
1997   if (msglen < 10)
1998     {
1999       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
2000       abort_cmd (handle, seqno);
2001       return CCID_DRIVER_ERR_INV_VALUE;
2002     }
2003   if (buffer[5] != 0)
2004     {
2005       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
2006       return CCID_DRIVER_ERR_INV_VALUE;
2007     }
2008   if (buffer[6] != seqno)
2009     {
2010       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
2011                   seqno, buffer[6]);
2012       /* Retry until we are synced again.  */
2013       goto retry;
2014     }
2015
2016   /* We need to handle the time extension request before we check that
2017      we got the expected message type.  This is in particular required
2018      for the Cherry keyboard which sends a time extension request for
2019      each key hit.  */
2020   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
2021     {
2022       /* Card present and active, time extension requested. */
2023       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
2024                   buffer[7], buffer[8]);
2025       goto retry;
2026     }
2027
2028   if (buffer[0] != expected_type)
2029     {
2030       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
2031       abort_cmd (handle, seqno);
2032       return CCID_DRIVER_ERR_INV_VALUE;
2033     }
2034
2035   if (debug_level && (!no_debug || debug_level >= 3))
2036     {
2037       switch (buffer[0])
2038         {
2039         case RDR_to_PC_DataBlock:
2040           print_r2p_datablock (buffer, msglen);
2041           break;
2042         case RDR_to_PC_SlotStatus:
2043           print_r2p_slotstatus (buffer, msglen);
2044           break;
2045         case RDR_to_PC_Parameters:
2046           print_r2p_parameters (buffer, msglen);
2047           break;
2048         case RDR_to_PC_Escape:
2049           print_r2p_escape (buffer, msglen);
2050           break;
2051         case RDR_to_PC_DataRate:
2052           print_r2p_datarate (buffer, msglen);
2053           break;
2054         default:
2055           print_r2p_unknown (buffer, msglen);
2056           break;
2057         }
2058     }
2059   if (CCID_COMMAND_FAILED (buffer))
2060     print_command_failed (buffer);
2061
2062   /* Check whether a card is at all available.  Note: If you add new
2063      error codes here, check whether they need to be ignored in
2064      send_escape_cmd. */
2065   switch ((buffer[7] & 0x03))
2066     {
2067     case 0: /* no error */ break;
2068     case 1: return CCID_DRIVER_ERR_CARD_INACTIVE;
2069     case 2: return CCID_DRIVER_ERR_NO_CARD;
2070     case 3: /* RFU */ break;
2071     }
2072   return 0;
2073 }
2074
2075
2076
2077 /* Send an abort sequence and wait until everything settled.  */
2078 static int
2079 abort_cmd (ccid_driver_t handle, int seqno)
2080 {
2081   int rc;
2082   char dummybuf[8];
2083   unsigned char msg[100];
2084   size_t msglen;
2085
2086   if (!handle->idev)
2087     {
2088       /* I don't know how to send an abort to non-USB devices.  */
2089       rc = CCID_DRIVER_ERR_NOT_SUPPORTED;
2090     }
2091
2092   seqno &= 0xff;
2093   DEBUGOUT_1 ("sending abort sequence for seqno %d\n", seqno);
2094   /* Send the abort command to the control pipe.  Note that we don't
2095      need to keep track of sent abort commands because there should
2096      never be another thread using the same slot concurrently.  */
2097   rc = libusb_control_transfer (handle->idev,
2098                                 0x21,/* bmRequestType: host-to-device,
2099                                         class specific, to interface.  */
2100                                 1,   /* ABORT */
2101                                 (seqno << 8 | 0 /* slot */),
2102                                 handle->ifc_no,
2103                                 dummybuf, 0,
2104                                 1000 /* ms timeout */);
2105   if (rc < 0)
2106     {
2107       DEBUGOUT_1 ("usb_control_msg error: %s\n", libusb_error_name (rc));
2108       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2109     }
2110
2111   /* Now send the abort command to the bulk out pipe using the same
2112      SEQNO and SLOT.  Do this in a loop to so that all seqno are
2113      tried.  */
2114   seqno--;  /* Adjust for next increment.  */
2115   do
2116     {
2117       int transferred;
2118
2119       seqno++;
2120       msg[0] = PC_to_RDR_Abort;
2121       msg[5] = 0; /* slot */
2122       msg[6] = seqno;
2123       msg[7] = 0; /* RFU */
2124       msg[8] = 0; /* RFU */
2125       msg[9] = 0; /* RFU */
2126       msglen = 10;
2127       set_msg_len (msg, 0);
2128
2129       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
2130                                  (char*)msg, msglen, &transferred,
2131                                  5000 /* ms timeout */);
2132       if (rc == 0 && transferred == msglen)
2133         rc = 0;
2134       else if (rc < 0)
2135         DEBUGOUT_1 ("usb_bulk_write error in abort_cmd: %s\n",
2136                     libusb_error_name (rc));
2137
2138       if (rc)
2139         return rc;
2140
2141       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
2142                                  (char*)msg, sizeof msg, &msglen,
2143                                  5000 /*ms timeout*/);
2144       if (rc < 0)
2145         {
2146           DEBUGOUT_1 ("usb_bulk_read error in abort_cmd: %s\n",
2147                       libusb_error_name (rc));
2148           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2149         }
2150
2151       if (msglen < 10)
2152         {
2153           DEBUGOUT_1 ("bulk-in msg in abort_cmd too short (%u)\n",
2154                       (unsigned int)msglen);
2155           return CCID_DRIVER_ERR_INV_VALUE;
2156         }
2157       if (msg[5] != 0)
2158         {
2159           DEBUGOUT_1 ("unexpected bulk-in slot (%d) in abort_cmd\n", msg[5]);
2160           return CCID_DRIVER_ERR_INV_VALUE;
2161         }
2162
2163       DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n",
2164                   msg[7], msg[8], msg[9]);
2165       if (CCID_COMMAND_FAILED (msg))
2166         print_command_failed (msg);
2167     }
2168   while (msg[0] != RDR_to_PC_SlotStatus && msg[5] != 0 && msg[6] != seqno);
2169
2170   handle->seqno = ((seqno + 1) & 0xff);
2171   DEBUGOUT ("sending abort sequence succeeded\n");
2172
2173   return 0;
2174 }
2175
2176
2177 /* Note that this function won't return the error codes NO_CARD or
2178    CARD_INACTIVE.  IF RESULT is not NULL, the result from the
2179    operation will get returned in RESULT and its length in RESULTLEN.
2180    If the response is larger than RESULTMAX, an error is returned and
2181    the required buffer length returned in RESULTLEN.  */
2182 static int
2183 send_escape_cmd (ccid_driver_t handle,
2184                  const unsigned char *data, size_t datalen,
2185                  unsigned char *result, size_t resultmax, size_t *resultlen)
2186 {
2187   int rc;
2188   unsigned char msg[100];
2189   size_t msglen;
2190   unsigned char seqno;
2191
2192   if (resultlen)
2193     *resultlen = 0;
2194
2195   if (datalen > sizeof msg - 10)
2196     return CCID_DRIVER_ERR_INV_VALUE; /* Escape data too large.  */
2197
2198   msg[0] = PC_to_RDR_Escape;
2199   msg[5] = 0; /* slot */
2200   msg[6] = seqno = handle->seqno++;
2201   msg[7] = 0; /* RFU */
2202   msg[8] = 0; /* RFU */
2203   msg[9] = 0; /* RFU */
2204   memcpy (msg+10, data, datalen);
2205   msglen = 10 + datalen;
2206   set_msg_len (msg, datalen);
2207
2208   rc = bulk_out (handle, msg, msglen, 0);
2209   if (rc)
2210     return rc;
2211   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Escape,
2212                 seqno, 5000, 0);
2213   if (result)
2214     switch (rc)
2215       {
2216         /* We need to ignore certain errorcode here. */
2217       case 0:
2218       case CCID_DRIVER_ERR_CARD_INACTIVE:
2219       case CCID_DRIVER_ERR_NO_CARD:
2220         {
2221           if (msglen > resultmax)
2222             rc = CCID_DRIVER_ERR_INV_VALUE; /* Response too large. */
2223           else
2224             {
2225               memcpy (result, msg, msglen);
2226               *resultlen = msglen;
2227               rc = 0;
2228             }
2229         }
2230         break;
2231       default:
2232         break;
2233       }
2234
2235   return rc;
2236 }
2237
2238
2239 int
2240 ccid_transceive_escape (ccid_driver_t handle,
2241                         const unsigned char *data, size_t datalen,
2242                         unsigned char *resp, size_t maxresplen, size_t *nresp)
2243 {
2244   return send_escape_cmd (handle, data, datalen, resp, maxresplen, nresp);
2245 }
2246
2247
2248
2249 /* experimental */
2250 int
2251 ccid_poll (ccid_driver_t handle)
2252 {
2253   int rc;
2254   unsigned char msg[10];
2255   size_t msglen;
2256   int i, j;
2257
2258   if (handle->idev)
2259     {
2260       rc = libusb_bulk_transfer (handle->idev, handle->ep_intr,
2261                                  (char*)msg, sizeof msg, &msglen,
2262                                  0 /* ms timeout */ );
2263       if (rc == LIBUSB_ERROR_TIMEOUT)
2264         return 0;
2265     }
2266   else
2267     return 0;
2268
2269   if (rc < 0)
2270     {
2271       DEBUGOUT_1 ("usb_intr_read error: %s\n", libusb_error_name (rc));
2272       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2273     }
2274
2275   if (msglen < 1)
2276     {
2277       DEBUGOUT ("intr-in msg too short\n");
2278       return CCID_DRIVER_ERR_INV_VALUE;
2279     }
2280
2281   if (msg[0] == RDR_to_PC_NotifySlotChange)
2282     {
2283       DEBUGOUT ("notify slot change:");
2284       for (i=1; i < msglen; i++)
2285         for (j=0; j < 4; j++)
2286           DEBUGOUT_CONT_3 (" %d:%c%c",
2287                            (i-1)*4+j,
2288                            (msg[i] & (1<<(j*2)))? 'p':'-',
2289                            (msg[i] & (2<<(j*2)))? '*':' ');
2290       DEBUGOUT_LF ();
2291     }
2292   else if (msg[0] == RDR_to_PC_HardwareError)
2293     {
2294       DEBUGOUT ("hardware error occurred\n");
2295     }
2296   else
2297     {
2298       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
2299     }
2300
2301   return 0;
2302 }
2303
2304
2305 /* Note that this function won't return the error codes NO_CARD or
2306    CARD_INACTIVE */
2307 int
2308 ccid_slot_status (ccid_driver_t handle, int *statusbits)
2309 {
2310   int rc;
2311   unsigned char msg[100];
2312   size_t msglen;
2313   unsigned char seqno;
2314   int retries = 0;
2315
2316  retry:
2317   msg[0] = PC_to_RDR_GetSlotStatus;
2318   msg[5] = 0; /* slot */
2319   msg[6] = seqno = handle->seqno++;
2320   msg[7] = 0; /* RFU */
2321   msg[8] = 0; /* RFU */
2322   msg[9] = 0; /* RFU */
2323   set_msg_len (msg, 0);
2324
2325   rc = bulk_out (handle, msg, 10, 1);
2326   if (rc)
2327     return rc;
2328   /* Note that we set the NO_DEBUG flag here, so that the logs won't
2329      get cluttered up by a ticker function checking for the slot
2330      status and debugging enabled. */
2331   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
2332                 seqno, retries? 1000 : 200, 1);
2333   if (rc == CCID_DRIVER_ERR_CARD_IO_ERROR && retries < 3)
2334     {
2335       if (!retries)
2336         {
2337           DEBUGOUT ("USB: CALLING USB_CLEAR_HALT\n");
2338           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
2339           libusb_clear_halt (handle->idev, handle->ep_bulk_out);
2340         }
2341       else
2342           DEBUGOUT ("USB: RETRYING bulk_in AGAIN\n");
2343       retries++;
2344       goto retry;
2345     }
2346   if (rc && rc != CCID_DRIVER_ERR_NO_CARD
2347       && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
2348     return rc;
2349   *statusbits = (msg[7] & 3);
2350
2351   return 0;
2352 }
2353
2354
2355 /* Parse ATR string (of ATRLEN) and update parameters at PARAM.
2356    Calling this routine, it should prepare default values at PARAM
2357    beforehand.  This routine assumes that card is accessed by T=1
2358    protocol.  It doesn't analyze historical bytes at all.
2359
2360    Returns < 0 value on error:
2361      -1 for parse error or integrity check error
2362      -2 for card doesn't support T=1 protocol
2363      -3 for parameters are nod explicitly defined by ATR
2364      -4 for this driver doesn't support CRC
2365
2366    Returns >= 0 on success:
2367       0 for card is negotiable mode
2368       1 for card is specific mode (and not negotiable)
2369  */
2370 static int
2371 update_param_by_atr (unsigned char *param, unsigned char *atr, size_t atrlen)
2372 {
2373   int i = -1;
2374   int t, y, chk;
2375   int historical_bytes_num, negotiable = 1;
2376
2377 #define NEXTBYTE() do { i++; if (atrlen <= i) return -1; } while (0)
2378
2379   NEXTBYTE ();
2380
2381   if (atr[i] == 0x3F)
2382     param[1] |= 0x02;           /* Convention is inverse.  */
2383   NEXTBYTE ();
2384
2385   y = (atr[i] >> 4);
2386   historical_bytes_num = atr[i] & 0x0f;
2387   NEXTBYTE ();
2388
2389   if ((y & 1))
2390     {
2391       param[0] = atr[i];        /* TA1 - Fi & Di */
2392       NEXTBYTE ();
2393     }
2394
2395   if ((y & 2))
2396     NEXTBYTE ();                /* TB1 - ignore */
2397
2398   if ((y & 4))
2399     {
2400       param[2] = atr[i];        /* TC1 - Guard Time */
2401       NEXTBYTE ();
2402     }
2403
2404   if ((y & 8))
2405     {
2406       y = (atr[i] >> 4);        /* TD1 */
2407       t = atr[i] & 0x0f;
2408       NEXTBYTE ();
2409
2410       if ((y & 1))
2411         {                       /* TA2 - PPS mode */
2412           if ((atr[i] & 0x0f) != 1)
2413             return -2;          /* Wrong card protocol (!= 1).  */
2414
2415           if ((atr[i] & 0x10) != 0x10)
2416             return -3; /* Transmission parameters are implicitly defined. */
2417
2418           negotiable = 0;       /* TA2 means specific mode.  */
2419           NEXTBYTE ();
2420         }
2421
2422       if ((y & 2))
2423         NEXTBYTE ();            /* TB2 - ignore */
2424
2425       if ((y & 4))
2426         NEXTBYTE ();            /* TC2 - ignore */
2427
2428       if ((y & 8))
2429         {
2430           y = (atr[i] >> 4);    /* TD2 */
2431           t = atr[i] & 0x0f;
2432           NEXTBYTE ();
2433         }
2434       else
2435         y = 0;
2436
2437       while (y)
2438         {
2439           if ((y & 1))
2440             {                   /* TAx */
2441               if (t == 1)
2442                 param[5] = atr[i]; /* IFSC */
2443               else if (t == 15)
2444                 /* XXX: check voltage? */
2445                 param[4] = (atr[i] >> 6); /* ClockStop */
2446
2447               NEXTBYTE ();
2448             }
2449
2450           if ((y & 2))
2451             {
2452               if (t == 1)
2453                 param[3] = atr[i]; /* TBx - BWI & CWI */
2454               NEXTBYTE ();
2455             }
2456
2457           if ((y & 4))
2458             {
2459               if (t == 1)
2460                 param[1] |= (atr[i] & 0x01); /* TCx - LRC/CRC */
2461               NEXTBYTE ();
2462
2463               if (param[1] & 0x01)
2464                 return -4;      /* CRC not supported yet.  */
2465             }
2466
2467           if ((y & 8))
2468             {
2469               y = (atr[i] >> 4); /* TDx */
2470               t = atr[i] & 0x0f;
2471               NEXTBYTE ();
2472             }
2473           else
2474             y = 0;
2475         }
2476     }
2477
2478   i += historical_bytes_num - 1;
2479   NEXTBYTE ();
2480   if (atrlen != i+1)
2481     return -1;
2482
2483 #undef NEXTBYTE
2484
2485   chk = 0;
2486   do
2487     {
2488       chk ^= atr[i];
2489       i--;
2490     }
2491   while (i > 0);
2492
2493   if (chk != 0)
2494     return -1;
2495
2496   return negotiable;
2497 }
2498
2499
2500 /* Return the ATR of the card.  This is not a cached value and thus an
2501    actual reset is done.  */
2502 int
2503 ccid_get_atr (ccid_driver_t handle,
2504               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
2505 {
2506   int rc;
2507   int statusbits;
2508   unsigned char msg[100];
2509   unsigned char *tpdu;
2510   size_t msglen, tpdulen;
2511   unsigned char seqno;
2512   int use_crc = 0;
2513   unsigned int edc;
2514   int tried_iso = 0;
2515   int got_param;
2516   unsigned char param[7] = { /* For Protocol T=1 */
2517     0x11, /* bmFindexDindex */
2518     0x10, /* bmTCCKST1 */
2519     0x00, /* bGuardTimeT1 */
2520     0x4d, /* bmWaitingIntegersT1 */
2521     0x00, /* bClockStop */
2522     0x20, /* bIFSC */
2523     0x00  /* bNadValue */
2524   };
2525
2526   /* First check whether a card is available.  */
2527   rc = ccid_slot_status (handle, &statusbits);
2528   if (rc)
2529     return rc;
2530   if (statusbits == 2)
2531     return CCID_DRIVER_ERR_NO_CARD;
2532
2533   /* For an inactive and also for an active card, issue the PowerOn
2534      command to get the ATR.  */
2535  again:
2536   msg[0] = PC_to_RDR_IccPowerOn;
2537   msg[5] = 0; /* slot */
2538   msg[6] = seqno = handle->seqno++;
2539   /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
2540   msg[7] = handle->auto_voltage ? 0 : 1;
2541   msg[8] = 0; /* RFU */
2542   msg[9] = 0; /* RFU */
2543   set_msg_len (msg, 0);
2544   msglen = 10;
2545
2546   rc = bulk_out (handle, msg, msglen, 0);
2547   if (rc)
2548     return rc;
2549   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2550                 seqno, 5000, 0);
2551   if (rc)
2552     return rc;
2553   if (!tried_iso && CCID_COMMAND_FAILED (msg) && CCID_ERROR_CODE (msg) == 0xbb
2554       && ((handle->id_vendor == VENDOR_CHERRY
2555            && handle->id_product == 0x0005)
2556           || (handle->id_vendor == VENDOR_GEMPC
2557               && handle->id_product == 0x4433)
2558           ))
2559     {
2560       tried_iso = 1;
2561       /* Try switching to ISO mode. */
2562       if (!send_escape_cmd (handle, (const unsigned char*)"\xF1\x01", 2,
2563                             NULL, 0, NULL))
2564         goto again;
2565     }
2566   else if (CCID_COMMAND_FAILED (msg))
2567     return CCID_DRIVER_ERR_CARD_IO_ERROR;
2568
2569
2570   handle->powered_off = 0;
2571
2572   if (atr)
2573     {
2574       size_t n = msglen - 10;
2575
2576       if (n > maxatrlen)
2577         n = maxatrlen;
2578       memcpy (atr, msg+10, n);
2579       *atrlen = n;
2580     }
2581
2582   param[6] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2583   rc = update_param_by_atr (param, msg+10, msglen - 10);
2584   if (rc < 0)
2585     {
2586       DEBUGOUT_1 ("update_param_by_atr failed: %d\n", rc);
2587       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2588     }
2589
2590   got_param = 0;
2591
2592   if (handle->auto_param)
2593     {
2594       msg[0] = PC_to_RDR_GetParameters;
2595       msg[5] = 0; /* slot */
2596       msg[6] = seqno = handle->seqno++;
2597       msg[7] = 0; /* RFU */
2598       msg[8] = 0; /* RFU */
2599       msg[9] = 0; /* RFU */
2600       set_msg_len (msg, 0);
2601       msglen = 10;
2602       rc = bulk_out (handle, msg, msglen, 0);
2603       if (!rc)
2604         rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2605                       seqno, 2000, 0);
2606       if (rc)
2607         DEBUGOUT ("GetParameters failed\n");
2608       else if (msglen == 17 && msg[9] == 1)
2609         got_param = 1;
2610     }
2611   else if (handle->auto_pps)
2612     ;
2613   else if (rc == 1)             /* It's negotiable, send PPS.  */
2614     {
2615       msg[0] = PC_to_RDR_XfrBlock;
2616       msg[5] = 0; /* slot */
2617       msg[6] = seqno = handle->seqno++;
2618       msg[7] = 0;
2619       msg[8] = 0;
2620       msg[9] = 0;
2621       msg[10] = 0xff;           /* PPSS */
2622       msg[11] = 0x11;           /* PPS0: PPS1, Protocol T=1 */
2623       msg[12] = param[0];       /* PPS1: Fi / Di */
2624       msg[13] = 0xff ^ 0x11 ^ param[0]; /* PCK */
2625       set_msg_len (msg, 4);
2626       msglen = 10 + 4;
2627
2628       rc = bulk_out (handle, msg, msglen, 0);
2629       if (rc)
2630         return rc;
2631
2632       rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2633                     seqno, 5000, 0);
2634       if (rc)
2635         return rc;
2636
2637       if (msglen != 10 + 4)
2638         {
2639           DEBUGOUT_1 ("Setting PPS failed: %zu\n", msglen);
2640           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2641         }
2642
2643       if (msg[10] != 0xff || msg[11] != 0x11 || msg[12] != param[0])
2644         {
2645           DEBUGOUT_1 ("Setting PPS failed: 0x%02x\n", param[0]);
2646           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2647         }
2648     }
2649
2650   /* Setup parameters to select T=1. */
2651   msg[0] = PC_to_RDR_SetParameters;
2652   msg[5] = 0; /* slot */
2653   msg[6] = seqno = handle->seqno++;
2654   msg[7] = 1; /* Select T=1. */
2655   msg[8] = 0; /* RFU */
2656   msg[9] = 0; /* RFU */
2657
2658   if (!got_param)
2659     memcpy (&msg[10], param, 7);
2660   set_msg_len (msg, 7);
2661   msglen = 10 + 7;
2662
2663   rc = bulk_out (handle, msg, msglen, 0);
2664   if (rc)
2665     return rc;
2666   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2667                 seqno, 5000, 0);
2668   if (rc)
2669     DEBUGOUT ("SetParameters failed (ignored)\n");
2670
2671   if (!rc && msglen > 15 && msg[15] >= 16 && msg[15] <= 254 )
2672     handle->ifsc = msg[15];
2673   else
2674     handle->ifsc = 128; /* Something went wrong, assume 128 bytes.  */
2675
2676   if (handle->nonnull_nad && msglen > 16 && msg[16] == 0)
2677     {
2678       DEBUGOUT ("Use Null-NAD, clearing handle->nonnull_nad.\n");
2679       handle->nonnull_nad = 0;
2680     }
2681
2682   handle->t1_ns = 0;
2683   handle->t1_nr = 0;
2684
2685   /* Send an S-Block with our maximum IFSD to the CCID.  */
2686   if (!handle->apdu_level && !handle->auto_ifsd)
2687     {
2688       tpdu = msg+10;
2689       /* NAD: DAD=1, SAD=0 */
2690       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2691       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
2692       tpdu[2] = 1;
2693       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32;
2694       tpdulen = 4;
2695       edc = compute_edc (tpdu, tpdulen, use_crc);
2696       if (use_crc)
2697         tpdu[tpdulen++] = (edc >> 8);
2698       tpdu[tpdulen++] = edc;
2699
2700       msg[0] = PC_to_RDR_XfrBlock;
2701       msg[5] = 0; /* slot */
2702       msg[6] = seqno = handle->seqno++;
2703       msg[7] = 0;
2704       msg[8] = 0; /* RFU */
2705       msg[9] = 0; /* RFU */
2706       set_msg_len (msg, tpdulen);
2707       msglen = 10 + tpdulen;
2708
2709       if (debug_level > 1)
2710         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
2711                       ((msg[11] & 0xc0) == 0x80)? 'R' :
2712                                 (msg[11] & 0x80)? 'S' : 'I',
2713                       ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2714                                        : !!(msg[11] & 0x40)),
2715                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2716
2717       rc = bulk_out (handle, msg, msglen, 0);
2718       if (rc)
2719         return rc;
2720
2721
2722       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2723                     RDR_to_PC_DataBlock, seqno, 5000, 0);
2724       if (rc)
2725         return rc;
2726
2727       tpdu = msg + 10;
2728       tpdulen = msglen - 10;
2729
2730       if (tpdulen < 4)
2731         return CCID_DRIVER_ERR_ABORTED;
2732
2733       if (debug_level > 1)
2734         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
2735                     ((msg[11] & 0xc0) == 0x80)? 'R' :
2736                               (msg[11] & 0x80)? 'S' : 'I',
2737                     ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2738                                      : !!(msg[11] & 0x40)),
2739                     ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
2740                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2741
2742       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
2743         {
2744           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
2745           return -1;
2746         }
2747       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
2748     }
2749
2750   return 0;
2751 }
2752
2753
2754 \f
2755
2756 static unsigned int
2757 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
2758 {
2759   if (use_crc)
2760     {
2761       return 0x42; /* Not yet implemented. */
2762     }
2763   else
2764     {
2765       unsigned char crc = 0;
2766
2767       for (; datalen; datalen--)
2768         crc ^= *data++;
2769       return crc;
2770     }
2771 }
2772
2773
2774 /* Return true if APDU is an extended length one.  */
2775 static int
2776 is_exlen_apdu (const unsigned char *apdu, size_t apdulen)
2777 {
2778   if (apdulen < 7 || apdu[4])
2779     return 0;  /* Too short or no Z byte.  */
2780   return 1;
2781 }
2782
2783
2784 /* Helper for ccid_transceive used for APDU level exchanges.  */
2785 static int
2786 ccid_transceive_apdu_level (ccid_driver_t handle,
2787                             const unsigned char *apdu_buf, size_t apdu_len,
2788                             unsigned char *resp, size_t maxresplen,
2789                             size_t *nresp)
2790 {
2791   int rc;
2792   unsigned char msg[CCID_MAX_BUF];
2793   const unsigned char *apdu_p;
2794   size_t apdu_part_len;
2795   size_t msglen;
2796   unsigned char seqno;
2797   int bwi = 4;
2798   unsigned char chain = 0;
2799
2800   if (apdu_len == 0 || apdu_len > sizeof (msg) - 10)
2801     return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
2802
2803   apdu_p = apdu_buf;
2804   while (1)
2805     {
2806       apdu_part_len = apdu_len;
2807       if (apdu_part_len > handle->max_ccid_msglen - 10)
2808         {
2809           apdu_part_len = handle->max_ccid_msglen - 10;
2810           chain |= 0x01;
2811         }
2812
2813       msg[0] = PC_to_RDR_XfrBlock;
2814       msg[5] = 0; /* slot */
2815       msg[6] = seqno = handle->seqno++;
2816       msg[7] = bwi;
2817       msg[8] = chain;
2818       msg[9] = 0;
2819       memcpy (msg+10, apdu_p, apdu_part_len);
2820       set_msg_len (msg, apdu_part_len);
2821       msglen = 10 + apdu_part_len;
2822
2823       rc = bulk_out (handle, msg, msglen, 0);
2824       if (rc)
2825         return rc;
2826
2827       apdu_p += apdu_part_len;
2828       apdu_len -= apdu_part_len;
2829
2830       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2831                     RDR_to_PC_DataBlock, seqno, CCID_CMD_TIMEOUT, 0);
2832       if (rc)
2833         return rc;
2834
2835       if (!(chain & 0x01))
2836         break;
2837
2838       chain = 0x02;
2839     }
2840
2841   apdu_len = 0;
2842   while (1)
2843     {
2844       apdu_part_len = msglen - 10;
2845       if (resp && apdu_len + apdu_part_len <= maxresplen)
2846         memcpy (resp + apdu_len, msg+10, apdu_part_len);
2847       apdu_len += apdu_part_len;
2848
2849       if (!(msg[9] & 0x01))
2850         break;
2851
2852       msg[0] = PC_to_RDR_XfrBlock;
2853       msg[5] = 0; /* slot */
2854       msg[6] = seqno = handle->seqno++;
2855       msg[7] = bwi;
2856       msg[8] = 0x10;                /* Request next data block */
2857       msg[9] = 0;
2858       set_msg_len (msg, 0);
2859       msglen = 10;
2860
2861       rc = bulk_out (handle, msg, msglen, 0);
2862       if (rc)
2863         return rc;
2864
2865       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2866                     RDR_to_PC_DataBlock, seqno, CCID_CMD_TIMEOUT, 0);
2867       if (rc)
2868         return rc;
2869     }
2870
2871   if (resp)
2872     {
2873       if (apdu_len > maxresplen)
2874         {
2875           DEBUGOUT_2 ("provided buffer too short for received data "
2876                       "(%u/%u)\n",
2877                       (unsigned int)apdu_len, (unsigned int)maxresplen);
2878           return CCID_DRIVER_ERR_INV_VALUE;
2879         }
2880
2881       *nresp = apdu_len;
2882     }
2883
2884   return 0;
2885 }
2886
2887
2888
2889 /*
2890   Protocol T=1 overview
2891
2892   Block Structure:
2893            Prologue Field:
2894    1 byte     Node Address (NAD)
2895    1 byte     Protocol Control Byte (PCB)
2896    1 byte     Length (LEN)
2897            Information Field:
2898    0-254 byte APDU or Control Information (INF)
2899            Epilogue Field:
2900    1 byte     Error Detection Code (EDC)
2901
2902   NAD:
2903    bit 7     unused
2904    bit 4..6  Destination Node Address (DAD)
2905    bit 3     unused
2906    bit 2..0  Source Node Address (SAD)
2907
2908    If node adresses are not used, SAD and DAD should be set to 0 on
2909    the first block sent to the card.  If they are used they should
2910    have different values (0 for one is okay); that first block sets up
2911    the addresses of the nodes.
2912
2913   PCB:
2914    Information Block (I-Block):
2915       bit 7    0
2916       bit 6    Sequence number (yep, that is modulo 2)
2917       bit 5    Chaining flag
2918       bit 4..0 reserved
2919    Received-Ready Block (R-Block):
2920       bit 7    1
2921       bit 6    0
2922       bit 5    0
2923       bit 4    Sequence number
2924       bit 3..0  0 = no error
2925                 1 = EDC or parity error
2926                 2 = other error
2927                 other values are reserved
2928    Supervisory Block (S-Block):
2929       bit 7    1
2930       bit 6    1
2931       bit 5    clear=request,set=response
2932       bit 4..0  0 = resyncronisation request
2933                 1 = information field size request
2934                 2 = abort request
2935                 3 = extension of BWT request
2936                 4 = VPP error
2937                 other values are reserved
2938
2939 */
2940
2941 int
2942 ccid_transceive (ccid_driver_t handle,
2943                  const unsigned char *apdu_buf, size_t apdu_buflen,
2944                  unsigned char *resp, size_t maxresplen, size_t *nresp)
2945 {
2946   int rc;
2947   /* The size of the buffer used to be 10+259.  For the via_escape
2948      hack we need one extra byte, thus 11+259.  */
2949   unsigned char send_buffer[11+259], recv_buffer[11+259];
2950   const unsigned char *apdu;
2951   size_t apdulen;
2952   unsigned char *msg, *tpdu, *p;
2953   size_t msglen, tpdulen, last_tpdulen, n;
2954   unsigned char seqno;
2955   unsigned int edc;
2956   int use_crc = 0;
2957   int hdrlen, pcboff;
2958   size_t dummy_nresp;
2959   int via_escape = 0;
2960   int next_chunk = 1;
2961   int sending = 1;
2962   int retries = 0;
2963   int resyncing = 0;
2964   int nad_byte;
2965
2966   if (!nresp)
2967     nresp = &dummy_nresp;
2968   *nresp = 0;
2969
2970   /* Smarter readers allow to send APDUs directly; divert here. */
2971   if (handle->apdu_level)
2972     {
2973       /* We employ a hack for Omnikey readers which are able to send
2974          TPDUs using an escape sequence.  There is no documentation
2975          but the Windows driver does it this way.  Tested using a
2976          CM6121.  This method works also for the Cherry XX44
2977          keyboards; however there are problems with the
2978          ccid_tranceive_secure which leads to a loss of sync on the
2979          CCID level.  If Cherry wants to make their keyboard work
2980          again, they should hand over some docs. */
2981       if ((handle->id_vendor == VENDOR_OMNIKEY
2982            || (!handle->idev && handle->id_product == TRANSPORT_CM4040))
2983           && handle->apdu_level < 2
2984           && is_exlen_apdu (apdu_buf, apdu_buflen))
2985         via_escape = 1;
2986       else
2987         return ccid_transceive_apdu_level (handle, apdu_buf, apdu_buflen,
2988                                            resp, maxresplen, nresp);
2989     }
2990
2991   /* The other readers we support require sending TPDUs.  */
2992
2993   tpdulen = 0; /* Avoid compiler warning about no initialization. */
2994   msg = send_buffer;
2995   hdrlen = via_escape? 11 : 10;
2996
2997   /* NAD: DAD=1, SAD=0 */
2998   nad_byte = handle->nonnull_nad? ((1 << 4) | 0): 0;
2999   if (via_escape)
3000     nad_byte = 0;
3001
3002   last_tpdulen = 0;  /* Avoid gcc warning (controlled by RESYNCING). */
3003   for (;;)
3004     {
3005       if (next_chunk)
3006         {
3007           next_chunk = 0;
3008
3009           apdu = apdu_buf;
3010           apdulen = apdu_buflen;
3011           assert (apdulen);
3012
3013           /* Construct an I-Block. */
3014           tpdu = msg + hdrlen;
3015           tpdu[0] = nad_byte;
3016           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
3017           if (apdulen > handle->ifsc )
3018             {
3019               apdulen = handle->ifsc;
3020               apdu_buf += handle->ifsc;
3021               apdu_buflen -= handle->ifsc;
3022               tpdu[1] |= (1 << 5); /* Set more bit. */
3023             }
3024           tpdu[2] = apdulen;
3025           memcpy (tpdu+3, apdu, apdulen);
3026           tpdulen = 3 + apdulen;
3027           edc = compute_edc (tpdu, tpdulen, use_crc);
3028           if (use_crc)
3029             tpdu[tpdulen++] = (edc >> 8);
3030           tpdu[tpdulen++] = edc;
3031         }
3032
3033       if (via_escape)
3034         {
3035           msg[0] = PC_to_RDR_Escape;
3036           msg[5] = 0; /* slot */
3037           msg[6] = seqno = handle->seqno++;
3038           msg[7] = 0; /* RFU */
3039           msg[8] = 0; /* RFU */
3040           msg[9] = 0; /* RFU */
3041           msg[10] = 0x1a; /* Omnikey command to send a TPDU.  */
3042           set_msg_len (msg, 1 + tpdulen);
3043         }
3044       else
3045         {
3046           msg[0] = PC_to_RDR_XfrBlock;
3047           msg[5] = 0; /* slot */
3048           msg[6] = seqno = handle->seqno++;
3049           msg[7] = 4; /* bBWI */
3050           msg[8] = 0; /* RFU */
3051           msg[9] = 0; /* RFU */
3052           set_msg_len (msg, tpdulen);
3053         }
3054       msglen = hdrlen + tpdulen;
3055       if (!resyncing)
3056         last_tpdulen = tpdulen;
3057       pcboff = hdrlen+1;
3058
3059       if (debug_level > 1)
3060         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
3061                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3062                     (msg[pcboff] & 0x80)? 'S' : 'I',
3063                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3064                      : !!(msg[pcboff] & 0x40)),
3065                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3066                      " [more]":""));
3067
3068       rc = bulk_out (handle, msg, msglen, 0);
3069       if (rc)
3070         return rc;
3071
3072       msg = recv_buffer;
3073       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3074                     via_escape? RDR_to_PC_Escape : RDR_to_PC_DataBlock,
3075                     seqno, CCID_CMD_TIMEOUT, 0);
3076       if (rc)
3077         return rc;
3078
3079       tpdu = msg + hdrlen;
3080       tpdulen = msglen - hdrlen;
3081       resyncing = 0;
3082
3083       if (tpdulen < 4)
3084         {
3085           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
3086           return CCID_DRIVER_ERR_ABORTED;
3087         }
3088
3089       if (debug_level > 1)
3090         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3091                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3092                               (msg[pcboff] & 0x80)? 'S' : 'I',
3093                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3094                      : !!(msg[pcboff] & 0x40)),
3095                     ((msg[pcboff] & 0xc0) == 0x80)? (msg[pcboff] & 0x0f) : 0,
3096                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3097                      " [more]":""));
3098
3099       if (!(tpdu[1] & 0x80))
3100         { /* This is an I-block. */
3101           retries = 0;
3102           if (sending)
3103             { /* last block sent was successful. */
3104               handle->t1_ns ^= 1;
3105               sending = 0;
3106             }
3107
3108           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3109             { /* Response does not match our sequence number. */
3110               msg = send_buffer;
3111               tpdu = msg + hdrlen;
3112               tpdu[0] = nad_byte;
3113               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
3114               tpdu[2] = 0;
3115               tpdulen = 3;
3116               edc = compute_edc (tpdu, tpdulen, use_crc);
3117               if (use_crc)
3118                 tpdu[tpdulen++] = (edc >> 8);
3119               tpdu[tpdulen++] = edc;
3120
3121               continue;
3122             }
3123
3124           handle->t1_nr ^= 1;
3125
3126           p = tpdu + 3; /* Skip the prologue field. */
3127           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3128           /* fixme: verify the checksum. */
3129           if (resp)
3130             {
3131               if (n > maxresplen)
3132                 {
3133                   DEBUGOUT_2 ("provided buffer too short for received data "
3134                               "(%u/%u)\n",
3135                               (unsigned int)n, (unsigned int)maxresplen);
3136                   return CCID_DRIVER_ERR_INV_VALUE;
3137                 }
3138
3139               memcpy (resp, p, n);
3140               resp += n;
3141               *nresp += n;
3142               maxresplen -= n;
3143             }
3144
3145           if (!(tpdu[1] & 0x20))
3146             return 0; /* No chaining requested - ready. */
3147
3148           msg = send_buffer;
3149           tpdu = msg + hdrlen;
3150           tpdu[0] = nad_byte;
3151           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
3152           tpdu[2] = 0;
3153           tpdulen = 3;
3154           edc = compute_edc (tpdu, tpdulen, use_crc);
3155           if (use_crc)
3156             tpdu[tpdulen++] = (edc >> 8);
3157           tpdu[tpdulen++] = edc;
3158         }
3159       else if ((tpdu[1] & 0xc0) == 0x80)
3160         { /* This is a R-block. */
3161           if ( (tpdu[1] & 0x0f))
3162             {
3163               retries++;
3164               if (via_escape && retries == 1 && (msg[pcboff] & 0x0f))
3165                 {
3166                   /* Error probably due to switching to TPDU.  Send a
3167                      resync request.  We use the recv_buffer so that
3168                      we don't corrupt the send_buffer.  */
3169                   msg = recv_buffer;
3170                   tpdu = msg + hdrlen;
3171                   tpdu[0] = nad_byte;
3172                   tpdu[1] = 0xc0; /* S-block resync request. */
3173                   tpdu[2] = 0;
3174                   tpdulen = 3;
3175                   edc = compute_edc (tpdu, tpdulen, use_crc);
3176                   if (use_crc)
3177                     tpdu[tpdulen++] = (edc >> 8);
3178                   tpdu[tpdulen++] = edc;
3179                   resyncing = 1;
3180                   DEBUGOUT ("T=1: requesting resync\n");
3181                 }
3182               else if (retries > 3)
3183                 {
3184                   DEBUGOUT ("T=1: 3 failed retries\n");
3185                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
3186                 }
3187               else
3188                 {
3189                   /* Error: repeat last block */
3190                   msg = send_buffer;
3191                   tpdulen = last_tpdulen;
3192                 }
3193             }
3194           else if (sending && !!(tpdu[1] & 0x10) == handle->t1_ns)
3195             { /* Response does not match our sequence number. */
3196               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
3197               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3198             }
3199           else if (sending)
3200             { /* Send next chunk. */
3201               retries = 0;
3202               msg = send_buffer;
3203               next_chunk = 1;
3204               handle->t1_ns ^= 1;
3205             }
3206           else
3207             {
3208               DEBUGOUT ("unexpected ACK R-block received\n");
3209               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3210             }
3211         }
3212       else
3213         { /* This is a S-block. */
3214           retries = 0;
3215           DEBUGOUT_2 ("T=1: S-block %s received cmd=%d\n",
3216                       (tpdu[1] & 0x20)? "response": "request",
3217                       (tpdu[1] & 0x1f));
3218           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 1 && tpdu[2] == 1)
3219             {
3220               /* Information field size request.  */
3221               unsigned char ifsc = tpdu[3];
3222
3223               if (ifsc < 16 || ifsc > 254)
3224                 return CCID_DRIVER_ERR_CARD_IO_ERROR;
3225
3226               msg = send_buffer;
3227               tpdu = msg + hdrlen;
3228               tpdu[0] = nad_byte;
3229               tpdu[1] = (0xc0 | 0x20 | 1); /* S-block response */
3230               tpdu[2] = 1;
3231               tpdu[3] = ifsc;
3232               tpdulen = 4;
3233               edc = compute_edc (tpdu, tpdulen, use_crc);
3234               if (use_crc)
3235                 tpdu[tpdulen++] = (edc >> 8);
3236               tpdu[tpdulen++] = edc;
3237               DEBUGOUT_1 ("T=1: requesting an ifsc=%d\n", ifsc);
3238             }
3239           else if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
3240             {
3241               /* Wait time extension request. */
3242               unsigned char bwi = tpdu[3];
3243               msg = send_buffer;
3244               tpdu = msg + hdrlen;
3245               tpdu[0] = nad_byte;
3246               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
3247               tpdu[2] = 1;
3248               tpdu[3] = bwi;
3249               tpdulen = 4;
3250               edc = compute_edc (tpdu, tpdulen, use_crc);
3251               if (use_crc)
3252                 tpdu[tpdulen++] = (edc >> 8);
3253               tpdu[tpdulen++] = edc;
3254               DEBUGOUT_1 ("T=1: waittime extension of bwi=%d\n", bwi);
3255               print_progress (handle);
3256             }
3257           else if ( (tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 0 && !tpdu[2])
3258             {
3259               DEBUGOUT ("T=1: resync ack from reader\n");
3260               /* Repeat previous block.  */
3261               msg = send_buffer;
3262               tpdulen = last_tpdulen;
3263             }
3264           else
3265             return CCID_DRIVER_ERR_CARD_IO_ERROR;
3266         }
3267     } /* end T=1 protocol loop. */
3268
3269   return 0;
3270 }
3271
3272
3273 /* Send the CCID Secure command to the reader.  APDU_BUF should
3274    contain the APDU template.  PIN_MODE defines how the pin gets
3275    formatted:
3276
3277      1 := The PIN is ASCII encoded and of variable length.  The
3278           length of the PIN entered will be put into Lc by the reader.
3279           The APDU should me made up of 4 bytes without Lc.
3280
3281    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
3282    may be used t enable reasonable defaults.
3283
3284    When called with RESP and NRESP set to NULL, the function will
3285    merely check whether the reader supports the secure command for the
3286    given APDU and PIN_MODE. */
3287 int
3288 ccid_transceive_secure (ccid_driver_t handle,
3289                         const unsigned char *apdu_buf, size_t apdu_buflen,
3290                         pininfo_t *pininfo,
3291                         unsigned char *resp, size_t maxresplen, size_t *nresp)
3292 {
3293   int rc;
3294   unsigned char send_buffer[10+259], recv_buffer[10+259];
3295   unsigned char *msg, *tpdu, *p;
3296   size_t msglen, tpdulen, n;
3297   unsigned char seqno;
3298   size_t dummy_nresp;
3299   int testmode;
3300   int cherry_mode = 0;
3301   int add_zero = 0;
3302   int enable_varlen = 0;
3303
3304   testmode = !resp && !nresp;
3305
3306   if (!nresp)
3307     nresp = &dummy_nresp;
3308   *nresp = 0;
3309
3310   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
3311     ;
3312   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
3313     ;
3314   else
3315     return CCID_DRIVER_ERR_NO_PINPAD;
3316
3317   if (!pininfo->minlen)
3318     pininfo->minlen = 1;
3319   if (!pininfo->maxlen)
3320     pininfo->maxlen = 15;
3321
3322   /* Note that the 25 is the maximum value the SPR532 allows.  */
3323   if (pininfo->minlen < 1 || pininfo->minlen > 25
3324       || pininfo->maxlen < 1 || pininfo->maxlen > 25
3325       || pininfo->minlen > pininfo->maxlen)
3326     return CCID_DRIVER_ERR_INV_VALUE;
3327
3328   /* We have only tested a few readers so better don't risk anything
3329      and do not allow the use with other readers. */
3330   switch (handle->id_vendor)
3331     {
3332     case VENDOR_SCM:  /* Tested with SPR 532. */
3333     case VENDOR_KAAN: /* Tested with KAAN Advanced (1.02). */
3334     case VENDOR_FSIJ: /* Tested with Gnuk (0.21). */
3335       pininfo->maxlen = 25;
3336       enable_varlen = 1;
3337       break;
3338     case VENDOR_REINER:/* Tested with cyberJack go */
3339     case VENDOR_VASCO: /* Tested with DIGIPASS 920 */
3340       enable_varlen = 1;
3341       break;
3342     case VENDOR_CHERRY:
3343       pininfo->maxlen = 15;
3344       enable_varlen = 1;
3345       /* The CHERRY XX44 keyboard echos an asterisk for each entered
3346          character on the keyboard channel.  We use a special variant
3347          of PC_to_RDR_Secure which directs these characters to the
3348          smart card's bulk-in channel.  We also need to append a zero
3349          Lc byte to the APDU.  It seems that it will be replaced with
3350          the actual length instead of being appended before the APDU
3351          is send to the card. */
3352       add_zero = 1;
3353       if (handle->id_product != CHERRY_ST2000)
3354         cherry_mode = 1;
3355       break;
3356     default:
3357       if ((handle->id_vendor == VENDOR_GEMPC &&
3358            handle->id_product == GEMPC_PINPAD)
3359           || (handle->id_vendor == VENDOR_VEGA &&
3360               handle->id_product == VEGA_ALPHA))
3361         {
3362           enable_varlen = 0;
3363           pininfo->minlen = 4;
3364           pininfo->maxlen = 8;
3365           break;
3366         }
3367      return CCID_DRIVER_ERR_NOT_SUPPORTED;
3368     }
3369
3370   if (enable_varlen)
3371     pininfo->fixedlen = 0;
3372
3373   if (testmode)
3374     return 0; /* Success */
3375
3376   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
3377     return CCID_DRIVER_ERR_NOT_SUPPORTED;
3378
3379   msg = send_buffer;
3380   if (handle->id_vendor == VENDOR_SCM)
3381     {
3382       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
3383       rc = send_escape_cmd (handle, (const unsigned char*)"\x80\x02\x00", 3,
3384                             NULL, 0, NULL);
3385       if (rc)
3386         return rc;
3387     }
3388
3389   msg[0] = cherry_mode? 0x89 : PC_to_RDR_Secure;
3390   msg[5] = 0; /* slot */
3391   msg[6] = seqno = handle->seqno++;
3392   msg[7] = 0; /* bBWI */
3393   msg[8] = 0; /* RFU */
3394   msg[9] = 0; /* RFU */
3395   msg[10] = apdu_buf[1] == 0x20 ? 0 : 1;
3396                /* Perform PIN verification or PIN modification. */
3397   msg[11] = 0; /* Timeout in seconds. */
3398   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
3399   if (handle->id_vendor == VENDOR_SCM)
3400     {
3401       /* For the SPR532 the next 2 bytes need to be zero.  We do this
3402          for all SCM products.  Kudos to Martin Paljak for this
3403          hint.  */
3404       msg[13] = msg[14] = 0;
3405     }
3406   else
3407     {
3408       msg[13] = pininfo->fixedlen; /* bmPINBlockString:
3409                                       0 bits of pin length to insert.
3410                                       PIN block size by fixedlen.  */
3411       msg[14] = 0x00; /* bmPINLengthFormat:
3412                          Units are bytes, position is 0. */
3413     }
3414
3415   msglen = 15;
3416   if (apdu_buf[1] == 0x24)
3417     {
3418       msg[msglen++] = 0;    /* bInsertionOffsetOld */
3419       msg[msglen++] = pininfo->fixedlen;    /* bInsertionOffsetNew */
3420     }
3421
3422   /* The following is a little endian word. */
3423   msg[msglen++] = pininfo->maxlen;   /* wPINMaxExtraDigit-Maximum.  */
3424   msg[msglen++] = pininfo->minlen;   /* wPINMaxExtraDigit-Minimum.  */
3425
3426   if (apdu_buf[1] == 0x24)
3427     msg[msglen++] = apdu_buf[2] == 0 ? 0x03 : 0x01;
3428               /* bConfirmPIN
3429                *    0x00: new PIN once
3430                *    0x01: new PIN twice (confirmation)
3431                *    0x02: old PIN and new PIN once
3432                *    0x03: old PIN and new PIN twice (confirmation)
3433                */
3434
3435   msg[msglen] = 0x02; /* bEntryValidationCondition:
3436                          Validation key pressed */
3437   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
3438     msg[msglen] |= 0x01; /* Max size reached.  */
3439   msglen++;
3440
3441   if (apdu_buf[1] == 0x20)
3442     msg[msglen++] = 0x01; /* bNumberMessage. */
3443   else
3444     msg[msglen++] = 0x03; /* bNumberMessage. */
3445
3446   msg[msglen++] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
3447   msg[msglen++] = 0x04; /* wLangId-High. */
3448
3449   if (apdu_buf[1] == 0x20)
3450     msg[msglen++] = 0;    /* bMsgIndex. */
3451   else
3452     {
3453       msg[msglen++] = 0;    /* bMsgIndex1. */
3454       msg[msglen++] = 1;    /* bMsgIndex2. */
3455       msg[msglen++] = 2;    /* bMsgIndex3. */
3456     }
3457
3458   /* Calculate Lc.  */
3459   n = pininfo->fixedlen;
3460   if (apdu_buf[1] == 0x24)
3461     n += pininfo->fixedlen;
3462
3463   /* bTeoProlog follows: */
3464   msg[msglen++] = handle->nonnull_nad? ((1 << 4) | 0): 0;
3465   msg[msglen++] = ((handle->t1_ns & 1) << 6); /* I-block */
3466   if (n)
3467     msg[msglen++] = n + 5; /* apdulen should be filled for fixed length.  */
3468   else
3469     msg[msglen++] = 0; /* The apdulen will be filled in by the reader.  */
3470   /* APDU follows:  */
3471   msg[msglen++] = apdu_buf[0]; /* CLA */
3472   msg[msglen++] = apdu_buf[1]; /* INS */
3473   msg[msglen++] = apdu_buf[2]; /* P1 */
3474   msg[msglen++] = apdu_buf[3]; /* P2 */
3475   if (add_zero)
3476     msg[msglen++] = 0;
3477   else if (pininfo->fixedlen != 0)
3478     {
3479       msg[msglen++] = n;
3480       memset (&msg[msglen], 0xff, n);
3481       msglen += n;
3482     }
3483   /* An EDC is not required. */
3484   set_msg_len (msg, msglen - 10);
3485
3486   rc = bulk_out (handle, msg, msglen, 0);
3487   if (rc)
3488     return rc;
3489
3490   msg = recv_buffer;
3491   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3492                 RDR_to_PC_DataBlock, seqno, 30000, 0);
3493   if (rc)
3494     return rc;
3495
3496   tpdu = msg + 10;
3497   tpdulen = msglen - 10;
3498
3499   if (handle->apdu_level)
3500     {
3501       if (resp)
3502         {
3503           if (tpdulen > maxresplen)
3504             {
3505               DEBUGOUT_2 ("provided buffer too short for received data "
3506                           "(%u/%u)\n",
3507                           (unsigned int)tpdulen, (unsigned int)maxresplen);
3508               return CCID_DRIVER_ERR_INV_VALUE;
3509             }
3510
3511           memcpy (resp, tpdu, tpdulen);
3512           *nresp = tpdulen;
3513         }
3514       return 0;
3515     }
3516
3517   if (tpdulen < 4)
3518     {
3519       libusb_clear_halt (handle->idev, handle->ep_bulk_in);
3520       return CCID_DRIVER_ERR_ABORTED;
3521     }
3522   if (debug_level > 1)
3523     DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3524                 ((msg[11] & 0xc0) == 0x80)? 'R' :
3525                           (msg[11] & 0x80)? 'S' : 'I',
3526                 ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
3527                 ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
3528                 (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
3529
3530   if (!(tpdu[1] & 0x80))
3531     { /* This is an I-block. */
3532       /* Last block sent was successful. */
3533       handle->t1_ns ^= 1;
3534
3535       if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3536         { /* Response does not match our sequence number. */
3537           DEBUGOUT ("I-block with wrong seqno received\n");
3538           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3539         }
3540
3541       handle->t1_nr ^= 1;
3542
3543       p = tpdu + 3; /* Skip the prologue field. */
3544       n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3545       /* fixme: verify the checksum. */
3546       if (resp)
3547         {
3548           if (n > maxresplen)
3549             {
3550               DEBUGOUT_2 ("provided buffer too short for received data "
3551                           "(%u/%u)\n",
3552                           (unsigned int)n, (unsigned int)maxresplen);
3553               return CCID_DRIVER_ERR_INV_VALUE;
3554             }
3555
3556           memcpy (resp, p, n);
3557           resp += n;
3558           *nresp += n;
3559           maxresplen -= n;
3560         }
3561
3562       if (!(tpdu[1] & 0x20))
3563         return 0; /* No chaining requested - ready. */
3564
3565       DEBUGOUT ("chaining requested but not supported for Secure operation\n");
3566       return CCID_DRIVER_ERR_CARD_IO_ERROR;
3567     }
3568   else if ((tpdu[1] & 0xc0) == 0x80)
3569     { /* This is a R-block. */
3570       if ( (tpdu[1] & 0x0f))
3571         { /* Error: repeat last block */
3572           DEBUGOUT ("No retries supported for Secure operation\n");
3573           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3574         }
3575       else if (!!(tpdu[1] & 0x10) == handle->t1_ns)
3576         { /* Response does not match our sequence number. */
3577           DEBUGOUT ("R-block with wrong seqno received on more bit\n");
3578           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3579         }
3580       else
3581         { /* Send next chunk. */
3582           DEBUGOUT ("chaining not supported on Secure operation\n");
3583           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3584         }
3585     }
3586   else
3587     { /* This is a S-block. */
3588       DEBUGOUT_2 ("T=1: S-block %s received cmd=%d for Secure operation\n",
3589                   (tpdu[1] & 0x20)? "response": "request",
3590                   (tpdu[1] & 0x1f));
3591       return CCID_DRIVER_ERR_CARD_IO_ERROR;
3592     }
3593
3594   return 0;
3595 }
3596
3597
3598
3599
3600 #ifdef TEST
3601
3602
3603 static void
3604 print_error (int err)
3605 {
3606   const char *p;
3607   char buf[50];
3608
3609   switch (err)
3610     {
3611     case 0: p = "success";
3612     case CCID_DRIVER_ERR_OUT_OF_CORE: p = "out of core"; break;
3613     case CCID_DRIVER_ERR_INV_VALUE: p = "invalid value"; break;
3614     case CCID_DRIVER_ERR_NO_DRIVER: p = "no driver"; break;
3615     case CCID_DRIVER_ERR_NOT_SUPPORTED: p = "not supported"; break;
3616     case CCID_DRIVER_ERR_LOCKING_FAILED: p = "locking failed"; break;
3617     case CCID_DRIVER_ERR_BUSY: p = "busy"; break;
3618     case CCID_DRIVER_ERR_NO_CARD: p = "no card"; break;
3619     case CCID_DRIVER_ERR_CARD_INACTIVE: p = "card inactive"; break;
3620     case CCID_DRIVER_ERR_CARD_IO_ERROR: p = "card I/O error"; break;
3621     case CCID_DRIVER_ERR_GENERAL_ERROR: p = "general error"; break;
3622     case CCID_DRIVER_ERR_NO_READER: p = "no reader"; break;
3623     case CCID_DRIVER_ERR_ABORTED: p = "aborted"; break;
3624     default: sprintf (buf, "0x%05x", err); p = buf; break;
3625     }
3626   fprintf (stderr, "operation failed: %s\n", p);
3627 }
3628
3629
3630 static void
3631 print_data (const unsigned char *data, size_t length)
3632 {
3633   if (length >= 2)
3634     {
3635       fprintf (stderr, "operation status: %02X%02X\n",
3636                data[length-2], data[length-1]);
3637       length -= 2;
3638     }
3639   if (length)
3640     {
3641         fputs ("   returned data:", stderr);
3642         for (; length; length--, data++)
3643           fprintf (stderr, " %02X", *data);
3644         putc ('\n', stderr);
3645     }
3646 }
3647
3648 static void
3649 print_result (int rc, const unsigned char *data, size_t length)
3650 {
3651   if (rc)
3652     print_error (rc);
3653   else if (data)
3654     print_data (data, length);
3655 }
3656
3657 int
3658 main (int argc, char **argv)
3659 {
3660   int rc;
3661   ccid_driver_t ccid;
3662   int slotstat;
3663   unsigned char result[512];
3664   size_t resultlen;
3665   int no_pinpad = 0;
3666   int verify_123456 = 0;
3667   int did_verify = 0;
3668   int no_poll = 0;
3669
3670   if (argc)
3671     {
3672       argc--;
3673       argv++;
3674     }
3675
3676   while (argc)
3677     {
3678       if ( !strcmp (*argv, "--list"))
3679         {
3680           char *p;
3681           p = ccid_get_reader_list ();
3682           if (!p)
3683             return 1;
3684           fputs (p, stderr);
3685           free (p);
3686           return 0;
3687         }
3688       else if ( !strcmp (*argv, "--debug"))
3689         {
3690           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
3691           argc--; argv++;
3692         }
3693       else if ( !strcmp (*argv, "--no-poll"))
3694         {
3695           no_poll = 1;
3696           argc--; argv++;
3697         }
3698       else if ( !strcmp (*argv, "--no-pinpad"))
3699         {
3700           no_pinpad = 1;
3701           argc--; argv++;
3702         }
3703       else if ( !strcmp (*argv, "--verify-123456"))
3704         {
3705           verify_123456 = 1;
3706           argc--; argv++;
3707         }
3708       else
3709         break;
3710     }
3711
3712   rc = ccid_open_reader (&ccid, argc? *argv:NULL, NULL);
3713   if (rc)
3714     return 1;
3715
3716   if (!no_poll)
3717     ccid_poll (ccid);
3718   fputs ("getting ATR ...\n", stderr);
3719   rc = ccid_get_atr (ccid, NULL, 0, NULL);
3720   if (rc)
3721     {
3722       print_error (rc);
3723       return 1;
3724     }
3725
3726   if (!no_poll)
3727     ccid_poll (ccid);
3728   fputs ("getting slot status ...\n", stderr);
3729   rc = ccid_slot_status (ccid, &slotstat);
3730   if (rc)
3731     {
3732       print_error (rc);
3733       return 1;
3734     }
3735
3736   if (!no_poll)
3737     ccid_poll (ccid);
3738
3739   fputs ("selecting application OpenPGP ....\n", stderr);
3740   {
3741     static unsigned char apdu[] = {
3742       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
3743     rc = ccid_transceive (ccid,
3744                           apdu, sizeof apdu,
3745                           result, sizeof result, &resultlen);
3746     print_result (rc, result, resultlen);
3747   }
3748
3749
3750   if (!no_poll)
3751     ccid_poll (ccid);
3752
3753   fputs ("getting OpenPGP DO 0x65 ....\n", stderr);
3754   {
3755     static unsigned char apdu[] = { 0, 0xCA, 0, 0x65, 254 };
3756     rc = ccid_transceive (ccid, apdu, sizeof apdu,
3757                           result, sizeof result, &resultlen);
3758     print_result (rc, result, resultlen);
3759   }
3760
3761   if (!no_pinpad)
3762     {
3763     }
3764
3765   if (!no_pinpad)
3766     {
3767       static unsigned char apdu[] = { 0, 0x20, 0, 0x81 };
3768
3769
3770       if (ccid_transceive_secure (ccid,
3771                                   apdu, sizeof apdu,
3772                                   1, 0, 0, 0,
3773                                   NULL, 0, NULL))
3774         fputs ("can't verify using a PIN-Pad reader\n", stderr);
3775       else
3776         {
3777           fputs ("verifying CHV1 using the PINPad ....\n", stderr);
3778
3779           rc = ccid_transceive_secure (ccid,
3780                                        apdu, sizeof apdu,
3781                                        1, 0, 0, 0,
3782                                        result, sizeof result, &resultlen);
3783           print_result (rc, result, resultlen);
3784           did_verify = 1;
3785         }
3786     }
3787
3788   if (verify_123456 && !did_verify)
3789     {
3790       fputs ("verifying that CHV1 is 123456....\n", stderr);
3791       {
3792         static unsigned char apdu[] = {0, 0x20, 0, 0x81,
3793                                        6, '1','2','3','4','5','6'};
3794         rc = ccid_transceive (ccid, apdu, sizeof apdu,
3795                               result, sizeof result, &resultlen);
3796         print_result (rc, result, resultlen);
3797       }
3798     }
3799
3800   if (!rc)
3801     {
3802       fputs ("getting OpenPGP DO 0x5E ....\n", stderr);
3803       {
3804         static unsigned char apdu[] = { 0, 0xCA, 0, 0x5E, 254 };
3805         rc = ccid_transceive (ccid, apdu, sizeof apdu,
3806                               result, sizeof result, &resultlen);
3807         print_result (rc, result, resultlen);
3808       }
3809     }
3810
3811   ccid_close_reader (ccid);
3812
3813   return 0;
3814 }
3815
3816 /*
3817  * Local Variables:
3818  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
3819  * End:
3820  */
3821 #endif /*TEST*/
3822 #endif /*HAVE_LIBUSB*/