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