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