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