gpg: Initialize the primary key when generating a key.
[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   int 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       if (msglen < 0)
1977         return CCID_DRIVER_ERR_INV_VALUE;  /* Faulty libusb.  */
1978       *nread = msglen;
1979     }
1980   else
1981     {
1982       rc = read (handle->dev_fd, buffer, length);
1983       if (rc < 0)
1984         {
1985           rc = errno;
1986           DEBUGOUT_2 ("read from %d failed: %s\n",
1987                       handle->dev_fd, strerror (rc));
1988           if (rc == EAGAIN && eagain_retries++ < 5)
1989             {
1990               my_sleep (1);
1991               goto retry;
1992             }
1993           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1994         }
1995       *nread = msglen = rc;
1996     }
1997   eagain_retries = 0;
1998
1999   if (msglen < 10)
2000     {
2001       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
2002       abort_cmd (handle, seqno);
2003       return CCID_DRIVER_ERR_INV_VALUE;
2004     }
2005   if (buffer[5] != 0)
2006     {
2007       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
2008       return CCID_DRIVER_ERR_INV_VALUE;
2009     }
2010   if (buffer[6] != seqno)
2011     {
2012       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
2013                   seqno, buffer[6]);
2014       /* Retry until we are synced again.  */
2015       goto retry;
2016     }
2017
2018   /* We need to handle the time extension request before we check that
2019      we got the expected message type.  This is in particular required
2020      for the Cherry keyboard which sends a time extension request for
2021      each key hit.  */
2022   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
2023     {
2024       /* Card present and active, time extension requested. */
2025       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
2026                   buffer[7], buffer[8]);
2027       goto retry;
2028     }
2029
2030   if (buffer[0] != expected_type)
2031     {
2032       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
2033       abort_cmd (handle, seqno);
2034       return CCID_DRIVER_ERR_INV_VALUE;
2035     }
2036
2037   if (debug_level && (!no_debug || debug_level >= 3))
2038     {
2039       switch (buffer[0])
2040         {
2041         case RDR_to_PC_DataBlock:
2042           print_r2p_datablock (buffer, msglen);
2043           break;
2044         case RDR_to_PC_SlotStatus:
2045           print_r2p_slotstatus (buffer, msglen);
2046           break;
2047         case RDR_to_PC_Parameters:
2048           print_r2p_parameters (buffer, msglen);
2049           break;
2050         case RDR_to_PC_Escape:
2051           print_r2p_escape (buffer, msglen);
2052           break;
2053         case RDR_to_PC_DataRate:
2054           print_r2p_datarate (buffer, msglen);
2055           break;
2056         default:
2057           print_r2p_unknown (buffer, msglen);
2058           break;
2059         }
2060     }
2061   if (CCID_COMMAND_FAILED (buffer))
2062     print_command_failed (buffer);
2063
2064   /* Check whether a card is at all available.  Note: If you add new
2065      error codes here, check whether they need to be ignored in
2066      send_escape_cmd. */
2067   switch ((buffer[7] & 0x03))
2068     {
2069     case 0: /* no error */ break;
2070     case 1: return CCID_DRIVER_ERR_CARD_INACTIVE;
2071     case 2: return CCID_DRIVER_ERR_NO_CARD;
2072     case 3: /* RFU */ break;
2073     }
2074   return 0;
2075 }
2076
2077
2078
2079 /* Send an abort sequence and wait until everything settled.  */
2080 static int
2081 abort_cmd (ccid_driver_t handle, int seqno)
2082 {
2083   int rc;
2084   char dummybuf[8];
2085   unsigned char msg[100];
2086   int msglen;
2087
2088   if (!handle->idev)
2089     {
2090       /* I don't know how to send an abort to non-USB devices.  */
2091       rc = CCID_DRIVER_ERR_NOT_SUPPORTED;
2092     }
2093
2094   seqno &= 0xff;
2095   DEBUGOUT_1 ("sending abort sequence for seqno %d\n", seqno);
2096   /* Send the abort command to the control pipe.  Note that we don't
2097      need to keep track of sent abort commands because there should
2098      never be another thread using the same slot concurrently.  */
2099   rc = libusb_control_transfer (handle->idev,
2100                                 0x21,/* bmRequestType: host-to-device,
2101                                         class specific, to interface.  */
2102                                 1,   /* ABORT */
2103                                 (seqno << 8 | 0 /* slot */),
2104                                 handle->ifc_no,
2105                                 dummybuf, 0,
2106                                 1000 /* ms timeout */);
2107   if (rc < 0)
2108     {
2109       DEBUGOUT_1 ("usb_control_msg error: %s\n", libusb_error_name (rc));
2110       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2111     }
2112
2113   /* Now send the abort command to the bulk out pipe using the same
2114      SEQNO and SLOT.  Do this in a loop to so that all seqno are
2115      tried.  */
2116   seqno--;  /* Adjust for next increment.  */
2117   do
2118     {
2119       int transferred;
2120
2121       seqno++;
2122       msg[0] = PC_to_RDR_Abort;
2123       msg[5] = 0; /* slot */
2124       msg[6] = seqno;
2125       msg[7] = 0; /* RFU */
2126       msg[8] = 0; /* RFU */
2127       msg[9] = 0; /* RFU */
2128       msglen = 10;
2129       set_msg_len (msg, 0);
2130
2131       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
2132                                  (char*)msg, msglen, &transferred,
2133                                  5000 /* ms timeout */);
2134       if (rc == 0 && transferred == msglen)
2135         rc = 0;
2136       else if (rc < 0)
2137         DEBUGOUT_1 ("usb_bulk_write error in abort_cmd: %s\n",
2138                     libusb_error_name (rc));
2139
2140       if (rc)
2141         return rc;
2142
2143       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
2144                                  (char*)msg, sizeof msg, &msglen,
2145                                  5000 /*ms timeout*/);
2146       if (rc < 0)
2147         {
2148           DEBUGOUT_1 ("usb_bulk_read error in abort_cmd: %s\n",
2149                       libusb_error_name (rc));
2150           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2151         }
2152
2153       if (msglen < 10)
2154         {
2155           DEBUGOUT_1 ("bulk-in msg in abort_cmd too short (%u)\n",
2156                       (unsigned int)msglen);
2157           return CCID_DRIVER_ERR_INV_VALUE;
2158         }
2159       if (msg[5] != 0)
2160         {
2161           DEBUGOUT_1 ("unexpected bulk-in slot (%d) in abort_cmd\n", msg[5]);
2162           return CCID_DRIVER_ERR_INV_VALUE;
2163         }
2164
2165       DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n",
2166                   msg[7], msg[8], msg[9]);
2167       if (CCID_COMMAND_FAILED (msg))
2168         print_command_failed (msg);
2169     }
2170   while (msg[0] != RDR_to_PC_SlotStatus && msg[5] != 0 && msg[6] != seqno);
2171
2172   handle->seqno = ((seqno + 1) & 0xff);
2173   DEBUGOUT ("sending abort sequence succeeded\n");
2174
2175   return 0;
2176 }
2177
2178
2179 /* Note that this function won't return the error codes NO_CARD or
2180    CARD_INACTIVE.  IF RESULT is not NULL, the result from the
2181    operation will get returned in RESULT and its length in RESULTLEN.
2182    If the response is larger than RESULTMAX, an error is returned and
2183    the required buffer length returned in RESULTLEN.  */
2184 static int
2185 send_escape_cmd (ccid_driver_t handle,
2186                  const unsigned char *data, size_t datalen,
2187                  unsigned char *result, size_t resultmax, size_t *resultlen)
2188 {
2189   int rc;
2190   unsigned char msg[100];
2191   size_t msglen;
2192   unsigned char seqno;
2193
2194   if (resultlen)
2195     *resultlen = 0;
2196
2197   if (datalen > sizeof msg - 10)
2198     return CCID_DRIVER_ERR_INV_VALUE; /* Escape data too large.  */
2199
2200   msg[0] = PC_to_RDR_Escape;
2201   msg[5] = 0; /* slot */
2202   msg[6] = seqno = handle->seqno++;
2203   msg[7] = 0; /* RFU */
2204   msg[8] = 0; /* RFU */
2205   msg[9] = 0; /* RFU */
2206   memcpy (msg+10, data, datalen);
2207   msglen = 10 + datalen;
2208   set_msg_len (msg, datalen);
2209
2210   rc = bulk_out (handle, msg, msglen, 0);
2211   if (rc)
2212     return rc;
2213   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Escape,
2214                 seqno, 5000, 0);
2215   if (result)
2216     switch (rc)
2217       {
2218         /* We need to ignore certain errorcode here. */
2219       case 0:
2220       case CCID_DRIVER_ERR_CARD_INACTIVE:
2221       case CCID_DRIVER_ERR_NO_CARD:
2222         {
2223           if (msglen > resultmax)
2224             rc = CCID_DRIVER_ERR_INV_VALUE; /* Response too large. */
2225           else
2226             {
2227               memcpy (result, msg, msglen);
2228               *resultlen = msglen;
2229               rc = 0;
2230             }
2231         }
2232         break;
2233       default:
2234         break;
2235       }
2236
2237   return rc;
2238 }
2239
2240
2241 int
2242 ccid_transceive_escape (ccid_driver_t handle,
2243                         const unsigned char *data, size_t datalen,
2244                         unsigned char *resp, size_t maxresplen, size_t *nresp)
2245 {
2246   return send_escape_cmd (handle, data, datalen, resp, maxresplen, nresp);
2247 }
2248
2249
2250
2251 /* experimental */
2252 int
2253 ccid_poll (ccid_driver_t handle)
2254 {
2255   int rc;
2256   unsigned char msg[10];
2257   int msglen;
2258   int i, j;
2259
2260   if (handle->idev)
2261     {
2262       rc = libusb_bulk_transfer (handle->idev, handle->ep_intr,
2263                                  (char*)msg, sizeof msg, &msglen,
2264                                  0 /* ms timeout */ );
2265       if (rc == LIBUSB_ERROR_TIMEOUT)
2266         return 0;
2267     }
2268   else
2269     return 0;
2270
2271   if (rc < 0)
2272     {
2273       DEBUGOUT_1 ("usb_intr_read error: %s\n", libusb_error_name (rc));
2274       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2275     }
2276
2277   if (msglen < 1)
2278     {
2279       DEBUGOUT ("intr-in msg too short\n");
2280       return CCID_DRIVER_ERR_INV_VALUE;
2281     }
2282
2283   if (msg[0] == RDR_to_PC_NotifySlotChange)
2284     {
2285       DEBUGOUT ("notify slot change:");
2286       for (i=1; i < msglen; i++)
2287         for (j=0; j < 4; j++)
2288           DEBUGOUT_CONT_3 (" %d:%c%c",
2289                            (i-1)*4+j,
2290                            (msg[i] & (1<<(j*2)))? 'p':'-',
2291                            (msg[i] & (2<<(j*2)))? '*':' ');
2292       DEBUGOUT_LF ();
2293     }
2294   else if (msg[0] == RDR_to_PC_HardwareError)
2295     {
2296       DEBUGOUT ("hardware error occurred\n");
2297     }
2298   else
2299     {
2300       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
2301     }
2302
2303   return 0;
2304 }
2305
2306
2307 /* Note that this function won't return the error codes NO_CARD or
2308    CARD_INACTIVE */
2309 int
2310 ccid_slot_status (ccid_driver_t handle, int *statusbits)
2311 {
2312   int rc;
2313   unsigned char msg[100];
2314   size_t msglen;
2315   unsigned char seqno;
2316   int retries = 0;
2317
2318  retry:
2319   msg[0] = PC_to_RDR_GetSlotStatus;
2320   msg[5] = 0; /* slot */
2321   msg[6] = seqno = handle->seqno++;
2322   msg[7] = 0; /* RFU */
2323   msg[8] = 0; /* RFU */
2324   msg[9] = 0; /* RFU */
2325   set_msg_len (msg, 0);
2326
2327   rc = bulk_out (handle, msg, 10, 1);
2328   if (rc)
2329     return rc;
2330   /* Note that we set the NO_DEBUG flag here, so that the logs won't
2331      get cluttered up by a ticker function checking for the slot
2332      status and debugging enabled. */
2333   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
2334                 seqno, retries? 1000 : 200, 1);
2335   if (rc == CCID_DRIVER_ERR_CARD_IO_ERROR && retries < 3)
2336     {
2337       if (!retries)
2338         {
2339           DEBUGOUT ("USB: CALLING USB_CLEAR_HALT\n");
2340           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
2341           libusb_clear_halt (handle->idev, handle->ep_bulk_out);
2342         }
2343       else
2344           DEBUGOUT ("USB: RETRYING bulk_in AGAIN\n");
2345       retries++;
2346       goto retry;
2347     }
2348   if (rc && rc != CCID_DRIVER_ERR_NO_CARD
2349       && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
2350     return rc;
2351   *statusbits = (msg[7] & 3);
2352
2353   return 0;
2354 }
2355
2356
2357 /* Parse ATR string (of ATRLEN) and update parameters at PARAM.
2358    Calling this routine, it should prepare default values at PARAM
2359    beforehand.  This routine assumes that card is accessed by T=1
2360    protocol.  It doesn't analyze historical bytes at all.
2361
2362    Returns < 0 value on error:
2363      -1 for parse error or integrity check error
2364      -2 for card doesn't support T=1 protocol
2365      -3 for parameters are nod explicitly defined by ATR
2366      -4 for this driver doesn't support CRC
2367
2368    Returns >= 0 on success:
2369       0 for card is negotiable mode
2370       1 for card is specific mode (and not negotiable)
2371  */
2372 static int
2373 update_param_by_atr (unsigned char *param, unsigned char *atr, size_t atrlen)
2374 {
2375   int i = -1;
2376   int t, y, chk;
2377   int historical_bytes_num, negotiable = 1;
2378
2379 #define NEXTBYTE() do { i++; if (atrlen <= i) return -1; } while (0)
2380
2381   NEXTBYTE ();
2382
2383   if (atr[i] == 0x3F)
2384     param[1] |= 0x02;           /* Convention is inverse.  */
2385   NEXTBYTE ();
2386
2387   y = (atr[i] >> 4);
2388   historical_bytes_num = atr[i] & 0x0f;
2389   NEXTBYTE ();
2390
2391   if ((y & 1))
2392     {
2393       param[0] = atr[i];        /* TA1 - Fi & Di */
2394       NEXTBYTE ();
2395     }
2396
2397   if ((y & 2))
2398     NEXTBYTE ();                /* TB1 - ignore */
2399
2400   if ((y & 4))
2401     {
2402       param[2] = atr[i];        /* TC1 - Guard Time */
2403       NEXTBYTE ();
2404     }
2405
2406   if ((y & 8))
2407     {
2408       y = (atr[i] >> 4);        /* TD1 */
2409       t = atr[i] & 0x0f;
2410       NEXTBYTE ();
2411
2412       if ((y & 1))
2413         {                       /* TA2 - PPS mode */
2414           if ((atr[i] & 0x0f) != 1)
2415             return -2;          /* Wrong card protocol (!= 1).  */
2416
2417           if ((atr[i] & 0x10) != 0x10)
2418             return -3; /* Transmission parameters are implicitly defined. */
2419
2420           negotiable = 0;       /* TA2 means specific mode.  */
2421           NEXTBYTE ();
2422         }
2423
2424       if ((y & 2))
2425         NEXTBYTE ();            /* TB2 - ignore */
2426
2427       if ((y & 4))
2428         NEXTBYTE ();            /* TC2 - ignore */
2429
2430       if ((y & 8))
2431         {
2432           y = (atr[i] >> 4);    /* TD2 */
2433           t = atr[i] & 0x0f;
2434           NEXTBYTE ();
2435         }
2436       else
2437         y = 0;
2438
2439       while (y)
2440         {
2441           if ((y & 1))
2442             {                   /* TAx */
2443               if (t == 1)
2444                 param[5] = atr[i]; /* IFSC */
2445               else if (t == 15)
2446                 /* XXX: check voltage? */
2447                 param[4] = (atr[i] >> 6); /* ClockStop */
2448
2449               NEXTBYTE ();
2450             }
2451
2452           if ((y & 2))
2453             {
2454               if (t == 1)
2455                 param[3] = atr[i]; /* TBx - BWI & CWI */
2456               NEXTBYTE ();
2457             }
2458
2459           if ((y & 4))
2460             {
2461               if (t == 1)
2462                 param[1] |= (atr[i] & 0x01); /* TCx - LRC/CRC */
2463               NEXTBYTE ();
2464
2465               if (param[1] & 0x01)
2466                 return -4;      /* CRC not supported yet.  */
2467             }
2468
2469           if ((y & 8))
2470             {
2471               y = (atr[i] >> 4); /* TDx */
2472               t = atr[i] & 0x0f;
2473               NEXTBYTE ();
2474             }
2475           else
2476             y = 0;
2477         }
2478     }
2479
2480   i += historical_bytes_num - 1;
2481   NEXTBYTE ();
2482   if (atrlen != i+1)
2483     return -1;
2484
2485 #undef NEXTBYTE
2486
2487   chk = 0;
2488   do
2489     {
2490       chk ^= atr[i];
2491       i--;
2492     }
2493   while (i > 0);
2494
2495   if (chk != 0)
2496     return -1;
2497
2498   return negotiable;
2499 }
2500
2501
2502 /* Return the ATR of the card.  This is not a cached value and thus an
2503    actual reset is done.  */
2504 int
2505 ccid_get_atr (ccid_driver_t handle,
2506               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
2507 {
2508   int rc;
2509   int statusbits;
2510   unsigned char msg[100];
2511   unsigned char *tpdu;
2512   size_t msglen, tpdulen;
2513   unsigned char seqno;
2514   int use_crc = 0;
2515   unsigned int edc;
2516   int tried_iso = 0;
2517   int got_param;
2518   unsigned char param[7] = { /* For Protocol T=1 */
2519     0x11, /* bmFindexDindex */
2520     0x10, /* bmTCCKST1 */
2521     0x00, /* bGuardTimeT1 */
2522     0x4d, /* bmWaitingIntegersT1 */
2523     0x00, /* bClockStop */
2524     0x20, /* bIFSC */
2525     0x00  /* bNadValue */
2526   };
2527
2528   /* First check whether a card is available.  */
2529   rc = ccid_slot_status (handle, &statusbits);
2530   if (rc)
2531     return rc;
2532   if (statusbits == 2)
2533     return CCID_DRIVER_ERR_NO_CARD;
2534
2535   /* For an inactive and also for an active card, issue the PowerOn
2536      command to get the ATR.  */
2537  again:
2538   msg[0] = PC_to_RDR_IccPowerOn;
2539   msg[5] = 0; /* slot */
2540   msg[6] = seqno = handle->seqno++;
2541   /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
2542   msg[7] = handle->auto_voltage ? 0 : 1;
2543   msg[8] = 0; /* RFU */
2544   msg[9] = 0; /* RFU */
2545   set_msg_len (msg, 0);
2546   msglen = 10;
2547
2548   rc = bulk_out (handle, msg, msglen, 0);
2549   if (rc)
2550     return rc;
2551   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2552                 seqno, 5000, 0);
2553   if (rc)
2554     return rc;
2555   if (!tried_iso && CCID_COMMAND_FAILED (msg) && CCID_ERROR_CODE (msg) == 0xbb
2556       && ((handle->id_vendor == VENDOR_CHERRY
2557            && handle->id_product == 0x0005)
2558           || (handle->id_vendor == VENDOR_GEMPC
2559               && handle->id_product == 0x4433)
2560           ))
2561     {
2562       tried_iso = 1;
2563       /* Try switching to ISO mode. */
2564       if (!send_escape_cmd (handle, (const unsigned char*)"\xF1\x01", 2,
2565                             NULL, 0, NULL))
2566         goto again;
2567     }
2568   else if (CCID_COMMAND_FAILED (msg))
2569     return CCID_DRIVER_ERR_CARD_IO_ERROR;
2570
2571
2572   handle->powered_off = 0;
2573
2574   if (atr)
2575     {
2576       size_t n = msglen - 10;
2577
2578       if (n > maxatrlen)
2579         n = maxatrlen;
2580       memcpy (atr, msg+10, n);
2581       *atrlen = n;
2582     }
2583
2584   param[6] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2585   rc = update_param_by_atr (param, msg+10, msglen - 10);
2586   if (rc < 0)
2587     {
2588       DEBUGOUT_1 ("update_param_by_atr failed: %d\n", rc);
2589       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2590     }
2591
2592   got_param = 0;
2593
2594   if (handle->auto_param)
2595     {
2596       msg[0] = PC_to_RDR_GetParameters;
2597       msg[5] = 0; /* slot */
2598       msg[6] = seqno = handle->seqno++;
2599       msg[7] = 0; /* RFU */
2600       msg[8] = 0; /* RFU */
2601       msg[9] = 0; /* RFU */
2602       set_msg_len (msg, 0);
2603       msglen = 10;
2604       rc = bulk_out (handle, msg, msglen, 0);
2605       if (!rc)
2606         rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2607                       seqno, 2000, 0);
2608       if (rc)
2609         DEBUGOUT ("GetParameters failed\n");
2610       else if (msglen == 17 && msg[9] == 1)
2611         got_param = 1;
2612     }
2613   else if (handle->auto_pps)
2614     ;
2615   else if (rc == 1)             /* It's negotiable, send PPS.  */
2616     {
2617       msg[0] = PC_to_RDR_XfrBlock;
2618       msg[5] = 0; /* slot */
2619       msg[6] = seqno = handle->seqno++;
2620       msg[7] = 0;
2621       msg[8] = 0;
2622       msg[9] = 0;
2623       msg[10] = 0xff;           /* PPSS */
2624       msg[11] = 0x11;           /* PPS0: PPS1, Protocol T=1 */
2625       msg[12] = param[0];       /* PPS1: Fi / Di */
2626       msg[13] = 0xff ^ 0x11 ^ param[0]; /* PCK */
2627       set_msg_len (msg, 4);
2628       msglen = 10 + 4;
2629
2630       rc = bulk_out (handle, msg, msglen, 0);
2631       if (rc)
2632         return rc;
2633
2634       rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2635                     seqno, 5000, 0);
2636       if (rc)
2637         return rc;
2638
2639       if (msglen != 10 + 4)
2640         {
2641           DEBUGOUT_1 ("Setting PPS failed: %zu\n", msglen);
2642           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2643         }
2644
2645       if (msg[10] != 0xff || msg[11] != 0x11 || msg[12] != param[0])
2646         {
2647           DEBUGOUT_1 ("Setting PPS failed: 0x%02x\n", param[0]);
2648           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2649         }
2650     }
2651
2652   /* Setup parameters to select T=1. */
2653   msg[0] = PC_to_RDR_SetParameters;
2654   msg[5] = 0; /* slot */
2655   msg[6] = seqno = handle->seqno++;
2656   msg[7] = 1; /* Select T=1. */
2657   msg[8] = 0; /* RFU */
2658   msg[9] = 0; /* RFU */
2659
2660   if (!got_param)
2661     memcpy (&msg[10], param, 7);
2662   set_msg_len (msg, 7);
2663   msglen = 10 + 7;
2664
2665   rc = bulk_out (handle, msg, msglen, 0);
2666   if (rc)
2667     return rc;
2668   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2669                 seqno, 5000, 0);
2670   if (rc)
2671     DEBUGOUT ("SetParameters failed (ignored)\n");
2672
2673   if (!rc && msglen > 15 && msg[15] >= 16 && msg[15] <= 254 )
2674     handle->ifsc = msg[15];
2675   else
2676     handle->ifsc = 128; /* Something went wrong, assume 128 bytes.  */
2677
2678   if (handle->nonnull_nad && msglen > 16 && msg[16] == 0)
2679     {
2680       DEBUGOUT ("Use Null-NAD, clearing handle->nonnull_nad.\n");
2681       handle->nonnull_nad = 0;
2682     }
2683
2684   handle->t1_ns = 0;
2685   handle->t1_nr = 0;
2686
2687   /* Send an S-Block with our maximum IFSD to the CCID.  */
2688   if (!handle->apdu_level && !handle->auto_ifsd)
2689     {
2690       tpdu = msg+10;
2691       /* NAD: DAD=1, SAD=0 */
2692       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2693       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
2694       tpdu[2] = 1;
2695       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32;
2696       tpdulen = 4;
2697       edc = compute_edc (tpdu, tpdulen, use_crc);
2698       if (use_crc)
2699         tpdu[tpdulen++] = (edc >> 8);
2700       tpdu[tpdulen++] = edc;
2701
2702       msg[0] = PC_to_RDR_XfrBlock;
2703       msg[5] = 0; /* slot */
2704       msg[6] = seqno = handle->seqno++;
2705       msg[7] = 0;
2706       msg[8] = 0; /* RFU */
2707       msg[9] = 0; /* RFU */
2708       set_msg_len (msg, tpdulen);
2709       msglen = 10 + tpdulen;
2710
2711       if (debug_level > 1)
2712         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
2713                       ((msg[11] & 0xc0) == 0x80)? 'R' :
2714                                 (msg[11] & 0x80)? 'S' : 'I',
2715                       ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2716                                        : !!(msg[11] & 0x40)),
2717                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2718
2719       rc = bulk_out (handle, msg, msglen, 0);
2720       if (rc)
2721         return rc;
2722
2723
2724       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2725                     RDR_to_PC_DataBlock, seqno, 5000, 0);
2726       if (rc)
2727         return rc;
2728
2729       tpdu = msg + 10;
2730       tpdulen = msglen - 10;
2731
2732       if (tpdulen < 4)
2733         return CCID_DRIVER_ERR_ABORTED;
2734
2735       if (debug_level > 1)
2736         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
2737                     ((msg[11] & 0xc0) == 0x80)? 'R' :
2738                               (msg[11] & 0x80)? 'S' : 'I',
2739                     ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2740                                      : !!(msg[11] & 0x40)),
2741                     ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
2742                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2743
2744       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
2745         {
2746           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
2747           return -1;
2748         }
2749       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
2750     }
2751
2752   return 0;
2753 }
2754
2755
2756 \f
2757
2758 static unsigned int
2759 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
2760 {
2761   if (use_crc)
2762     {
2763       return 0x42; /* Not yet implemented. */
2764     }
2765   else
2766     {
2767       unsigned char crc = 0;
2768
2769       for (; datalen; datalen--)
2770         crc ^= *data++;
2771       return crc;
2772     }
2773 }
2774
2775
2776 /* Return true if APDU is an extended length one.  */
2777 static int
2778 is_exlen_apdu (const unsigned char *apdu, size_t apdulen)
2779 {
2780   if (apdulen < 7 || apdu[4])
2781     return 0;  /* Too short or no Z byte.  */
2782   return 1;
2783 }
2784
2785
2786 /* Helper for ccid_transceive used for APDU level exchanges.  */
2787 static int
2788 ccid_transceive_apdu_level (ccid_driver_t handle,
2789                             const unsigned char *apdu_buf, size_t apdu_len,
2790                             unsigned char *resp, size_t maxresplen,
2791                             size_t *nresp)
2792 {
2793   int rc;
2794   unsigned char msg[CCID_MAX_BUF];
2795   const unsigned char *apdu_p;
2796   size_t apdu_part_len;
2797   size_t msglen;
2798   unsigned char seqno;
2799   int bwi = 4;
2800   unsigned char chain = 0;
2801
2802   if (apdu_len == 0 || apdu_len > sizeof (msg) - 10)
2803     return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
2804
2805   apdu_p = apdu_buf;
2806   while (1)
2807     {
2808       apdu_part_len = apdu_len;
2809       if (apdu_part_len > handle->max_ccid_msglen - 10)
2810         {
2811           apdu_part_len = handle->max_ccid_msglen - 10;
2812           chain |= 0x01;
2813         }
2814
2815       msg[0] = PC_to_RDR_XfrBlock;
2816       msg[5] = 0; /* slot */
2817       msg[6] = seqno = handle->seqno++;
2818       msg[7] = bwi;
2819       msg[8] = chain;
2820       msg[9] = 0;
2821       memcpy (msg+10, apdu_p, apdu_part_len);
2822       set_msg_len (msg, apdu_part_len);
2823       msglen = 10 + apdu_part_len;
2824
2825       rc = bulk_out (handle, msg, msglen, 0);
2826       if (rc)
2827         return rc;
2828
2829       apdu_p += apdu_part_len;
2830       apdu_len -= apdu_part_len;
2831
2832       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2833                     RDR_to_PC_DataBlock, seqno, CCID_CMD_TIMEOUT, 0);
2834       if (rc)
2835         return rc;
2836
2837       if (!(chain & 0x01))
2838         break;
2839
2840       chain = 0x02;
2841     }
2842
2843   apdu_len = 0;
2844   while (1)
2845     {
2846       apdu_part_len = msglen - 10;
2847       if (resp && apdu_len + apdu_part_len <= maxresplen)
2848         memcpy (resp + apdu_len, msg+10, apdu_part_len);
2849       apdu_len += apdu_part_len;
2850
2851       if (!(msg[9] & 0x01))
2852         break;
2853
2854       msg[0] = PC_to_RDR_XfrBlock;
2855       msg[5] = 0; /* slot */
2856       msg[6] = seqno = handle->seqno++;
2857       msg[7] = bwi;
2858       msg[8] = 0x10;                /* Request next data block */
2859       msg[9] = 0;
2860       set_msg_len (msg, 0);
2861       msglen = 10;
2862
2863       rc = bulk_out (handle, msg, msglen, 0);
2864       if (rc)
2865         return rc;
2866
2867       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2868                     RDR_to_PC_DataBlock, seqno, CCID_CMD_TIMEOUT, 0);
2869       if (rc)
2870         return rc;
2871     }
2872
2873   if (resp)
2874     {
2875       if (apdu_len > maxresplen)
2876         {
2877           DEBUGOUT_2 ("provided buffer too short for received data "
2878                       "(%u/%u)\n",
2879                       (unsigned int)apdu_len, (unsigned int)maxresplen);
2880           return CCID_DRIVER_ERR_INV_VALUE;
2881         }
2882
2883       *nresp = apdu_len;
2884     }
2885
2886   return 0;
2887 }
2888
2889
2890
2891 /*
2892   Protocol T=1 overview
2893
2894   Block Structure:
2895            Prologue Field:
2896    1 byte     Node Address (NAD)
2897    1 byte     Protocol Control Byte (PCB)
2898    1 byte     Length (LEN)
2899            Information Field:
2900    0-254 byte APDU or Control Information (INF)
2901            Epilogue Field:
2902    1 byte     Error Detection Code (EDC)
2903
2904   NAD:
2905    bit 7     unused
2906    bit 4..6  Destination Node Address (DAD)
2907    bit 3     unused
2908    bit 2..0  Source Node Address (SAD)
2909
2910    If node adresses are not used, SAD and DAD should be set to 0 on
2911    the first block sent to the card.  If they are used they should
2912    have different values (0 for one is okay); that first block sets up
2913    the addresses of the nodes.
2914
2915   PCB:
2916    Information Block (I-Block):
2917       bit 7    0
2918       bit 6    Sequence number (yep, that is modulo 2)
2919       bit 5    Chaining flag
2920       bit 4..0 reserved
2921    Received-Ready Block (R-Block):
2922       bit 7    1
2923       bit 6    0
2924       bit 5    0
2925       bit 4    Sequence number
2926       bit 3..0  0 = no error
2927                 1 = EDC or parity error
2928                 2 = other error
2929                 other values are reserved
2930    Supervisory Block (S-Block):
2931       bit 7    1
2932       bit 6    1
2933       bit 5    clear=request,set=response
2934       bit 4..0  0 = resyncronisation request
2935                 1 = information field size request
2936                 2 = abort request
2937                 3 = extension of BWT request
2938                 4 = VPP error
2939                 other values are reserved
2940
2941 */
2942
2943 int
2944 ccid_transceive (ccid_driver_t handle,
2945                  const unsigned char *apdu_buf, size_t apdu_buflen,
2946                  unsigned char *resp, size_t maxresplen, size_t *nresp)
2947 {
2948   int rc;
2949   /* The size of the buffer used to be 10+259.  For the via_escape
2950      hack we need one extra byte, thus 11+259.  */
2951   unsigned char send_buffer[11+259], recv_buffer[11+259];
2952   const unsigned char *apdu;
2953   size_t apdulen;
2954   unsigned char *msg, *tpdu, *p;
2955   size_t msglen, tpdulen, last_tpdulen, n;
2956   unsigned char seqno;
2957   unsigned int edc;
2958   int use_crc = 0;
2959   int hdrlen, pcboff;
2960   size_t dummy_nresp;
2961   int via_escape = 0;
2962   int next_chunk = 1;
2963   int sending = 1;
2964   int retries = 0;
2965   int resyncing = 0;
2966   int nad_byte;
2967
2968   if (!nresp)
2969     nresp = &dummy_nresp;
2970   *nresp = 0;
2971
2972   /* Smarter readers allow to send APDUs directly; divert here. */
2973   if (handle->apdu_level)
2974     {
2975       /* We employ a hack for Omnikey readers which are able to send
2976          TPDUs using an escape sequence.  There is no documentation
2977          but the Windows driver does it this way.  Tested using a
2978          CM6121.  This method works also for the Cherry XX44
2979          keyboards; however there are problems with the
2980          ccid_tranceive_secure which leads to a loss of sync on the
2981          CCID level.  If Cherry wants to make their keyboard work
2982          again, they should hand over some docs. */
2983       if ((handle->id_vendor == VENDOR_OMNIKEY
2984            || (!handle->idev && handle->id_product == TRANSPORT_CM4040))
2985           && handle->apdu_level < 2
2986           && is_exlen_apdu (apdu_buf, apdu_buflen))
2987         via_escape = 1;
2988       else
2989         return ccid_transceive_apdu_level (handle, apdu_buf, apdu_buflen,
2990                                            resp, maxresplen, nresp);
2991     }
2992
2993   /* The other readers we support require sending TPDUs.  */
2994
2995   tpdulen = 0; /* Avoid compiler warning about no initialization. */
2996   msg = send_buffer;
2997   hdrlen = via_escape? 11 : 10;
2998
2999   /* NAD: DAD=1, SAD=0 */
3000   nad_byte = handle->nonnull_nad? ((1 << 4) | 0): 0;
3001   if (via_escape)
3002     nad_byte = 0;
3003
3004   last_tpdulen = 0;  /* Avoid gcc warning (controlled by RESYNCING). */
3005   for (;;)
3006     {
3007       if (next_chunk)
3008         {
3009           next_chunk = 0;
3010
3011           apdu = apdu_buf;
3012           apdulen = apdu_buflen;
3013           assert (apdulen);
3014
3015           /* Construct an I-Block. */
3016           tpdu = msg + hdrlen;
3017           tpdu[0] = nad_byte;
3018           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
3019           if (apdulen > handle->ifsc )
3020             {
3021               apdulen = handle->ifsc;
3022               apdu_buf += handle->ifsc;
3023               apdu_buflen -= handle->ifsc;
3024               tpdu[1] |= (1 << 5); /* Set more bit. */
3025             }
3026           tpdu[2] = apdulen;
3027           memcpy (tpdu+3, apdu, apdulen);
3028           tpdulen = 3 + apdulen;
3029           edc = compute_edc (tpdu, tpdulen, use_crc);
3030           if (use_crc)
3031             tpdu[tpdulen++] = (edc >> 8);
3032           tpdu[tpdulen++] = edc;
3033         }
3034
3035       if (via_escape)
3036         {
3037           msg[0] = PC_to_RDR_Escape;
3038           msg[5] = 0; /* slot */
3039           msg[6] = seqno = handle->seqno++;
3040           msg[7] = 0; /* RFU */
3041           msg[8] = 0; /* RFU */
3042           msg[9] = 0; /* RFU */
3043           msg[10] = 0x1a; /* Omnikey command to send a TPDU.  */
3044           set_msg_len (msg, 1 + tpdulen);
3045         }
3046       else
3047         {
3048           msg[0] = PC_to_RDR_XfrBlock;
3049           msg[5] = 0; /* slot */
3050           msg[6] = seqno = handle->seqno++;
3051           msg[7] = 4; /* bBWI */
3052           msg[8] = 0; /* RFU */
3053           msg[9] = 0; /* RFU */
3054           set_msg_len (msg, tpdulen);
3055         }
3056       msglen = hdrlen + tpdulen;
3057       if (!resyncing)
3058         last_tpdulen = tpdulen;
3059       pcboff = hdrlen+1;
3060
3061       if (debug_level > 1)
3062         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
3063                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3064                     (msg[pcboff] & 0x80)? 'S' : 'I',
3065                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3066                      : !!(msg[pcboff] & 0x40)),
3067                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3068                      " [more]":""));
3069
3070       rc = bulk_out (handle, msg, msglen, 0);
3071       if (rc)
3072         return rc;
3073
3074       msg = recv_buffer;
3075       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3076                     via_escape? RDR_to_PC_Escape : RDR_to_PC_DataBlock,
3077                     seqno, CCID_CMD_TIMEOUT, 0);
3078       if (rc)
3079         return rc;
3080
3081       tpdu = msg + hdrlen;
3082       tpdulen = msglen - hdrlen;
3083       resyncing = 0;
3084
3085       if (tpdulen < 4)
3086         {
3087           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
3088           return CCID_DRIVER_ERR_ABORTED;
3089         }
3090
3091       if (debug_level > 1)
3092         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3093                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3094                               (msg[pcboff] & 0x80)? 'S' : 'I',
3095                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3096                      : !!(msg[pcboff] & 0x40)),
3097                     ((msg[pcboff] & 0xc0) == 0x80)? (msg[pcboff] & 0x0f) : 0,
3098                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3099                      " [more]":""));
3100
3101       if (!(tpdu[1] & 0x80))
3102         { /* This is an I-block. */
3103           retries = 0;
3104           if (sending)
3105             { /* last block sent was successful. */
3106               handle->t1_ns ^= 1;
3107               sending = 0;
3108             }
3109
3110           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3111             { /* Response does not match our sequence number. */
3112               msg = send_buffer;
3113               tpdu = msg + hdrlen;
3114               tpdu[0] = nad_byte;
3115               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
3116               tpdu[2] = 0;
3117               tpdulen = 3;
3118               edc = compute_edc (tpdu, tpdulen, use_crc);
3119               if (use_crc)
3120                 tpdu[tpdulen++] = (edc >> 8);
3121               tpdu[tpdulen++] = edc;
3122
3123               continue;
3124             }
3125
3126           handle->t1_nr ^= 1;
3127
3128           p = tpdu + 3; /* Skip the prologue field. */
3129           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3130           /* fixme: verify the checksum. */
3131           if (resp)
3132             {
3133               if (n > maxresplen)
3134                 {
3135                   DEBUGOUT_2 ("provided buffer too short for received data "
3136                               "(%u/%u)\n",
3137                               (unsigned int)n, (unsigned int)maxresplen);
3138                   return CCID_DRIVER_ERR_INV_VALUE;
3139                 }
3140
3141               memcpy (resp, p, n);
3142               resp += n;
3143               *nresp += n;
3144               maxresplen -= n;
3145             }
3146
3147           if (!(tpdu[1] & 0x20))
3148             return 0; /* No chaining requested - ready. */
3149
3150           msg = send_buffer;
3151           tpdu = msg + hdrlen;
3152           tpdu[0] = nad_byte;
3153           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
3154           tpdu[2] = 0;
3155           tpdulen = 3;
3156           edc = compute_edc (tpdu, tpdulen, use_crc);
3157           if (use_crc)
3158             tpdu[tpdulen++] = (edc >> 8);
3159           tpdu[tpdulen++] = edc;
3160         }
3161       else if ((tpdu[1] & 0xc0) == 0x80)
3162         { /* This is a R-block. */
3163           if ( (tpdu[1] & 0x0f))
3164             {
3165               retries++;
3166               if (via_escape && retries == 1 && (msg[pcboff] & 0x0f))
3167                 {
3168                   /* Error probably due to switching to TPDU.  Send a
3169                      resync request.  We use the recv_buffer so that
3170                      we don't corrupt the send_buffer.  */
3171                   msg = recv_buffer;
3172                   tpdu = msg + hdrlen;
3173                   tpdu[0] = nad_byte;
3174                   tpdu[1] = 0xc0; /* S-block resync request. */
3175                   tpdu[2] = 0;
3176                   tpdulen = 3;
3177                   edc = compute_edc (tpdu, tpdulen, use_crc);
3178                   if (use_crc)
3179                     tpdu[tpdulen++] = (edc >> 8);
3180                   tpdu[tpdulen++] = edc;
3181                   resyncing = 1;
3182                   DEBUGOUT ("T=1: requesting resync\n");
3183                 }
3184               else if (retries > 3)
3185                 {
3186                   DEBUGOUT ("T=1: 3 failed retries\n");
3187                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
3188                 }
3189               else
3190                 {
3191                   /* Error: repeat last block */
3192                   msg = send_buffer;
3193                   tpdulen = last_tpdulen;
3194                 }
3195             }
3196           else if (sending && !!(tpdu[1] & 0x10) == handle->t1_ns)
3197             { /* Response does not match our sequence number. */
3198               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
3199               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3200             }
3201           else if (sending)
3202             { /* Send next chunk. */
3203               retries = 0;
3204               msg = send_buffer;
3205               next_chunk = 1;
3206               handle->t1_ns ^= 1;
3207             }
3208           else
3209             {
3210               DEBUGOUT ("unexpected ACK R-block received\n");
3211               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3212             }
3213         }
3214       else
3215         { /* This is a S-block. */
3216           retries = 0;
3217           DEBUGOUT_2 ("T=1: S-block %s received cmd=%d\n",
3218                       (tpdu[1] & 0x20)? "response": "request",
3219                       (tpdu[1] & 0x1f));
3220           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 1 && tpdu[2] == 1)
3221             {
3222               /* Information field size request.  */
3223               unsigned char ifsc = tpdu[3];
3224
3225               if (ifsc < 16 || ifsc > 254)
3226                 return CCID_DRIVER_ERR_CARD_IO_ERROR;
3227
3228               msg = send_buffer;
3229               tpdu = msg + hdrlen;
3230               tpdu[0] = nad_byte;
3231               tpdu[1] = (0xc0 | 0x20 | 1); /* S-block response */
3232               tpdu[2] = 1;
3233               tpdu[3] = ifsc;
3234               tpdulen = 4;
3235               edc = compute_edc (tpdu, tpdulen, use_crc);
3236               if (use_crc)
3237                 tpdu[tpdulen++] = (edc >> 8);
3238               tpdu[tpdulen++] = edc;
3239               DEBUGOUT_1 ("T=1: requesting an ifsc=%d\n", ifsc);
3240             }
3241           else if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
3242             {
3243               /* Wait time extension request. */
3244               unsigned char bwi = tpdu[3];
3245               msg = send_buffer;
3246               tpdu = msg + hdrlen;
3247               tpdu[0] = nad_byte;
3248               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
3249               tpdu[2] = 1;
3250               tpdu[3] = bwi;
3251               tpdulen = 4;
3252               edc = compute_edc (tpdu, tpdulen, use_crc);
3253               if (use_crc)
3254                 tpdu[tpdulen++] = (edc >> 8);
3255               tpdu[tpdulen++] = edc;
3256               DEBUGOUT_1 ("T=1: waittime extension of bwi=%d\n", bwi);
3257               print_progress (handle);
3258             }
3259           else if ( (tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 0 && !tpdu[2])
3260             {
3261               DEBUGOUT ("T=1: resync ack from reader\n");
3262               /* Repeat previous block.  */
3263               msg = send_buffer;
3264               tpdulen = last_tpdulen;
3265             }
3266           else
3267             return CCID_DRIVER_ERR_CARD_IO_ERROR;
3268         }
3269     } /* end T=1 protocol loop. */
3270
3271   return 0;
3272 }
3273
3274
3275 /* Send the CCID Secure command to the reader.  APDU_BUF should
3276    contain the APDU template.  PIN_MODE defines how the pin gets
3277    formatted:
3278
3279      1 := The PIN is ASCII encoded and of variable length.  The
3280           length of the PIN entered will be put into Lc by the reader.
3281           The APDU should me made up of 4 bytes without Lc.
3282
3283    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
3284    may be used t enable reasonable defaults.
3285
3286    When called with RESP and NRESP set to NULL, the function will
3287    merely check whether the reader supports the secure command for the
3288    given APDU and PIN_MODE. */
3289 int
3290 ccid_transceive_secure (ccid_driver_t handle,
3291                         const unsigned char *apdu_buf, size_t apdu_buflen,
3292                         pininfo_t *pininfo,
3293                         unsigned char *resp, size_t maxresplen, size_t *nresp)
3294 {
3295   int rc;
3296   unsigned char send_buffer[10+259], recv_buffer[10+259];
3297   unsigned char *msg, *tpdu, *p;
3298   size_t msglen, tpdulen, n;
3299   unsigned char seqno;
3300   size_t dummy_nresp;
3301   int testmode;
3302   int cherry_mode = 0;
3303   int add_zero = 0;
3304   int enable_varlen = 0;
3305
3306   testmode = !resp && !nresp;
3307
3308   if (!nresp)
3309     nresp = &dummy_nresp;
3310   *nresp = 0;
3311
3312   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
3313     ;
3314   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
3315     ;
3316   else
3317     return CCID_DRIVER_ERR_NO_PINPAD;
3318
3319   if (!pininfo->minlen)
3320     pininfo->minlen = 1;
3321   if (!pininfo->maxlen)
3322     pininfo->maxlen = 15;
3323
3324   /* Note that the 25 is the maximum value the SPR532 allows.  */
3325   if (pininfo->minlen < 1 || pininfo->minlen > 25
3326       || pininfo->maxlen < 1 || pininfo->maxlen > 25
3327       || pininfo->minlen > pininfo->maxlen)
3328     return CCID_DRIVER_ERR_INV_VALUE;
3329
3330   /* We have only tested a few readers so better don't risk anything
3331      and do not allow the use with other readers. */
3332   switch (handle->id_vendor)
3333     {
3334     case VENDOR_SCM:  /* Tested with SPR 532. */
3335     case VENDOR_KAAN: /* Tested with KAAN Advanced (1.02). */
3336     case VENDOR_FSIJ: /* Tested with Gnuk (0.21). */
3337       pininfo->maxlen = 25;
3338       enable_varlen = 1;
3339       break;
3340     case VENDOR_REINER:/* Tested with cyberJack go */
3341     case VENDOR_VASCO: /* Tested with DIGIPASS 920 */
3342       enable_varlen = 1;
3343       break;
3344     case VENDOR_CHERRY:
3345       pininfo->maxlen = 15;
3346       enable_varlen = 1;
3347       /* The CHERRY XX44 keyboard echos an asterisk for each entered
3348          character on the keyboard channel.  We use a special variant
3349          of PC_to_RDR_Secure which directs these characters to the
3350          smart card's bulk-in channel.  We also need to append a zero
3351          Lc byte to the APDU.  It seems that it will be replaced with
3352          the actual length instead of being appended before the APDU
3353          is send to the card. */
3354       add_zero = 1;
3355       if (handle->id_product != CHERRY_ST2000)
3356         cherry_mode = 1;
3357       break;
3358     default:
3359       if ((handle->id_vendor == VENDOR_GEMPC &&
3360            handle->id_product == GEMPC_PINPAD)
3361           || (handle->id_vendor == VENDOR_VEGA &&
3362               handle->id_product == VEGA_ALPHA))
3363         {
3364           enable_varlen = 0;
3365           pininfo->minlen = 4;
3366           pininfo->maxlen = 8;
3367           break;
3368         }
3369      return CCID_DRIVER_ERR_NOT_SUPPORTED;
3370     }
3371
3372   if (enable_varlen)
3373     pininfo->fixedlen = 0;
3374
3375   if (testmode)
3376     return 0; /* Success */
3377
3378   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
3379     return CCID_DRIVER_ERR_NOT_SUPPORTED;
3380
3381   msg = send_buffer;
3382   if (handle->id_vendor == VENDOR_SCM)
3383     {
3384       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
3385       rc = send_escape_cmd (handle, (const unsigned char*)"\x80\x02\x00", 3,
3386                             NULL, 0, NULL);
3387       if (rc)
3388         return rc;
3389     }
3390
3391   msg[0] = cherry_mode? 0x89 : PC_to_RDR_Secure;
3392   msg[5] = 0; /* slot */
3393   msg[6] = seqno = handle->seqno++;
3394   msg[7] = 0; /* bBWI */
3395   msg[8] = 0; /* RFU */
3396   msg[9] = 0; /* RFU */
3397   msg[10] = apdu_buf[1] == 0x20 ? 0 : 1;
3398                /* Perform PIN verification or PIN modification. */
3399   msg[11] = 0; /* Timeout in seconds. */
3400   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
3401   if (handle->id_vendor == VENDOR_SCM)
3402     {
3403       /* For the SPR532 the next 2 bytes need to be zero.  We do this
3404          for all SCM products.  Kudos to Martin Paljak for this
3405          hint.  */
3406       msg[13] = msg[14] = 0;
3407     }
3408   else
3409     {
3410       msg[13] = pininfo->fixedlen; /* bmPINBlockString:
3411                                       0 bits of pin length to insert.
3412                                       PIN block size by fixedlen.  */
3413       msg[14] = 0x00; /* bmPINLengthFormat:
3414                          Units are bytes, position is 0. */
3415     }
3416
3417   msglen = 15;
3418   if (apdu_buf[1] == 0x24)
3419     {
3420       msg[msglen++] = 0;    /* bInsertionOffsetOld */
3421       msg[msglen++] = pininfo->fixedlen;    /* bInsertionOffsetNew */
3422     }
3423
3424   /* The following is a little endian word. */
3425   msg[msglen++] = pininfo->maxlen;   /* wPINMaxExtraDigit-Maximum.  */
3426   msg[msglen++] = pininfo->minlen;   /* wPINMaxExtraDigit-Minimum.  */
3427
3428   if (apdu_buf[1] == 0x24)
3429     msg[msglen++] = apdu_buf[2] == 0 ? 0x03 : 0x01;
3430               /* bConfirmPIN
3431                *    0x00: new PIN once
3432                *    0x01: new PIN twice (confirmation)
3433                *    0x02: old PIN and new PIN once
3434                *    0x03: old PIN and new PIN twice (confirmation)
3435                */
3436
3437   msg[msglen] = 0x02; /* bEntryValidationCondition:
3438                          Validation key pressed */
3439   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
3440     msg[msglen] |= 0x01; /* Max size reached.  */
3441   msglen++;
3442
3443   if (apdu_buf[1] == 0x20)
3444     msg[msglen++] = 0x01; /* bNumberMessage. */
3445   else
3446     msg[msglen++] = 0x03; /* bNumberMessage. */
3447
3448   msg[msglen++] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
3449   msg[msglen++] = 0x04; /* wLangId-High. */
3450
3451   if (apdu_buf[1] == 0x20)
3452     msg[msglen++] = 0;    /* bMsgIndex. */
3453   else
3454     {
3455       msg[msglen++] = 0;    /* bMsgIndex1. */
3456       msg[msglen++] = 1;    /* bMsgIndex2. */
3457       msg[msglen++] = 2;    /* bMsgIndex3. */
3458     }
3459
3460   /* Calculate Lc.  */
3461   n = pininfo->fixedlen;
3462   if (apdu_buf[1] == 0x24)
3463     n += pininfo->fixedlen;
3464
3465   /* bTeoProlog follows: */
3466   msg[msglen++] = handle->nonnull_nad? ((1 << 4) | 0): 0;
3467   msg[msglen++] = ((handle->t1_ns & 1) << 6); /* I-block */
3468   if (n)
3469     msg[msglen++] = n + 5; /* apdulen should be filled for fixed length.  */
3470   else
3471     msg[msglen++] = 0; /* The apdulen will be filled in by the reader.  */
3472   /* APDU follows:  */
3473   msg[msglen++] = apdu_buf[0]; /* CLA */
3474   msg[msglen++] = apdu_buf[1]; /* INS */
3475   msg[msglen++] = apdu_buf[2]; /* P1 */
3476   msg[msglen++] = apdu_buf[3]; /* P2 */
3477   if (add_zero)
3478     msg[msglen++] = 0;
3479   else if (pininfo->fixedlen != 0)
3480     {
3481       msg[msglen++] = n;
3482       memset (&msg[msglen], 0xff, n);
3483       msglen += n;
3484     }
3485   /* An EDC is not required. */
3486   set_msg_len (msg, msglen - 10);
3487
3488   rc = bulk_out (handle, msg, msglen, 0);
3489   if (rc)
3490     return rc;
3491
3492   msg = recv_buffer;
3493   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3494                 RDR_to_PC_DataBlock, seqno, 30000, 0);
3495   if (rc)
3496     return rc;
3497
3498   tpdu = msg + 10;
3499   tpdulen = msglen - 10;
3500
3501   if (handle->apdu_level)
3502     {
3503       if (resp)
3504         {
3505           if (tpdulen > maxresplen)
3506             {
3507               DEBUGOUT_2 ("provided buffer too short for received data "
3508                           "(%u/%u)\n",
3509                           (unsigned int)tpdulen, (unsigned int)maxresplen);
3510               return CCID_DRIVER_ERR_INV_VALUE;
3511             }
3512
3513           memcpy (resp, tpdu, tpdulen);
3514           *nresp = tpdulen;
3515         }
3516       return 0;
3517     }
3518
3519   if (tpdulen < 4)
3520     {
3521       libusb_clear_halt (handle->idev, handle->ep_bulk_in);
3522       return CCID_DRIVER_ERR_ABORTED;
3523     }
3524   if (debug_level > 1)
3525     DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3526                 ((msg[11] & 0xc0) == 0x80)? 'R' :
3527                           (msg[11] & 0x80)? 'S' : 'I',
3528                 ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
3529                 ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,