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