po: Update Russian translation
[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     }
1782   libusb_release_interface (handle->idev, handle->ifc_no);
1783   --ccid_usb_thread_is_alive;
1784   libusb_close (handle->idev);
1785   handle->idev = NULL;
1786 }
1787
1788
1789 int
1790 ccid_set_progress_cb (ccid_driver_t handle,
1791                       void (*cb)(void *, const char *, int, int, int),
1792                       void *cb_arg)
1793 {
1794   if (!handle)
1795     return CCID_DRIVER_ERR_INV_VALUE;
1796
1797   handle->progress_cb = cb;
1798   handle->progress_cb_arg = cb_arg;
1799   return 0;
1800 }
1801
1802
1803 /* Close the reader HANDLE. */
1804 int
1805 ccid_close_reader (ccid_driver_t handle)
1806 {
1807   if (!handle)
1808     return 0;
1809
1810   do_close_reader (handle);
1811   free (handle);
1812   return 0;
1813 }
1814
1815
1816 /* Return False if a card is present and powered. */
1817 int
1818 ccid_check_card_presence (ccid_driver_t handle)
1819 {
1820   (void)handle;  /* Not yet implemented.  */
1821   return -1;
1822 }
1823
1824
1825 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
1826    Returns 0 on success. */
1827 static int
1828 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen,
1829           int no_debug)
1830 {
1831   int rc;
1832   int transferred;
1833
1834   /* No need to continue and clutter the log with USB write error
1835      messages after we got the first ENODEV.  */
1836   if (handle->enodev_seen)
1837     return CCID_DRIVER_ERR_NO_READER;
1838
1839   if (debug_level && (!no_debug || debug_level >= 3))
1840     {
1841       switch (msglen? msg[0]:0)
1842         {
1843         case PC_to_RDR_IccPowerOn:
1844           print_p2r_iccpoweron (msg, msglen);
1845           break;
1846         case PC_to_RDR_IccPowerOff:
1847           print_p2r_iccpoweroff (msg, msglen);
1848           break;
1849         case PC_to_RDR_GetSlotStatus:
1850           print_p2r_getslotstatus (msg, msglen);
1851           break;
1852         case PC_to_RDR_XfrBlock:
1853           print_p2r_xfrblock (msg, msglen);
1854           break;
1855         case PC_to_RDR_GetParameters:
1856           print_p2r_getparameters (msg, msglen);
1857           break;
1858         case PC_to_RDR_ResetParameters:
1859           print_p2r_resetparameters (msg, msglen);
1860           break;
1861         case PC_to_RDR_SetParameters:
1862           print_p2r_setparameters (msg, msglen);
1863           break;
1864         case PC_to_RDR_Escape:
1865           print_p2r_escape (msg, msglen);
1866           break;
1867         case PC_to_RDR_IccClock:
1868           print_p2r_iccclock (msg, msglen);
1869           break;
1870         case PC_to_RDR_T0APDU:
1871           print_p2r_to0apdu (msg, msglen);
1872           break;
1873         case PC_to_RDR_Secure:
1874           print_p2r_secure (msg, msglen);
1875           break;
1876         case PC_to_RDR_Mechanical:
1877           print_p2r_mechanical (msg, msglen);
1878           break;
1879         case PC_to_RDR_Abort:
1880           print_p2r_abort (msg, msglen);
1881           break;
1882         case PC_to_RDR_SetDataRate:
1883           print_p2r_setdatarate (msg, msglen);
1884           break;
1885         default:
1886           print_p2r_unknown (msg, msglen);
1887           break;
1888         }
1889     }
1890
1891 #ifdef USE_NPTH
1892   npth_unprotect ();
1893 #endif
1894   rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
1895                              (char*)msg, msglen, &transferred,
1896                              5000 /* ms timeout */);
1897 #ifdef USE_NPTH
1898   npth_protect ();
1899 #endif
1900   if (rc == 0 && transferred == msglen)
1901     return 0;
1902
1903   if (rc)
1904     {
1905       DEBUGOUT_1 ("usb_bulk_write error: %s\n", libusb_error_name (rc));
1906       if (rc == LIBUSB_ERROR_NO_DEVICE)
1907         {
1908           handle->enodev_seen = 1;
1909           return CCID_DRIVER_ERR_NO_READER;
1910         }
1911     }
1912
1913   return 0;
1914 }
1915
1916
1917 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
1918    BUFFER and return the actual read number if bytes in NREAD. SEQNO
1919    is the sequence number used to send the request and EXPECTED_TYPE
1920    the type of message we expect. Does checks on the ccid
1921    header. TIMEOUT is the timeout value in ms. NO_DEBUG may be set to
1922    avoid debug messages in case of no error; this can be overriden
1923    with a glibal debug level of at least 3. Returns 0 on success. */
1924 static int
1925 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
1926          size_t *nread, int expected_type, int seqno, int timeout,
1927          int no_debug)
1928 {
1929   int rc;
1930   int msglen;
1931
1932   /* Fixme: The next line for the current Valgrind without support
1933      for USB IOCTLs. */
1934   memset (buffer, 0, length);
1935  retry:
1936
1937 #ifdef USE_NPTH
1938   npth_unprotect ();
1939 #endif
1940   rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
1941                              (char*)buffer, length, &msglen, timeout);
1942 #ifdef USE_NPTH
1943   npth_protect ();
1944 #endif
1945   if (rc)
1946     {
1947       DEBUGOUT_1 ("usb_bulk_read error: %s\n", libusb_error_name (rc));
1948       if (rc == LIBUSB_ERROR_NO_DEVICE)
1949         {
1950           handle->enodev_seen = 1;
1951           return CCID_DRIVER_ERR_NO_READER;
1952         }
1953
1954       return CCID_DRIVER_ERR_CARD_IO_ERROR;
1955     }
1956   if (msglen < 0)
1957     return CCID_DRIVER_ERR_INV_VALUE;  /* Faulty libusb.  */
1958   *nread = msglen;
1959
1960   if (msglen < 10)
1961     {
1962       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
1963       abort_cmd (handle, seqno);
1964       return CCID_DRIVER_ERR_INV_VALUE;
1965     }
1966   if (buffer[5] != 0)
1967     {
1968       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
1969       return CCID_DRIVER_ERR_INV_VALUE;
1970     }
1971   if (buffer[6] != seqno)
1972     {
1973       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
1974                   seqno, buffer[6]);
1975       /* Retry until we are synced again.  */
1976       goto retry;
1977     }
1978
1979   /* We need to handle the time extension request before we check that
1980      we got the expected message type.  This is in particular required
1981      for the Cherry keyboard which sends a time extension request for
1982      each key hit.  */
1983   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
1984     {
1985       /* Card present and active, time extension requested. */
1986       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
1987                   buffer[7], buffer[8]);
1988       goto retry;
1989     }
1990
1991   if (buffer[0] != expected_type && buffer[0] != RDR_to_PC_SlotStatus)
1992     {
1993       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
1994       abort_cmd (handle, seqno);
1995       return CCID_DRIVER_ERR_INV_VALUE;
1996     }
1997
1998   if (debug_level && (!no_debug || debug_level >= 3))
1999     {
2000       switch (buffer[0])
2001         {
2002         case RDR_to_PC_DataBlock:
2003           print_r2p_datablock (buffer, msglen);
2004           break;
2005         case RDR_to_PC_SlotStatus:
2006           print_r2p_slotstatus (buffer, msglen);
2007           break;
2008         case RDR_to_PC_Parameters:
2009           print_r2p_parameters (buffer, msglen);
2010           break;
2011         case RDR_to_PC_Escape:
2012           print_r2p_escape (buffer, msglen);
2013           break;
2014         case RDR_to_PC_DataRate:
2015           print_r2p_datarate (buffer, msglen);
2016           break;
2017         default:
2018           print_r2p_unknown (buffer, msglen);
2019           break;
2020         }
2021     }
2022   if (CCID_COMMAND_FAILED (buffer))
2023     print_command_failed (buffer);
2024
2025   /* Check whether a card is at all available.  Note: If you add new
2026      error codes here, check whether they need to be ignored in
2027      send_escape_cmd. */
2028   switch ((buffer[7] & 0x03))
2029     {
2030     case 0: /* no error */ break;
2031     case 1: rc = CCID_DRIVER_ERR_CARD_INACTIVE; break;
2032     case 2: rc = CCID_DRIVER_ERR_NO_CARD; break;
2033     case 3: /* RFU */ break;
2034     }
2035
2036   if (rc)
2037     {
2038       /*
2039        * Communication failure by device side.
2040        * Possibly, it was forcibly suspended and resumed.
2041        */
2042       DEBUGOUT ("CCID: card inactive/removed\n");
2043       if (handle->transfer == NULL)
2044         {
2045           handle->powered_off = 1;
2046           scd_kick_the_loop ();
2047         }
2048     }
2049
2050   return rc;
2051 }
2052
2053
2054
2055 /* Send an abort sequence and wait until everything settled.  */
2056 static int
2057 abort_cmd (ccid_driver_t handle, int seqno)
2058 {
2059   int rc;
2060   char dummybuf[8];
2061   unsigned char msg[100];
2062   int msglen;
2063
2064   seqno &= 0xff;
2065   DEBUGOUT_1 ("sending abort sequence for seqno %d\n", seqno);
2066   /* Send the abort command to the control pipe.  Note that we don't
2067      need to keep track of sent abort commands because there should
2068      never be another thread using the same slot concurrently.  */
2069 #ifdef USE_NPTH
2070   npth_unprotect ();
2071 #endif
2072   rc = libusb_control_transfer (handle->idev,
2073                                 0x21,/* bmRequestType: host-to-device,
2074                                         class specific, to interface.  */
2075                                 1,   /* ABORT */
2076                                 (seqno << 8 | 0 /* slot */),
2077                                 handle->ifc_no,
2078                                 dummybuf, 0,
2079                                 1000 /* ms timeout */);
2080 #ifdef USE_NPTH
2081   npth_protect ();
2082 #endif
2083   if (rc)
2084     {
2085       DEBUGOUT_1 ("usb_control_msg error: %s\n", libusb_error_name (rc));
2086       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2087     }
2088
2089   /* Now send the abort command to the bulk out pipe using the same
2090      SEQNO and SLOT.  Do this in a loop to so that all seqno are
2091      tried.  */
2092   seqno--;  /* Adjust for next increment.  */
2093   do
2094     {
2095       int transferred;
2096
2097       seqno++;
2098       msg[0] = PC_to_RDR_Abort;
2099       msg[5] = 0; /* slot */
2100       msg[6] = seqno;
2101       msg[7] = 0; /* RFU */
2102       msg[8] = 0; /* RFU */
2103       msg[9] = 0; /* RFU */
2104       msglen = 10;
2105       set_msg_len (msg, 0);
2106
2107 #ifdef USE_NPTH
2108       npth_unprotect ();
2109 #endif
2110       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
2111                                  (char*)msg, msglen, &transferred,
2112                                  5000 /* ms timeout */);
2113 #ifdef USE_NPTH
2114       npth_protect ();
2115 #endif
2116       if (rc == 0 && transferred == msglen)
2117         rc = 0;
2118       else if (rc)
2119         DEBUGOUT_1 ("usb_bulk_write error in abort_cmd: %s\n",
2120                     libusb_error_name (rc));
2121
2122       if (rc)
2123         return rc;
2124
2125 #ifdef USE_NPTH
2126       npth_unprotect ();
2127 #endif
2128       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
2129                                  (char*)msg, sizeof msg, &msglen,
2130                                  5000 /*ms timeout*/);
2131 #ifdef USE_NPTH
2132       npth_protect ();
2133 #endif
2134       if (rc)
2135         {
2136           DEBUGOUT_1 ("usb_bulk_read error in abort_cmd: %s\n",
2137                       libusb_error_name (rc));
2138           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2139         }
2140
2141       if (msglen < 10)
2142         {
2143           DEBUGOUT_1 ("bulk-in msg in abort_cmd too short (%u)\n",
2144                       (unsigned int)msglen);
2145           return CCID_DRIVER_ERR_INV_VALUE;
2146         }
2147       if (msg[5] != 0)
2148         {
2149           DEBUGOUT_1 ("unexpected bulk-in slot (%d) in abort_cmd\n", msg[5]);
2150           return CCID_DRIVER_ERR_INV_VALUE;
2151         }
2152
2153       DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n",
2154                   msg[7], msg[8], msg[9]);
2155       if (CCID_COMMAND_FAILED (msg))
2156         print_command_failed (msg);
2157     }
2158   while (msg[0] != RDR_to_PC_SlotStatus && msg[5] != 0 && msg[6] != seqno);
2159
2160   handle->seqno = ((seqno + 1) & 0xff);
2161   DEBUGOUT ("sending abort sequence succeeded\n");
2162
2163   return 0;
2164 }
2165
2166
2167 /* Note that this function won't return the error codes NO_CARD or
2168    CARD_INACTIVE.  IF RESULT is not NULL, the result from the
2169    operation will get returned in RESULT and its length in RESULTLEN.
2170    If the response is larger than RESULTMAX, an error is returned and
2171    the required buffer length returned in RESULTLEN.  */
2172 static int
2173 send_escape_cmd (ccid_driver_t handle,
2174                  const unsigned char *data, size_t datalen,
2175                  unsigned char *result, size_t resultmax, size_t *resultlen)
2176 {
2177   int rc;
2178   unsigned char msg[100];
2179   size_t msglen;
2180   unsigned char seqno;
2181
2182   if (resultlen)
2183     *resultlen = 0;
2184
2185   if (datalen > sizeof msg - 10)
2186     return CCID_DRIVER_ERR_INV_VALUE; /* Escape data too large.  */
2187
2188   msg[0] = PC_to_RDR_Escape;
2189   msg[5] = 0; /* slot */
2190   msg[6] = seqno = handle->seqno++;
2191   msg[7] = 0; /* RFU */
2192   msg[8] = 0; /* RFU */
2193   msg[9] = 0; /* RFU */
2194   memcpy (msg+10, data, datalen);
2195   msglen = 10 + datalen;
2196   set_msg_len (msg, datalen);
2197
2198   rc = bulk_out (handle, msg, msglen, 0);
2199   if (rc)
2200     return rc;
2201   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Escape,
2202                 seqno, 5000, 0);
2203   if (result)
2204     switch (rc)
2205       {
2206         /* We need to ignore certain errorcode here. */
2207       case 0:
2208       case CCID_DRIVER_ERR_CARD_INACTIVE:
2209       case CCID_DRIVER_ERR_NO_CARD:
2210         {
2211           if (msglen > resultmax)
2212             rc = CCID_DRIVER_ERR_INV_VALUE; /* Response too large. */
2213           else
2214             {
2215               memcpy (result, msg, msglen);
2216               if (resultlen)
2217                 *resultlen = msglen;
2218               rc = 0;
2219             }
2220         }
2221         break;
2222       default:
2223         break;
2224       }
2225
2226   return rc;
2227 }
2228
2229
2230 int
2231 ccid_transceive_escape (ccid_driver_t handle,
2232                         const unsigned char *data, size_t datalen,
2233                         unsigned char *resp, size_t maxresplen, size_t *nresp)
2234 {
2235   return send_escape_cmd (handle, data, datalen, resp, maxresplen, nresp);
2236 }
2237
2238
2239
2240 /* experimental */
2241 int
2242 ccid_poll (ccid_driver_t handle)
2243 {
2244   int rc;
2245   unsigned char msg[10];
2246   int msglen;
2247   int i, j;
2248
2249   rc = libusb_interrupt_transfer (handle->idev, handle->ep_intr,
2250                                   (char*)msg, sizeof msg, &msglen,
2251                                   0 /* ms timeout */ );
2252   if (rc == LIBUSB_ERROR_TIMEOUT)
2253     return 0;
2254
2255   if (rc)
2256     {
2257       DEBUGOUT_1 ("usb_intr_read error: %s\n", libusb_error_name (rc));
2258       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2259     }
2260
2261   if (msglen < 1)
2262     {
2263       DEBUGOUT ("intr-in msg too short\n");
2264       return CCID_DRIVER_ERR_INV_VALUE;
2265     }
2266
2267   if (msg[0] == RDR_to_PC_NotifySlotChange)
2268     {
2269       DEBUGOUT ("notify slot change:");
2270       for (i=1; i < msglen; i++)
2271         for (j=0; j < 4; j++)
2272           DEBUGOUT_CONT_3 (" %d:%c%c",
2273                            (i-1)*4+j,
2274                            (msg[i] & (1<<(j*2)))? 'p':'-',
2275                            (msg[i] & (2<<(j*2)))? '*':' ');
2276       DEBUGOUT_LF ();
2277     }
2278   else if (msg[0] == RDR_to_PC_HardwareError)
2279     {
2280       DEBUGOUT ("hardware error occurred\n");
2281     }
2282   else
2283     {
2284       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
2285     }
2286
2287   return 0;
2288 }
2289
2290
2291 /* Note that this function won't return the error codes NO_CARD or
2292    CARD_INACTIVE */
2293 int
2294 ccid_slot_status (ccid_driver_t handle, int *statusbits, int on_wire)
2295 {
2296   int rc;
2297   unsigned char msg[100];
2298   size_t msglen;
2299   unsigned char seqno;
2300   int retries = 0;
2301
2302   if (handle->powered_off)
2303     return CCID_DRIVER_ERR_NO_READER;
2304
2305   /* If the card (with its lower-level driver) doesn't require
2306      GET_STATUS on wire (because it supports INTERRUPT transfer for
2307      status change, or it's a token which has a card always inserted),
2308      no need to send on wire.  */
2309   if (!on_wire && !ccid_require_get_status (handle))
2310     {
2311       /* Setup interrupt transfer at the initial call of slot_status
2312          with ON_WIRE == 0 */
2313       if (handle->transfer == NULL && handle->ep_intr >= 0)
2314         ccid_setup_intr (handle);
2315
2316       *statusbits = 0;
2317       return 0;
2318     }
2319
2320  retry:
2321   msg[0] = PC_to_RDR_GetSlotStatus;
2322   msg[5] = 0; /* slot */
2323   msg[6] = seqno = handle->seqno++;
2324   msg[7] = 0; /* RFU */
2325   msg[8] = 0; /* RFU */
2326   msg[9] = 0; /* RFU */
2327   set_msg_len (msg, 0);
2328
2329   rc = bulk_out (handle, msg, 10, 1);
2330   if (rc)
2331     return rc;
2332   /* Note that we set the NO_DEBUG flag here, so that the logs won't
2333      get cluttered up by a ticker function checking for the slot
2334      status and debugging enabled. */
2335   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
2336                 seqno, retries? 1000 : 200, 1);
2337   if (rc == CCID_DRIVER_ERR_CARD_IO_ERROR && retries < 3)
2338     {
2339       if (!retries)
2340         {
2341           DEBUGOUT ("USB: CALLING USB_CLEAR_HALT\n");
2342 #ifdef USE_NPTH
2343           npth_unprotect ();
2344 #endif
2345           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
2346           libusb_clear_halt (handle->idev, handle->ep_bulk_out);
2347 #ifdef USE_NPTH
2348           npth_protect ();
2349 #endif
2350         }
2351       else
2352           DEBUGOUT ("USB: RETRYING bulk_in AGAIN\n");
2353       retries++;
2354       goto retry;
2355     }
2356   if (rc && rc != CCID_DRIVER_ERR_NO_CARD && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
2357     return rc;
2358   *statusbits = (msg[7] & 3);
2359
2360   return 0;
2361 }
2362
2363
2364 /* Parse ATR string (of ATRLEN) and update parameters at PARAM.
2365    Calling this routine, it should prepare default values at PARAM
2366    beforehand.  This routine assumes that card is accessed by T=1
2367    protocol.  It doesn't analyze historical bytes at all.
2368
2369    Returns < 0 value on error:
2370      -1 for parse error or integrity check error
2371      -2 for card doesn't support T=1 protocol
2372      -3 for parameters are nod explicitly defined by ATR
2373      -4 for this driver doesn't support CRC
2374
2375    Returns >= 0 on success:
2376       0 for card is negotiable mode
2377       1 for card is specific mode (and not negotiable)
2378  */
2379 static int
2380 update_param_by_atr (unsigned char *param, unsigned char *atr, size_t atrlen)
2381 {
2382   int i = -1;
2383   int t, y, chk;
2384   int historical_bytes_num, negotiable = 1;
2385
2386 #define NEXTBYTE() do { i++; if (atrlen <= i) return -1; } while (0)
2387
2388   NEXTBYTE ();
2389
2390   if (atr[i] == 0x3F)
2391     param[1] |= 0x02;           /* Convention is inverse.  */
2392   NEXTBYTE ();
2393
2394   y = (atr[i] >> 4);
2395   historical_bytes_num = atr[i] & 0x0f;
2396   NEXTBYTE ();
2397
2398   if ((y & 1))
2399     {
2400       param[0] = atr[i];        /* TA1 - Fi & Di */
2401       NEXTBYTE ();
2402     }
2403
2404   if ((y & 2))
2405     NEXTBYTE ();                /* TB1 - ignore */
2406
2407   if ((y & 4))
2408     {
2409       param[2] = atr[i];        /* TC1 - Guard Time */
2410       NEXTBYTE ();
2411     }
2412
2413   if ((y & 8))
2414     {
2415       y = (atr[i] >> 4);        /* TD1 */
2416       t = atr[i] & 0x0f;
2417       NEXTBYTE ();
2418
2419       if ((y & 1))
2420         {                       /* TA2 - PPS mode */
2421           if ((atr[i] & 0x0f) != 1)
2422             return -2;          /* Wrong card protocol (!= 1).  */
2423
2424           if ((atr[i] & 0x10) != 0x10)
2425             return -3; /* Transmission parameters are implicitly defined. */
2426
2427           negotiable = 0;       /* TA2 means specific mode.  */
2428           NEXTBYTE ();
2429         }
2430
2431       if ((y & 2))
2432         NEXTBYTE ();            /* TB2 - ignore */
2433
2434       if ((y & 4))
2435         NEXTBYTE ();            /* TC2 - ignore */
2436
2437       if ((y & 8))
2438         {
2439           y = (atr[i] >> 4);    /* TD2 */
2440           t = atr[i] & 0x0f;
2441           NEXTBYTE ();
2442         }
2443       else
2444         y = 0;
2445
2446       while (y)
2447         {
2448           if ((y & 1))
2449             {                   /* TAx */
2450               if (t == 1)
2451                 param[5] = atr[i]; /* IFSC */
2452               else if (t == 15)
2453                 /* XXX: check voltage? */
2454                 param[4] = (atr[i] >> 6); /* ClockStop */
2455
2456               NEXTBYTE ();
2457             }
2458
2459           if ((y & 2))
2460             {
2461               if (t == 1)
2462                 param[3] = atr[i]; /* TBx - BWI & CWI */
2463               NEXTBYTE ();
2464             }
2465
2466           if ((y & 4))
2467             {
2468               if (t == 1)
2469                 param[1] |= (atr[i] & 0x01); /* TCx - LRC/CRC */
2470               NEXTBYTE ();
2471
2472               if (param[1] & 0x01)
2473                 return -4;      /* CRC not supported yet.  */
2474             }
2475
2476           if ((y & 8))
2477             {
2478               y = (atr[i] >> 4); /* TDx */
2479               t = atr[i] & 0x0f;
2480               NEXTBYTE ();
2481             }
2482           else
2483             y = 0;
2484         }
2485     }
2486
2487   i += historical_bytes_num - 1;
2488   NEXTBYTE ();
2489   if (atrlen != i+1)
2490     return -1;
2491
2492 #undef NEXTBYTE
2493
2494   chk = 0;
2495   do
2496     {
2497       chk ^= atr[i];
2498       i--;
2499     }
2500   while (i > 0);
2501
2502   if (chk != 0)
2503     return -1;
2504
2505   return negotiable;
2506 }
2507
2508
2509 /* Return the ATR of the card.  This is not a cached value and thus an
2510    actual reset is done.  */
2511 int
2512 ccid_get_atr (ccid_driver_t handle,
2513               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
2514 {
2515   int rc;
2516   int statusbits;
2517   unsigned char msg[100];
2518   unsigned char *tpdu;
2519   size_t msglen, tpdulen;
2520   unsigned char seqno;
2521   int use_crc = 0;
2522   unsigned int edc;
2523   int tried_iso = 0;
2524   int got_param;
2525   unsigned char param[7] = { /* For Protocol T=1 */
2526     0x11, /* bmFindexDindex */
2527     0x10, /* bmTCCKST1 */
2528     0x00, /* bGuardTimeT1 */
2529     0x4d, /* bmWaitingIntegersT1 */
2530     0x00, /* bClockStop */
2531     0x20, /* bIFSC */
2532     0x00  /* bNadValue */
2533   };
2534
2535   /* First check whether a card is available.  */
2536   rc = ccid_slot_status (handle, &statusbits, 1);
2537   if (rc)
2538     return rc;
2539   if (statusbits == 2)
2540     return CCID_DRIVER_ERR_NO_CARD;
2541
2542   /* For an inactive and also for an active card, issue the PowerOn
2543      command to get the ATR.  */
2544  again:
2545   msg[0] = PC_to_RDR_IccPowerOn;
2546   msg[5] = 0; /* slot */
2547   msg[6] = seqno = handle->seqno++;
2548   /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
2549   msg[7] = handle->auto_voltage ? 0 : 1;
2550   msg[8] = 0; /* RFU */
2551   msg[9] = 0; /* RFU */
2552   set_msg_len (msg, 0);
2553   msglen = 10;
2554
2555   rc = bulk_out (handle, msg, msglen, 0);
2556   if (rc)
2557     return rc;
2558   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2559                 seqno, 5000, 0);
2560   if (rc)
2561     return rc;
2562   if (!tried_iso && CCID_COMMAND_FAILED (msg) && CCID_ERROR_CODE (msg) == 0xbb
2563       && ((handle->id_vendor == VENDOR_CHERRY
2564            && handle->id_product == 0x0005)
2565           || (handle->id_vendor == VENDOR_GEMPC
2566               && handle->id_product == 0x4433)
2567           ))
2568     {
2569       tried_iso = 1;
2570       /* Try switching to ISO mode. */
2571       if (!send_escape_cmd (handle, (const unsigned char*)"\xF1\x01", 2,
2572                             NULL, 0, NULL))
2573         goto again;
2574     }
2575   else if (CCID_COMMAND_FAILED (msg))
2576     return CCID_DRIVER_ERR_CARD_IO_ERROR;
2577
2578
2579   handle->powered_off = 0;
2580
2581   if (atr)
2582     {
2583       size_t n = msglen - 10;
2584
2585       if (n > maxatrlen)
2586         n = maxatrlen;
2587       memcpy (atr, msg+10, n);
2588       *atrlen = n;
2589     }
2590
2591   param[6] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2592   rc = update_param_by_atr (param, msg+10, msglen - 10);
2593   if (rc < 0)
2594     {
2595       DEBUGOUT_1 ("update_param_by_atr failed: %d\n", rc);
2596       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2597     }
2598
2599   got_param = 0;
2600
2601   if (handle->auto_param)
2602     {
2603       msg[0] = PC_to_RDR_GetParameters;
2604       msg[5] = 0; /* slot */
2605       msg[6] = seqno = handle->seqno++;
2606       msg[7] = 0; /* RFU */
2607       msg[8] = 0; /* RFU */
2608       msg[9] = 0; /* RFU */
2609       set_msg_len (msg, 0);
2610       msglen = 10;
2611       rc = bulk_out (handle, msg, msglen, 0);
2612       if (!rc)
2613         rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2614                       seqno, 2000, 0);
2615       if (rc)
2616         DEBUGOUT ("GetParameters failed\n");
2617       else if (msglen == 17 && msg[9] == 1)
2618         got_param = 1;
2619     }
2620   else if (handle->auto_pps)
2621     ;
2622   else if (rc == 1)             /* It's negotiable, send PPS.  */
2623     {
2624       msg[0] = PC_to_RDR_XfrBlock;
2625       msg[5] = 0; /* slot */
2626       msg[6] = seqno = handle->seqno++;
2627       msg[7] = 0;
2628       msg[8] = 0;
2629       msg[9] = 0;
2630       msg[10] = 0xff;           /* PPSS */
2631       msg[11] = 0x11;           /* PPS0: PPS1, Protocol T=1 */
2632       msg[12] = param[0];       /* PPS1: Fi / Di */
2633       msg[13] = 0xff ^ 0x11 ^ param[0]; /* PCK */
2634       set_msg_len (msg, 4);
2635       msglen = 10 + 4;
2636
2637       rc = bulk_out (handle, msg, msglen, 0);
2638       if (rc)
2639         return rc;
2640
2641       rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2642                     seqno, 5000, 0);
2643       if (rc)
2644         return rc;
2645
2646       if (msglen != 10 + 4)
2647         {
2648           DEBUGOUT_1 ("Setting PPS failed: %zu\n", msglen);
2649           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2650         }
2651
2652       if (msg[10] != 0xff || msg[11] != 0x11 || msg[12] != param[0])
2653         {
2654           DEBUGOUT_1 ("Setting PPS failed: 0x%02x\n", param[0]);
2655           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2656         }
2657     }
2658
2659   /* Setup parameters to select T=1. */
2660   msg[0] = PC_to_RDR_SetParameters;
2661   msg[5] = 0; /* slot */
2662   msg[6] = seqno = handle->seqno++;
2663   msg[7] = 1; /* Select T=1. */
2664   msg[8] = 0; /* RFU */
2665   msg[9] = 0; /* RFU */
2666
2667   if (!got_param)
2668     memcpy (&msg[10], param, 7);
2669   set_msg_len (msg, 7);
2670   msglen = 10 + 7;
2671
2672   rc = bulk_out (handle, msg, msglen, 0);
2673   if (rc)
2674     return rc;
2675   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2676                 seqno, 5000, 0);
2677   if (rc)
2678     DEBUGOUT ("SetParameters failed (ignored)\n");
2679
2680   if (!rc && msglen > 15 && msg[15] >= 16 && msg[15] <= 254 )
2681     handle->ifsc = msg[15];
2682   else
2683     handle->ifsc = 128; /* Something went wrong, assume 128 bytes.  */
2684
2685   if (handle->nonnull_nad && msglen > 16 && msg[16] == 0)
2686     {
2687       DEBUGOUT ("Use Null-NAD, clearing handle->nonnull_nad.\n");
2688       handle->nonnull_nad = 0;
2689     }
2690
2691   handle->t1_ns = 0;
2692   handle->t1_nr = 0;
2693
2694   /* Send an S-Block with our maximum IFSD to the CCID.  */
2695   if (!handle->apdu_level && !handle->auto_ifsd)
2696     {
2697       tpdu = msg+10;
2698       /* NAD: DAD=1, SAD=0 */
2699       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2700       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
2701       tpdu[2] = 1;
2702       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32;
2703       tpdulen = 4;
2704       edc = compute_edc (tpdu, tpdulen, use_crc);
2705       if (use_crc)
2706         tpdu[tpdulen++] = (edc >> 8);
2707       tpdu[tpdulen++] = edc;
2708
2709       msg[0] = PC_to_RDR_XfrBlock;
2710       msg[5] = 0; /* slot */
2711       msg[6] = seqno = handle->seqno++;
2712       msg[7] = 0;
2713       msg[8] = 0; /* RFU */
2714       msg[9] = 0; /* RFU */
2715       set_msg_len (msg, tpdulen);
2716       msglen = 10 + tpdulen;
2717
2718       if (debug_level > 1)
2719         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
2720                       ((msg[11] & 0xc0) == 0x80)? 'R' :
2721                                 (msg[11] & 0x80)? 'S' : 'I',
2722                       ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2723                                        : !!(msg[11] & 0x40)),
2724                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2725
2726       rc = bulk_out (handle, msg, msglen, 0);
2727       if (rc)
2728         return rc;
2729
2730
2731       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2732                     RDR_to_PC_DataBlock, seqno, 5000, 0);
2733       if (rc)
2734         return rc;
2735
2736       tpdu = msg + 10;
2737       tpdulen = msglen - 10;
2738
2739       if (tpdulen < 4)
2740         return CCID_DRIVER_ERR_ABORTED;
2741
2742       if (debug_level > 1)
2743         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
2744                     ((msg[11] & 0xc0) == 0x80)? 'R' :
2745                               (msg[11] & 0x80)? 'S' : 'I',
2746                     ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2747                                      : !!(msg[11] & 0x40)),
2748                     ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
2749                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2750
2751       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
2752         {
2753           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
2754           return -1;
2755         }
2756       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
2757     }
2758
2759   return 0;
2760 }
2761
2762
2763 \f
2764
2765 static unsigned int
2766 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
2767 {
2768   if (use_crc)
2769     {
2770       return 0x42; /* Not yet implemented. */
2771     }
2772   else
2773     {
2774       unsigned char crc = 0;
2775
2776       for (; datalen; datalen--)
2777         crc ^= *data++;
2778       return crc;
2779     }
2780 }
2781
2782
2783 /* Return true if APDU is an extended length one.  */
2784 static int
2785 is_exlen_apdu (const unsigned char *apdu, size_t apdulen)
2786 {
2787   if (apdulen < 7 || apdu[4])
2788     return 0;  /* Too short or no Z byte.  */
2789   return 1;
2790 }
2791
2792
2793 /* Helper for ccid_transceive used for APDU level exchanges.  */
2794 static int
2795 ccid_transceive_apdu_level (ccid_driver_t handle,
2796                             const unsigned char *apdu_buf, size_t apdu_len,
2797                             unsigned char *resp, size_t maxresplen,
2798                             size_t *nresp)
2799 {
2800   int rc;
2801   unsigned char msg[CCID_MAX_BUF];
2802   const unsigned char *apdu_p;
2803   size_t apdu_part_len;
2804   size_t msglen;
2805   unsigned char seqno;
2806   int bwi = 4;
2807   unsigned char chain = 0;
2808
2809   if (apdu_len == 0 || apdu_len > sizeof (msg) - 10)
2810     return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
2811
2812   apdu_p = apdu_buf;
2813   while (1)
2814     {
2815       apdu_part_len = apdu_len;
2816       if (apdu_part_len > handle->max_ccid_msglen - 10)
2817         {
2818           apdu_part_len = handle->max_ccid_msglen - 10;
2819           chain |= 0x01;
2820         }
2821
2822       msg[0] = PC_to_RDR_XfrBlock;
2823       msg[5] = 0; /* slot */
2824       msg[6] = seqno = handle->seqno++;
2825       msg[7] = bwi;
2826       msg[8] = chain;
2827       msg[9] = 0;
2828       memcpy (msg+10, apdu_p, apdu_part_len);
2829       set_msg_len (msg, apdu_part_len);
2830       msglen = 10 + apdu_part_len;
2831
2832       rc = bulk_out (handle, msg, msglen, 0);
2833       if (rc)
2834         return rc;
2835
2836       apdu_p += apdu_part_len;
2837       apdu_len -= apdu_part_len;
2838
2839       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2840                     RDR_to_PC_DataBlock, seqno, CCID_CMD_TIMEOUT, 0);
2841       if (rc)
2842         return rc;
2843
2844       if (!(chain & 0x01))
2845         break;
2846
2847       chain = 0x02;
2848     }
2849
2850   apdu_len = 0;
2851   while (1)
2852     {
2853       apdu_part_len = msglen - 10;
2854       if (resp && apdu_len + apdu_part_len <= maxresplen)
2855         memcpy (resp + apdu_len, msg+10, apdu_part_len);
2856       apdu_len += apdu_part_len;
2857
2858       if (!(msg[9] & 0x01))
2859         break;
2860
2861       msg[0] = PC_to_RDR_XfrBlock;
2862       msg[5] = 0; /* slot */
2863       msg[6] = seqno = handle->seqno++;
2864       msg[7] = bwi;
2865       msg[8] = 0x10;                /* Request next data block */
2866       msg[9] = 0;
2867       set_msg_len (msg, 0);
2868       msglen = 10;
2869
2870       rc = bulk_out (handle, msg, msglen, 0);
2871       if (rc)
2872         return rc;
2873
2874       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2875                     RDR_to_PC_DataBlock, seqno, CCID_CMD_TIMEOUT, 0);
2876       if (rc)
2877         return rc;
2878     }
2879
2880   if (resp)
2881     {
2882       if (apdu_len > maxresplen)
2883         {
2884           DEBUGOUT_2 ("provided buffer too short for received data "
2885                       "(%u/%u)\n",
2886                       (unsigned int)apdu_len, (unsigned int)maxresplen);
2887           return CCID_DRIVER_ERR_INV_VALUE;
2888         }
2889
2890       *nresp = apdu_len;
2891     }
2892
2893   return 0;
2894 }
2895
2896
2897
2898 /*
2899   Protocol T=1 overview
2900
2901   Block Structure:
2902            Prologue Field:
2903    1 byte     Node Address (NAD)
2904    1 byte     Protocol Control Byte (PCB)
2905    1 byte     Length (LEN)
2906            Information Field:
2907    0-254 byte APDU or Control Information (INF)
2908            Epilogue Field:
2909    1 byte     Error Detection Code (EDC)
2910
2911   NAD:
2912    bit 7     unused
2913    bit 4..6  Destination Node Address (DAD)
2914    bit 3     unused
2915    bit 2..0  Source Node Address (SAD)
2916
2917    If node adresses are not used, SAD and DAD should be set to 0 on
2918    the first block sent to the card.  If they are used they should
2919    have different values (0 for one is okay); that first block sets up
2920    the addresses of the nodes.
2921
2922   PCB:
2923    Information Block (I-Block):
2924       bit 7    0
2925       bit 6    Sequence number (yep, that is modulo 2)
2926       bit 5    Chaining flag
2927       bit 4..0 reserved
2928    Received-Ready Block (R-Block):
2929       bit 7    1
2930       bit 6    0
2931       bit 5    0
2932       bit 4    Sequence number
2933       bit 3..0  0 = no error
2934                 1 = EDC or parity error
2935                 2 = other error
2936                 other values are reserved
2937    Supervisory Block (S-Block):
2938       bit 7    1
2939       bit 6    1
2940       bit 5    clear=request,set=response
2941       bit 4..0  0 = resyncronisation request
2942                 1 = information field size request
2943                 2 = abort request
2944                 3 = extension of BWT request
2945                 4 = VPP error
2946                 other values are reserved
2947
2948 */
2949
2950 int
2951 ccid_transceive (ccid_driver_t handle,
2952                  const unsigned char *apdu_buf, size_t apdu_buflen,
2953                  unsigned char *resp, size_t maxresplen, size_t *nresp)
2954 {
2955   int rc;
2956   /* The size of the buffer used to be 10+259.  For the via_escape
2957      hack we need one extra byte, thus 11+259.  */
2958   unsigned char send_buffer[11+259], recv_buffer[11+259];
2959   const unsigned char *apdu;
2960   size_t apdulen;
2961   unsigned char *msg, *tpdu, *p;
2962   size_t msglen, tpdulen, last_tpdulen, n;
2963   unsigned char seqno;
2964   unsigned int edc;
2965   int use_crc = 0;
2966   int hdrlen, pcboff;
2967   size_t dummy_nresp;
2968   int via_escape = 0;
2969   int next_chunk = 1;
2970   int sending = 1;
2971   int retries = 0;
2972   int resyncing = 0;
2973   int nad_byte;
2974   int wait_more = 0;
2975
2976   if (!nresp)
2977     nresp = &dummy_nresp;
2978   *nresp = 0;
2979
2980   /* Smarter readers allow sending APDUs directly; divert here. */
2981   if (handle->apdu_level)
2982     {
2983       /* We employ a hack for Omnikey readers which are able to send
2984          TPDUs using an escape sequence.  There is no documentation
2985          but the Windows driver does it this way.  Tested using a
2986          CM6121.  This method works also for the Cherry XX44
2987          keyboards; however there are problems with the
2988          ccid_transceive_secure which leads to a loss of sync on the
2989          CCID level.  If Cherry wants to make their keyboard work
2990          again, they should hand over some docs. */
2991       if ((handle->id_vendor == VENDOR_OMNIKEY)
2992           && handle->apdu_level < 2
2993           && is_exlen_apdu (apdu_buf, apdu_buflen))
2994         via_escape = 1;
2995       else
2996         return ccid_transceive_apdu_level (handle, apdu_buf, apdu_buflen,
2997                                            resp, maxresplen, nresp);
2998     }
2999
3000   /* The other readers we support require sending TPDUs.  */
3001
3002   tpdulen = 0; /* Avoid compiler warning about no initialization. */
3003   msg = send_buffer;
3004   hdrlen = via_escape? 11 : 10;
3005
3006   /* NAD: DAD=1, SAD=0 */
3007   nad_byte = handle->nonnull_nad? ((1 << 4) | 0): 0;
3008   if (via_escape)
3009     nad_byte = 0;
3010
3011   last_tpdulen = 0;  /* Avoid gcc warning (controlled by RESYNCING). */
3012   for (;;)
3013     {
3014       if (next_chunk)
3015         {
3016           next_chunk = 0;
3017
3018           apdu = apdu_buf;
3019           apdulen = apdu_buflen;
3020           assert (apdulen);
3021
3022           /* Construct an I-Block. */
3023           tpdu = msg + hdrlen;
3024           tpdu[0] = nad_byte;
3025           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
3026           if (apdulen > handle->ifsc )
3027             {
3028               apdulen = handle->ifsc;
3029               apdu_buf += handle->ifsc;
3030               apdu_buflen -= handle->ifsc;
3031               tpdu[1] |= (1 << 5); /* Set more bit. */
3032             }
3033           tpdu[2] = apdulen;
3034           memcpy (tpdu+3, apdu, apdulen);
3035           tpdulen = 3 + apdulen;
3036           edc = compute_edc (tpdu, tpdulen, use_crc);
3037           if (use_crc)
3038             tpdu[tpdulen++] = (edc >> 8);
3039           tpdu[tpdulen++] = edc;
3040         }
3041
3042       if (via_escape)
3043         {
3044           msg[0] = PC_to_RDR_Escape;
3045           msg[5] = 0; /* slot */
3046           msg[6] = seqno = handle->seqno++;
3047           msg[7] = 0; /* RFU */
3048           msg[8] = 0; /* RFU */
3049           msg[9] = 0; /* RFU */
3050           msg[10] = 0x1a; /* Omnikey command to send a TPDU.  */
3051           set_msg_len (msg, 1 + tpdulen);
3052         }
3053       else
3054         {
3055           msg[0] = PC_to_RDR_XfrBlock;
3056           msg[5] = 0; /* slot */
3057           msg[6] = seqno = handle->seqno++;
3058           msg[7] = 4; /* bBWI */
3059           msg[8] = 0; /* RFU */
3060           msg[9] = 0; /* RFU */
3061           set_msg_len (msg, tpdulen);
3062         }
3063       msglen = hdrlen + tpdulen;
3064       if (!resyncing)
3065         last_tpdulen = tpdulen;
3066       pcboff = hdrlen+1;
3067
3068       if (debug_level > 1)
3069         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
3070                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3071                     (msg[pcboff] & 0x80)? 'S' : 'I',
3072                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3073                      : !!(msg[pcboff] & 0x40)),
3074                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3075                      " [more]":""));
3076
3077       rc = bulk_out (handle, msg, msglen, 0);
3078       if (rc)
3079         return rc;
3080
3081       msg = recv_buffer;
3082       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3083                     via_escape? RDR_to_PC_Escape : RDR_to_PC_DataBlock, seqno,
3084                     wait_more? CCID_CMD_TIMEOUT_LONGER: CCID_CMD_TIMEOUT, 0);
3085       if (rc)
3086         return rc;
3087
3088       tpdu = msg + hdrlen;
3089       tpdulen = msglen - hdrlen;
3090       resyncing = 0;
3091
3092       if (tpdulen < 4)
3093         {
3094 #ifdef USE_NPTH
3095           npth_unprotect ();
3096 #endif
3097           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
3098 #ifdef USE_NPTH
3099           npth_protect ();
3100 #endif
3101           return CCID_DRIVER_ERR_ABORTED;
3102         }
3103
3104       if (debug_level > 1)
3105         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3106                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3107                               (msg[pcboff] & 0x80)? 'S' : 'I',
3108                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3109                      : !!(msg[pcboff] & 0x40)),
3110                     ((msg[pcboff] & 0xc0) == 0x80)? (msg[pcboff] & 0x0f) : 0,
3111                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3112                      " [more]":""));
3113
3114       if (!(tpdu[1] & 0x80))
3115         { /* This is an I-block. */
3116           retries = 0;
3117           if (sending)
3118             { /* last block sent was successful. */
3119               handle->t1_ns ^= 1;
3120               sending = 0;
3121             }
3122
3123           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3124             { /* Response does not match our sequence number. */
3125               msg = send_buffer;
3126               tpdu = msg + hdrlen;
3127               tpdu[0] = nad_byte;
3128               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
3129               tpdu[2] = 0;
3130               tpdulen = 3;
3131               edc = compute_edc (tpdu, tpdulen, use_crc);
3132               if (use_crc)
3133                 tpdu[tpdulen++] = (edc >> 8);
3134               tpdu[tpdulen++] = edc;
3135
3136               continue;
3137             }
3138
3139           handle->t1_nr ^= 1;
3140
3141           p = tpdu + 3; /* Skip the prologue field. */
3142           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3143           /* fixme: verify the checksum. */
3144           if (resp)
3145             {
3146               if (n > maxresplen)
3147                 {
3148                   DEBUGOUT_2 ("provided buffer too short for received data "
3149                               "(%u/%u)\n",
3150                               (unsigned int)n, (unsigned int)maxresplen);
3151                   return CCID_DRIVER_ERR_INV_VALUE;
3152                 }
3153
3154               memcpy (resp, p, n);
3155               resp += n;
3156               *nresp += n;
3157               maxresplen -= n;
3158             }
3159
3160           if (!(tpdu[1] & 0x20))
3161             return 0; /* No chaining requested - ready. */
3162
3163           msg = send_buffer;
3164           tpdu = msg + hdrlen;
3165           tpdu[0] = nad_byte;
3166           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
3167           tpdu[2] = 0;
3168           tpdulen = 3;
3169           edc = compute_edc (tpdu, tpdulen, use_crc);
3170           if (use_crc)
3171             tpdu[tpdulen++] = (edc >> 8);
3172           tpdu[tpdulen++] = edc;
3173         }
3174       else if ((tpdu[1] & 0xc0) == 0x80)
3175         { /* This is a R-block. */
3176           if ( (tpdu[1] & 0x0f))
3177             {
3178               retries++;
3179               if (via_escape && retries == 1 && (msg[pcboff] & 0x0f))
3180                 {
3181                   /* Error probably due to switching to TPDU.  Send a
3182                      resync request.  We use the recv_buffer so that
3183                      we don't corrupt the send_buffer.  */
3184                   msg = recv_buffer;
3185                   tpdu = msg + hdrlen;
3186                   tpdu[0] = nad_byte;
3187                   tpdu[1] = 0xc0; /* S-block resync request. */
3188                   tpdu[2] = 0;
3189                   tpdulen = 3;
3190                   edc = compute_edc (tpdu, tpdulen, use_crc);
3191                   if (use_crc)
3192                     tpdu[tpdulen++] = (edc >> 8);
3193                   tpdu[tpdulen++] = edc;
3194                   resyncing = 1;
3195                   DEBUGOUT ("T=1: requesting resync\n");
3196                 }
3197               else if (retries > 3)
3198                 {
3199                   DEBUGOUT ("T=1: 3 failed retries\n");
3200                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
3201                 }
3202               else
3203                 {
3204                   /* Error: repeat last block */
3205                   msg = send_buffer;
3206                   tpdulen = last_tpdulen;
3207                 }
3208             }
3209           else if (sending && !!(tpdu[1] & 0x10) == handle->t1_ns)
3210             { /* Response does not match our sequence number. */
3211               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
3212               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3213             }
3214           else if (sending)
3215             { /* Send next chunk. */
3216               retries = 0;
3217               msg = send_buffer;
3218               next_chunk = 1;
3219               handle->t1_ns ^= 1;
3220             }
3221           else
3222             {
3223               DEBUGOUT ("unexpected ACK R-block received\n");
3224               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3225             }
3226         }
3227       else
3228         { /* This is a S-block. */
3229           retries = 0;
3230           DEBUGOUT_2 ("T=1: S-block %s received cmd=%d\n",
3231                       (tpdu[1] & 0x20)? "response": "request",
3232                       (tpdu[1] & 0x1f));
3233           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 1 && tpdu[2] == 1)
3234             {
3235               /* Information field size request.  */
3236               unsigned char ifsc = tpdu[3];
3237
3238               if (ifsc < 16 || ifsc > 254)
3239                 return CCID_DRIVER_ERR_CARD_IO_ERROR;
3240
3241               msg = send_buffer;
3242               tpdu = msg + hdrlen;
3243               tpdu[0] = nad_byte;
3244               tpdu[1] = (0xc0 | 0x20 | 1); /* S-block response */
3245               tpdu[2] = 1;
3246               tpdu[3] = ifsc;
3247               tpdulen = 4;
3248               edc = compute_edc (tpdu, tpdulen, use_crc);
3249               if (use_crc)
3250                 tpdu[tpdulen++] = (edc >> 8);
3251               tpdu[tpdulen++] = edc;
3252               DEBUGOUT_1 ("T=1: requesting an ifsc=%d\n", ifsc);
3253             }
3254           else if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
3255             {
3256               /* Wait time extension request. */
3257               unsigned char bwi = tpdu[3];
3258
3259               /* Check if it's unsual value which can't be expressed in ATR.  */
3260               if (bwi > 15)
3261                 wait_more = 1;
3262
3263               msg = send_buffer;
3264               tpdu = msg + hdrlen;
3265               tpdu[0] = nad_byte;
3266               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
3267               tpdu[2] = 1;
3268               tpdu[3] = bwi;
3269               tpdulen = 4;
3270               edc = compute_edc (tpdu, tpdulen, use_crc);
3271               if (use_crc)
3272                 tpdu[tpdulen++] = (edc >> 8);
3273               tpdu[tpdulen++] = edc;
3274               DEBUGOUT_1 ("T=1: waittime extension of bwi=%d\n", bwi);
3275               print_progress (handle);
3276             }
3277           else if ( (tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 0 && !tpdu[2])
3278             {
3279               DEBUGOUT ("T=1: resync ack from reader\n");
3280               /* Repeat previous block.  */
3281               msg = send_buffer;
3282               tpdulen = last_tpdulen;
3283             }
3284           else
3285             return CCID_DRIVER_ERR_CARD_IO_ERROR;
3286         }
3287     } /* end T=1 protocol loop. */
3288
3289   return 0;
3290 }
3291
3292
3293 /* Send the CCID Secure command to the reader.  APDU_BUF should
3294    contain the APDU template.  PIN_MODE defines how the pin gets
3295    formatted:
3296
3297      1 := The PIN is ASCII encoded and of variable length.  The
3298           length of the PIN entered will be put into Lc by the reader.
3299           The APDU should me made up of 4 bytes without Lc.
3300
3301    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
3302    may be used t enable reasonable defaults.
3303
3304    When called with RESP and NRESP set to NULL, the function will
3305    merely check whether the reader supports the secure command for the
3306    given APDU and PIN_MODE. */
3307 int
3308 ccid_transceive_secure (ccid_driver_t handle,
3309                         const unsigned char *apdu_buf, size_t apdu_buflen,
3310                         pininfo_t *pininfo,
3311                         unsigned char *resp, size_t maxresplen, size_t *nresp)
3312 {
3313   int rc;
3314   unsigned char send_buffer[10+259], recv_buffer[10+259];
3315   unsigned char *msg, *tpdu, *p;
3316   size_t msglen, tpdulen, n;
3317   unsigned char seqno;
3318   size_t dummy_nresp;
3319   int testmode;
3320   int cherry_mode = 0;
3321   int add_zero = 0;
3322   int enable_varlen = 0;
3323
3324   testmode = !resp && !nresp;
3325
3326   if (!nresp)
3327     nresp = &dummy_nresp;
3328   *nresp = 0;
3329
3330   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
3331     ;
3332   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
3333     ;
3334   else
3335     return CCID_DRIVER_ERR_NO_PINPAD;
3336
3337   if (!pininfo->minlen)
3338     pininfo->minlen = 1;
3339   if (!pininfo->maxlen)
3340     pininfo->maxlen = 15;
3341
3342   /* Note that the 25 is the maximum value the SPR532 allows.  */
3343   if (pininfo->minlen < 1 || pininfo->minlen > 25
3344       || pininfo->maxlen < 1 || pininfo->maxlen > 25
3345       || pininfo->minlen > pininfo->maxlen)
3346     return CCID_DRIVER_ERR_INV_VALUE;
3347
3348   /* We have only tested a few readers so better don't risk anything
3349      and do not allow the use with other readers. */
3350   switch (handle->id_vendor)
3351     {
3352     case VENDOR_SCM:  /* Tested with SPR 532. */
3353     case VENDOR_KAAN: /* Tested with KAAN Advanced (1.02). */
3354     case VENDOR_FSIJ: /* Tested with Gnuk (0.21). */
3355       pininfo->maxlen = 25;
3356       enable_varlen = 1;
3357       break;
3358     case VENDOR_REINER:/* Tested with cyberJack go */
3359     case VENDOR_VASCO: /* Tested with DIGIPASS 920 */
3360       enable_varlen = 1;
3361       break;
3362     case VENDOR_CHERRY:
3363       pininfo->maxlen = 15;
3364       enable_varlen = 1;
3365       /* The CHERRY XX44 keyboard echos an asterisk for each entered
3366          character on the keyboard channel.  We use a special variant
3367          of PC_to_RDR_Secure which directs these characters to the
3368          smart card's bulk-in channel.  We also need to append a zero
3369          Lc byte to the APDU.  It seems that it will be replaced with
3370          the actual length instead of being appended before the APDU
3371          is send to the card. */
3372       add_zero = 1;
3373       if (handle->id_product != CHERRY_ST2000)
3374         cherry_mode = 1;
3375       break;
3376     default:
3377       if ((handle->id_vendor == VENDOR_GEMPC &&
3378            handle->id_product == GEMPC_PINPAD)
3379           || (handle->id_vendor == VENDOR_VEGA &&
3380               handle->id_product == VEGA_ALPHA))
3381         {
3382           enable_varlen = 0;
3383           pininfo->minlen = 4;
3384           pininfo->maxlen = 8;
3385           break;
3386         }
3387      return CCID_DRIVER_ERR_NOT_SUPPORTED;
3388     }
3389
3390   if (enable_varlen)
3391     pininfo->fixedlen = 0;
3392
3393   if (testmode)
3394     return 0; /* Success */
3395
3396   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
3397     return CCID_DRIVER_ERR_NOT_SUPPORTED;
3398
3399   msg = send_buffer;
3400   if (handle->id_vendor == VENDOR_SCM)
3401     {
3402       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
3403       rc = send_escape_cmd (handle, (const unsigned char*)"\x80\x02\x00", 3,
3404                             NULL, 0, NULL);
3405       if (rc)
3406         return rc;
3407     }
3408
3409   msg[0] = cherry_mode? 0x89 : PC_to_RDR_Secure;
3410   msg[5] = 0; /* slot */
3411   msg[6] = seqno = handle->seqno++;
3412   msg[7] = 0; /* bBWI */
3413   msg[8] = 0; /* RFU */
3414   msg[9] = 0; /* RFU */
3415   msg[10] = apdu_buf[1] == 0x20 ? 0 : 1;
3416                /* Perform PIN verification or PIN modification. */
3417   msg[11] = 0; /* Timeout in seconds. */
3418   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
3419   if (handle->id_vendor == VENDOR_SCM)
3420     {
3421       /* For the SPR532 the next 2 bytes need to be zero.  We do this
3422          for all SCM products.  Kudos to Martin Paljak for this
3423          hint.  */
3424       msg[13] = msg[14] = 0;
3425     }
3426   else
3427     {
3428       msg[13] = pininfo->fixedlen; /* bmPINBlockString:
3429                                       0 bits of pin length to insert.
3430                                       PIN block size by fixedlen.  */
3431       msg[14] = 0x00; /* bmPINLengthFormat:
3432                          Units are bytes, position is 0. */
3433     }
3434
3435   msglen = 15;
3436   if (apdu_buf[1] == 0x24)
3437     {
3438       msg[msglen++] = 0;    /* bInsertionOffsetOld */
3439       msg[msglen++] = pininfo->fixedlen;    /* bInsertionOffsetNew */
3440     }
3441
3442   /* The following is a little endian word. */
3443   msg[msglen++] = pininfo->maxlen;   /* wPINMaxExtraDigit-Maximum.  */
3444   msg[msglen++] = pininfo->minlen;   /* wPINMaxExtraDigit-Minimum.  */
3445
3446   if (apdu_buf[1] == 0x24)
3447     msg[msglen++] = apdu_buf[2] == 0 ? 0x03 : 0x01;
3448               /* bConfirmPIN
3449                *    0x00: new PIN once
3450                *    0x01: new PIN twice (confirmation)
3451                *    0x02: old PIN and new PIN once
3452                *    0x03: old PIN and new PIN twice (confirmation)
3453                */
3454
3455   msg[msglen] = 0x02; /* bEntryValidationCondition:
3456                          Validation key pressed */
3457   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
3458     msg[msglen] |= 0x01; /* Max size reached.  */
3459   msglen++;
3460
3461   if (apdu_buf[1] == 0x20)
3462     msg[msglen++] = 0x01; /* bNumberMessage. */
3463   else
3464     msg[msglen++] = 0x03; /* bNumberMessage. */
3465
3466   msg[msglen++] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
3467   msg[msglen++] = 0x04; /* wLangId-High. */
3468
3469   if (apdu_buf[1] == 0x20)
3470     msg[msglen++] = 0;    /* bMsgIndex. */
3471   else
3472     {
3473       msg[msglen++] = 0;    /* bMsgIndex1. */
3474       msg[msglen++] = 1;    /* bMsgIndex2. */
3475       msg[msglen++] = 2;    /* bMsgIndex3. */
3476     }
3477
3478   /* Calculate Lc.  */
3479   n = pininfo->fixedlen;
3480   if (apdu_buf[1] == 0x24)
3481     n += pininfo->fixedlen;
3482
3483   /* bTeoProlog follows: */
3484   msg[msglen++] = handle->nonnull_nad? ((1 << 4) | 0): 0;
3485   msg[msglen++] = ((handle->t1_ns & 1) << 6); /* I-block */
3486   if (n)
3487     msg[msglen++] = n + 5; /* apdulen should be filled for fixed length.  */
3488   else
3489     msg[msglen++] = 0; /* The apdulen will be filled in by the reader.  */
3490   /* APDU follows:  */
3491   msg[msglen++] = apdu_buf[0]; /* CLA */
3492   msg[msglen++] = apdu_buf[1]; /* INS */
3493   msg[msglen++] = apdu_buf[2]; /* P1 */
3494   msg[msglen++] = apdu_buf[3]; /* P2 */
3495   if (add_zero)
3496     msg[msglen++] = 0;
3497   else if (pininfo->fixedlen != 0)
3498     {
3499       msg[msglen++] = n;
3500       memset (&msg[msglen], 0xff, n);
3501       msglen += n;
3502     }
3503   /* An EDC is not required. */
3504   set_msg_len (msg, msglen - 10);
3505
3506   rc = bulk_out (handle, msg, msglen, 0);
3507   if (rc)
3508     return rc;
3509
3510   msg = recv_buffer;
3511   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3512                 RDR_to_PC_DataBlock, seqno, 30000, 0);
3513   if (rc)
3514     return rc;
3515
3516   tpdu = msg + 10;
3517   tpdulen = msglen - 10;
3518
3519   if (handle->apdu_level)
3520     {
3521       if (resp)
3522         {
3523           if (tpdulen > maxresplen)
3524             {
3525               DEBUGOUT_2 ("provided buffer too short for received data "
3526                           "(%u/%u)\n",
3527                           (unsigned int)tpdulen, (unsigned int)maxresplen);
3528               return CCID_DRIVER_ERR_INV_VALUE;
3529             }
3530
3531           memcpy (resp, tpdu, tpdulen);
3532           *nresp = tpdulen;
3533         }
3534       return 0;
3535     }
3536
3537   if (tpdulen < 4)
3538     {
3539 #ifdef USE_NPTH
3540       npth_unprotect ();
3541 #endif
3542       libusb_clear_halt (handle->idev, handle->ep_bulk_in);
3543 #ifdef USE_NPTH
3544       npth_protect ();
3545 #endif
3546       return CCID_DRIVER_ERR_ABORTED;
3547     }
3548   if (debug_level > 1)
3549     DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3550                 ((msg[11] & 0xc0) == 0x80)? 'R' :
3551                           (msg[11] & 0x80)? 'S' : 'I',
3552                 ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
3553                 ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
3554                 (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
3555
3556   if (!(tpdu[1] & 0x80))
3557     { /* This is an I-block. */
3558       /* Last block sent was successful. */
3559       handle->t1_ns ^= 1;
3560
3561       if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3562         { /* Response does not match our sequence number. */
3563           DEBUGOUT ("I-block with wrong seqno received\n");
3564           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3565         }
3566
3567       handle->t1_nr ^= 1;
3568
3569       p = tpdu + 3; /* Skip the prologue field. */
3570       n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3571       /* fixme: verify the checksum. */
3572       if (resp)
3573         {
3574           if (n > maxresplen)
3575             {
3576               DEBUGOUT_2 ("provided buffer too short for received data "
3577                           "(%u/%u)\n",
3578                           (unsigned int)n, (unsigned int)maxresplen);
3579               return CCID_DRIVER_ERR_INV_VALUE;
3580             }
3581
3582           memcpy (resp, p, n);
3583           *nresp += n;
3584         }
3585
3586       if (!(tpdu[1] & 0x20))
3587         return 0; /* No chaining requested - ready. */
3588
3589       DEBUGOUT ("chaining requested but not supported for Secure operation\n");
3590 &nb