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