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