Spelling fixes in docs and comments.
[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       libusb_init (NULL);
1232       initialized_usb = 1;
1233     }
1234
1235   if (scan_devices (&reader_list))
1236     return NULL; /* Error. */
1237   return reader_list;
1238 }
1239
1240
1241 /* Vendor specific custom initialization.  */
1242 static int
1243 ccid_vendor_specific_init (ccid_driver_t handle)
1244 {
1245   if (handle->id_vendor == VENDOR_VEGA && handle->id_product == VEGA_ALPHA)
1246     {
1247       int r;
1248       /*
1249        * Vega alpha has a feature to show retry counter on the pinpad
1250        * display.  But it assumes that the card returns the value of
1251        * retry counter by VERIFY with empty data (return code of
1252        * 63Cx).  Unfortunately, existing OpenPGP cards don't support
1253        * VERIFY command with empty data.  This vendor specific command
1254        * sequence is to disable the feature.
1255        */
1256       const unsigned char cmd[] = { '\xb5', '\x01', '\x00', '\x03', '\x00' };
1257
1258       r = send_escape_cmd (handle, cmd, sizeof (cmd), NULL, 0, NULL);
1259       if (r != 0 && r != CCID_DRIVER_ERR_CARD_INACTIVE
1260           && r != CCID_DRIVER_ERR_NO_CARD)
1261         return r;
1262     }
1263
1264   return 0;
1265 }
1266
1267
1268 #define MAX_DEVICE 4 /* See MAX_READER in apdu.c.  */
1269
1270 struct ccid_dev_table {
1271   int n;                        /* Index to ccid_usb_dev_list */
1272   int interface_number;
1273   int setting_number;
1274   unsigned char *ifcdesc_extra;
1275   int ep_bulk_out;
1276   int ep_bulk_in;
1277   int ep_intr;
1278   size_t ifcdesc_extra_len;
1279 };
1280
1281 static libusb_device **ccid_usb_dev_list;
1282 static struct ccid_dev_table ccid_dev_table[MAX_DEVICE];
1283
1284 gpg_error_t
1285 ccid_dev_scan (int *idx_max_p, struct ccid_dev_table **t_p)
1286 {
1287   ssize_t n;
1288   libusb_device *dev;
1289   int i;
1290   int ifc_no;
1291   int set_no;
1292   int idx = 0;
1293   int err = 0;
1294
1295   if (!initialized_usb)
1296     {
1297       libusb_init (NULL);
1298       initialized_usb = 1;
1299     }
1300
1301   n = libusb_get_device_list (NULL, &ccid_usb_dev_list);
1302   for (i = 0; i < n; i++)
1303     {
1304       struct libusb_config_descriptor *config;
1305       struct libusb_device_descriptor desc;
1306
1307       dev = ccid_usb_dev_list[i];
1308
1309       if (libusb_get_device_descriptor (dev, &desc))
1310         continue;
1311
1312       if (libusb_get_active_config_descriptor (dev, &config))
1313         continue;
1314
1315       for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
1316         for (set_no=0; set_no < config->interface[ifc_no].num_altsetting;
1317              set_no++)
1318           {
1319             const struct libusb_interface_descriptor *ifcdesc;
1320
1321             ifcdesc = &config->interface[ifc_no].altsetting[set_no];
1322             /* The second condition is for older SCM SPR 532 who did
1323                not know about the assigned CCID class.  The third
1324                condition does the same for a Cherry SmartTerminal
1325                ST-2000.  Instead of trying to interpret the strings
1326                we simply check the product ID. */
1327             if (ifcdesc && ifcdesc->extra
1328                 && ((ifcdesc->bInterfaceClass == 11
1329                      && ifcdesc->bInterfaceSubClass == 0
1330                      && ifcdesc->bInterfaceProtocol == 0)
1331                     || (ifcdesc->bInterfaceClass == 255
1332                         && desc.idVendor == VENDOR_SCM
1333                         && desc.idProduct == SCM_SPR532)
1334                     || (ifcdesc->bInterfaceClass == 255
1335                         && desc.idVendor == VENDOR_CHERRY
1336                         && desc.idProduct == CHERRY_ST2000)))
1337               {
1338                 /* Found a reader.  */
1339                 unsigned char *ifcdesc_extra;
1340
1341                 ifcdesc_extra = malloc (ifcdesc->extra_length);
1342                 if (!ifcdesc_extra)
1343                   {
1344                     err = gpg_error_from_syserror ();
1345                     libusb_free_config_descriptor (config);
1346                     goto scan_finish;
1347                   }
1348                 memcpy (ifcdesc_extra, ifcdesc->extra, ifcdesc->extra_length);
1349
1350                 ccid_dev_table[idx].n = i;
1351                 ccid_dev_table[idx].interface_number = ifc_no;
1352                 ccid_dev_table[idx].setting_number = set_no;
1353                 ccid_dev_table[idx].ifcdesc_extra = ifcdesc_extra;
1354                 ccid_dev_table[idx].ifcdesc_extra_len = ifcdesc->extra_length;
1355                 ccid_dev_table[idx].ep_bulk_out = find_endpoint (ifcdesc, 0);
1356                 ccid_dev_table[idx].ep_bulk_in = find_endpoint (ifcdesc, 1);
1357                 ccid_dev_table[idx].ep_intr = find_endpoint (ifcdesc, 2);
1358
1359                 idx++;
1360                 if (idx >= MAX_DEVICE)
1361                   {
1362                     libusb_free_config_descriptor (config);
1363                     err = 0;
1364                     goto scan_finish;
1365                   }
1366               }
1367           }
1368
1369       libusb_free_config_descriptor (config);
1370     }
1371
1372  scan_finish:
1373
1374   if (err)
1375     {
1376       *idx_max_p = 0;
1377       *t_p = NULL;
1378       for (i = 0; i < idx; i++)
1379         {
1380           free (ccid_dev_table[idx].ifcdesc_extra);
1381           ccid_dev_table[idx].n = 0;
1382           ccid_dev_table[idx].interface_number = 0;
1383           ccid_dev_table[idx].setting_number = 0;
1384           ccid_dev_table[idx].ifcdesc_extra = NULL;
1385           ccid_dev_table[idx].ifcdesc_extra_len = 0;
1386           ccid_dev_table[idx].ep_bulk_out = 0;
1387           ccid_dev_table[idx].ep_bulk_in = 0;
1388           ccid_dev_table[idx].ep_intr = 0;
1389         }
1390       libusb_free_device_list (ccid_usb_dev_list, 1);
1391       ccid_usb_dev_list = NULL;
1392     }
1393   else
1394     {
1395       *idx_max_p = idx;
1396       if (idx)
1397         *t_p = ccid_dev_table;
1398       else
1399         *t_p = NULL;
1400     }
1401
1402   return err;
1403 }
1404
1405 void
1406 ccid_dev_scan_finish (struct ccid_dev_table *tbl, int max)
1407 {
1408   int i;
1409
1410   for (i = 0; i < max; i++)
1411     {
1412       free (tbl[i].ifcdesc_extra);
1413       tbl[i].n = 0;
1414       tbl[i].interface_number = 0;
1415       tbl[i].setting_number = 0;
1416       tbl[i].ifcdesc_extra = NULL;
1417       tbl[i].ifcdesc_extra_len = 0;
1418       tbl[i].ep_bulk_out = 0;
1419       tbl[i].ep_bulk_in = 0;
1420       tbl[i].ep_intr = 0;
1421     }
1422   libusb_free_device_list (ccid_usb_dev_list, 1);
1423   ccid_usb_dev_list = NULL;
1424 }
1425
1426 unsigned int
1427 ccid_get_BAI (int idx, struct ccid_dev_table *tbl)
1428 {
1429   int n;
1430   int bus, addr, intf;
1431   unsigned int bai;
1432   libusb_device *dev;
1433
1434   n = tbl[idx].n;
1435   dev = ccid_usb_dev_list[n];
1436
1437   bus = libusb_get_bus_number (dev);
1438   addr = libusb_get_device_address (dev);
1439   intf = tbl[idx].interface_number;
1440   bai = (bus << 16) | (addr << 8) | intf;
1441
1442   return bai;
1443 }
1444
1445 int
1446 ccid_compare_BAI (ccid_driver_t handle, unsigned int bai)
1447 {
1448   return handle->bai == bai;
1449 }
1450
1451
1452 static void
1453 intr_cb (struct libusb_transfer *transfer)
1454 {
1455   ccid_driver_t handle = transfer->user_data;
1456
1457   DEBUGOUT_1 ("CCID: interrupt callback %d\n", transfer->status);
1458
1459   if (transfer->status == LIBUSB_TRANSFER_TIMED_OUT)
1460     {
1461       int err;
1462
1463     submit_again:
1464       /* Submit the URB again to keep watching the INTERRUPT transfer.  */
1465       err = libusb_submit_transfer (transfer);
1466       if (err == LIBUSB_ERROR_NO_DEVICE)
1467         goto device_removed;
1468
1469       DEBUGOUT_1 ("CCID submit transfer again %d\n", err);
1470     }
1471   else if (transfer->status == LIBUSB_TRANSFER_COMPLETED)
1472     {
1473       if (transfer->actual_length == 2
1474           && transfer->buffer[0] == 0x50
1475           && (transfer->buffer[1] & 1) == 0)
1476         {
1477           DEBUGOUT ("CCID: card removed\n");
1478           handle->powered_off = 1;
1479         }
1480       else
1481         {
1482           /* Event other than card removal.  */
1483           goto submit_again;
1484         }
1485     }
1486   else if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
1487     handle->powered_off = 1;
1488   else
1489     {
1490     device_removed:
1491       DEBUGOUT ("CCID: device removed\n");
1492       handle->powered_off = 1;
1493     }
1494
1495   scd_kick_the_loop ();
1496 }
1497
1498 static void
1499 ccid_setup_intr  (ccid_driver_t handle)
1500 {
1501   struct libusb_transfer *transfer;
1502   int err;
1503
1504   transfer = libusb_alloc_transfer (0);
1505   handle->transfer = transfer;
1506   libusb_fill_interrupt_transfer (transfer, handle->idev, handle->ep_intr,
1507                                   handle->intr_buf, sizeof (handle->intr_buf),
1508                                   intr_cb, handle, 0);
1509   err = libusb_submit_transfer (transfer);
1510   DEBUGOUT_2 ("CCID submit transfer (%x): %d", handle->ep_intr, err);
1511 }
1512
1513
1514 static void *
1515 ccid_usb_thread (void *arg)
1516 {
1517   libusb_context *ctx = arg;
1518
1519   while (ccid_usb_thread_is_alive)
1520     {
1521 #ifdef USE_NPTH
1522       npth_unprotect ();
1523 #endif
1524       libusb_handle_events_completed (ctx, NULL);
1525 #ifdef USE_NPTH
1526       npth_protect ();
1527 #endif
1528     }
1529
1530   return NULL;
1531 }
1532
1533
1534 static int
1535 ccid_open_usb_reader (const char *spec_reader_name,
1536                       int idx, struct ccid_dev_table *ccid_table,
1537                       ccid_driver_t *handle, char **rdrname_p)
1538 {
1539   libusb_device *dev;
1540   libusb_device_handle *idev = NULL;
1541   char *rid = NULL;
1542   int rc = 0;
1543   int ifc_no, set_no;
1544   struct libusb_device_descriptor desc;
1545   int n;
1546   int bus, addr;
1547   unsigned int bai;
1548
1549   n = ccid_table[idx].n;
1550   ifc_no = ccid_table[idx].interface_number;
1551   set_no = ccid_table[idx].setting_number;
1552
1553   dev = ccid_usb_dev_list[n];
1554   bus = libusb_get_bus_number (dev);
1555   addr = libusb_get_device_address (dev);
1556   bai = (bus << 16) | (addr << 8) | ifc_no;
1557
1558   rc = libusb_open (dev, &idev);
1559   if (rc)
1560     {
1561       DEBUGOUT_1 ("usb_open failed: %s\n", libusb_error_name (rc));
1562       free (*handle);
1563       *handle = NULL;
1564       return rc;
1565     }
1566
1567   if (ccid_usb_thread_is_alive++ == 0)
1568     {
1569       npth_t thread;
1570       npth_attr_t tattr;
1571       int err;
1572
1573       err = npth_attr_init (&tattr);
1574       if (err)
1575         {
1576           DEBUGOUT_1 ("npth_attr_init failed: %s\n", strerror (err));
1577           free (*handle);
1578           *handle = NULL;
1579           return err;
1580         }
1581
1582       npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1583       err = npth_create (&thread, &tattr, ccid_usb_thread, NULL);
1584       if (err)
1585         {
1586           DEBUGOUT_1 ("npth_create failed: %s\n", strerror (err));
1587           free (*handle);
1588           *handle = NULL;
1589           return err;
1590         }
1591
1592       npth_attr_destroy (&tattr);
1593     }
1594
1595   rc = libusb_get_device_descriptor (dev, &desc);
1596   if (rc)
1597     {
1598       DEBUGOUT ("get_device_descripor failed\n");
1599       goto leave;
1600     }
1601
1602   rid = make_reader_id (idev, desc.idVendor, desc.idProduct,
1603                         desc.iSerialNumber);
1604
1605   /* Check to see if reader name matches the spec.  */
1606   if (spec_reader_name
1607       && strncmp (rid, spec_reader_name, strlen (spec_reader_name)))
1608     {
1609       DEBUGOUT ("device not matched\n");
1610       rc = CCID_DRIVER_ERR_NO_READER;
1611       goto leave;
1612     }
1613
1614   (*handle)->id_vendor = desc.idVendor;
1615   (*handle)->id_product = desc.idProduct;
1616   (*handle)->idev = idev;
1617   (*handle)->bai = bai;
1618   (*handle)->ifc_no = ifc_no;
1619   (*handle)->ep_bulk_out = ccid_table[idx].ep_bulk_out;
1620   (*handle)->ep_bulk_in = ccid_table[idx].ep_bulk_in;
1621   (*handle)->ep_intr = ccid_table[idx].ep_intr;
1622
1623   DEBUGOUT_2 ("using CCID reader %d (ID=%s)\n", idx, rid);
1624
1625   if (parse_ccid_descriptor (*handle, desc.bcdDevice,
1626                              ccid_table[idx].ifcdesc_extra,
1627                              ccid_table[idx].ifcdesc_extra_len))
1628     {
1629       DEBUGOUT ("device not supported\n");
1630       rc = CCID_DRIVER_ERR_NO_READER;
1631       goto leave;
1632     }
1633
1634   rc = libusb_claim_interface (idev, ifc_no);
1635   if (rc)
1636     {
1637       DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
1638       rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1639       goto leave;
1640     }
1641
1642   if (set_no != 0)
1643     {
1644       rc = libusb_set_interface_alt_setting (idev, ifc_no, set_no);
1645       if (rc)
1646         {
1647           DEBUGOUT_1 ("usb_set_interface_alt_setting failed: %d\n", rc);
1648           rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1649           goto leave;
1650         }
1651     }
1652
1653   if ((*handle)->ep_intr >= 0)
1654     ccid_setup_intr (*handle);
1655
1656   rc = ccid_vendor_specific_init (*handle);
1657
1658  leave:
1659   if (rc)
1660     {
1661       --ccid_usb_thread_is_alive;
1662       free (rid);
1663       libusb_close (idev);
1664       free (*handle);
1665       *handle = NULL;
1666     }
1667   else
1668     {
1669       if (rdrname_p)
1670         *rdrname_p = rid;
1671       else
1672         free (rid);
1673     }
1674
1675   return rc;
1676 }
1677
1678 /* Open the reader with the internal number READERNO and return a
1679    pointer to be used as handle in HANDLE.  Returns 0 on success. */
1680 int
1681 ccid_open_reader (const char *spec_reader_name, int idx,
1682                   struct ccid_dev_table *ccid_table,
1683                   ccid_driver_t *handle, char **rdrname_p)
1684 {
1685   *handle = calloc (1, sizeof **handle);
1686   if (!*handle)
1687     {
1688       DEBUGOUT ("out of memory\n");
1689       return CCID_DRIVER_ERR_OUT_OF_CORE;
1690     }
1691
1692   return ccid_open_usb_reader (spec_reader_name, idx, ccid_table,
1693                                handle, rdrname_p);
1694 }
1695
1696
1697 int
1698 ccid_require_get_status (ccid_driver_t handle)
1699 {
1700   /* When a card reader supports interrupt transfer to check the
1701      status of card, it is possible to submit only an interrupt
1702      transfer, and no check is required by application layer.  USB can
1703      detect removal of a card and can detect removal of a reader.
1704   */
1705   if (handle->ep_intr >= 0)
1706     return 0;
1707
1708   /* Libusb actually detects the removal of USB device in use.
1709      However, there is no good API to handle the removal (yet),
1710      cleanly and with good portability.
1711
1712      There is libusb_set_pollfd_notifiers function, but it doesn't
1713      offer libusb_device_handle* data to its callback.  So, when it
1714      watches multiple devices, there is no way to know which device is
1715      removed.
1716
1717      Once, we will have a good programming interface of libusb, we can
1718      list tokens (with no interrupt transfer support, but always with
1719      card inserted) here to return 0, so that scdaemon can submit
1720      minimum packet on wire.
1721   */
1722   return 1;
1723 }
1724
1725
1726 static void
1727 do_close_reader (ccid_driver_t handle)
1728 {
1729   int rc;
1730   unsigned char msg[100];
1731   size_t msglen;
1732   unsigned char seqno;
1733
1734   if (!handle->powered_off)
1735     {
1736       msg[0] = PC_to_RDR_IccPowerOff;
1737       msg[5] = 0; /* slot */
1738       msg[6] = seqno = handle->seqno++;
1739       msg[7] = 0; /* RFU */
1740       msg[8] = 0; /* RFU */
1741       msg[9] = 0; /* RFU */
1742       set_msg_len (msg, 0);
1743       msglen = 10;
1744
1745       rc = bulk_out (handle, msg, msglen, 0);
1746       if (!rc)
1747         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
1748                  seqno, 2000, 0);
1749     }
1750
1751   if (handle->transfer)
1752     {
1753       if (!handle->powered_off)
1754         {
1755           DEBUGOUT ("libusb_cancel_transfer\n");
1756
1757           rc = libusb_cancel_transfer (handle->transfer);
1758           if (rc != LIBUSB_ERROR_NOT_FOUND)
1759             while (!handle->powered_off)
1760               {
1761                 DEBUGOUT ("libusb_handle_events_completed\n");
1762 #ifdef USE_NPTH
1763                 npth_unprotect ();
1764 #endif
1765                 libusb_handle_events_completed (NULL, &handle->powered_off);
1766 #ifdef USE_NPTH
1767                 npth_protect ();
1768 #endif
1769               }
1770         }
1771
1772       libusb_free_transfer (handle->transfer);
1773     }
1774   libusb_release_interface (handle->idev, handle->ifc_no);
1775   --ccid_usb_thread_is_alive;
1776   libusb_close (handle->idev);
1777   handle->idev = NULL;
1778 }
1779
1780
1781 int
1782 ccid_set_progress_cb (ccid_driver_t handle,
1783                       void (*cb)(void *, const char *, int, int, int),
1784                       void *cb_arg)
1785 {
1786   if (!handle)
1787     return CCID_DRIVER_ERR_INV_VALUE;
1788
1789   handle->progress_cb = cb;
1790   handle->progress_cb_arg = cb_arg;
1791   return 0;
1792 }
1793
1794
1795 /* Close the reader HANDLE. */
1796 int
1797 ccid_close_reader (ccid_driver_t handle)
1798 {
1799   if (!handle)
1800     return 0;
1801
1802   do_close_reader (handle);
1803   free (handle);
1804   return 0;
1805 }
1806
1807
1808 /* Return False if a card is present and powered. */
1809 int
1810 ccid_check_card_presence (ccid_driver_t handle)
1811 {
1812   (void)handle;  /* Not yet implemented.  */
1813   return -1;
1814 }
1815
1816
1817 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
1818    Returns 0 on success. */
1819 static int
1820 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen,
1821           int no_debug)
1822 {
1823   int rc;
1824   int transferred;
1825
1826   /* No need to continue and clutter the log with USB write error
1827      messages after we got the first ENODEV.  */
1828   if (handle->enodev_seen)
1829     return CCID_DRIVER_ERR_NO_READER;
1830
1831   if (debug_level && (!no_debug || debug_level >= 3))
1832     {
1833       switch (msglen? msg[0]:0)
1834         {
1835         case PC_to_RDR_IccPowerOn:
1836           print_p2r_iccpoweron (msg, msglen);
1837           break;
1838         case PC_to_RDR_IccPowerOff:
1839           print_p2r_iccpoweroff (msg, msglen);
1840           break;
1841         case PC_to_RDR_GetSlotStatus:
1842           print_p2r_getslotstatus (msg, msglen);
1843           break;
1844         case PC_to_RDR_XfrBlock:
1845           print_p2r_xfrblock (msg, msglen);
1846           break;
1847         case PC_to_RDR_GetParameters:
1848           print_p2r_getparameters (msg, msglen);
1849           break;
1850         case PC_to_RDR_ResetParameters:
1851           print_p2r_resetparameters (msg, msglen);
1852           break;
1853         case PC_to_RDR_SetParameters:
1854           print_p2r_setparameters (msg, msglen);
1855           break;
1856         case PC_to_RDR_Escape:
1857           print_p2r_escape (msg, msglen);
1858           break;
1859         case PC_to_RDR_IccClock:
1860           print_p2r_iccclock (msg, msglen);
1861           break;
1862         case PC_to_RDR_T0APDU:
1863           print_p2r_to0apdu (msg, msglen);
1864           break;
1865         case PC_to_RDR_Secure:
1866           print_p2r_secure (msg, msglen);
1867           break;
1868         case PC_to_RDR_Mechanical:
1869           print_p2r_mechanical (msg, msglen);
1870           break;
1871         case PC_to_RDR_Abort:
1872           print_p2r_abort (msg, msglen);
1873           break;
1874         case PC_to_RDR_SetDataRate:
1875           print_p2r_setdatarate (msg, msglen);
1876           break;
1877         default:
1878           print_p2r_unknown (msg, msglen);
1879           break;
1880         }
1881     }
1882
1883 #ifdef USE_NPTH
1884   npth_unprotect ();
1885 #endif
1886   rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
1887                              (char*)msg, msglen, &transferred,
1888                              5000 /* ms timeout */);
1889 #ifdef USE_NPTH
1890   npth_protect ();
1891 #endif
1892   if (rc == 0 && transferred == msglen)
1893     return 0;
1894
1895   if (rc)
1896     {
1897       DEBUGOUT_1 ("usb_bulk_write error: %s\n", libusb_error_name (rc));
1898       if (rc == LIBUSB_ERROR_NO_DEVICE)
1899         {
1900           handle->enodev_seen = 1;
1901           return CCID_DRIVER_ERR_NO_READER;
1902         }
1903     }
1904
1905   return 0;
1906 }
1907
1908
1909 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
1910    BUFFER and return the actual read number if bytes in NREAD. SEQNO
1911    is the sequence number used to send the request and EXPECTED_TYPE
1912    the type of message we expect. Does checks on the ccid
1913    header. TIMEOUT is the timeout value in ms. NO_DEBUG may be set to
1914    avoid debug messages in case of no error; this can be overriden
1915    with a glibal debug level of at least 3. Returns 0 on success. */
1916 static int
1917 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
1918          size_t *nread, int expected_type, int seqno, int timeout,
1919          int no_debug)
1920 {
1921   int rc;
1922   int msglen;
1923
1924   /* Fixme: The next line for the current Valgrind without support
1925      for USB IOCTLs. */
1926   memset (buffer, 0, length);
1927  retry:
1928
1929 #ifdef USE_NPTH
1930   npth_unprotect ();
1931 #endif
1932   rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
1933                              (char*)buffer, length, &msglen, timeout);
1934 #ifdef USE_NPTH
1935   npth_protect ();
1936 #endif
1937   if (rc)
1938     {
1939       DEBUGOUT_1 ("usb_bulk_read error: %s\n", libusb_error_name (rc));
1940       if (rc == LIBUSB_ERROR_NO_DEVICE)
1941         {
1942           handle->enodev_seen = 1;
1943           return CCID_DRIVER_ERR_NO_READER;
1944         }
1945
1946       return CCID_DRIVER_ERR_CARD_IO_ERROR;
1947     }
1948   if (msglen < 0)
1949     return CCID_DRIVER_ERR_INV_VALUE;  /* Faulty libusb.  */
1950   *nread = msglen;
1951
1952   if (msglen < 10)
1953     {
1954       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
1955       abort_cmd (handle, seqno);
1956       return CCID_DRIVER_ERR_INV_VALUE;
1957     }
1958   if (buffer[5] != 0)
1959     {
1960       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
1961       return CCID_DRIVER_ERR_INV_VALUE;
1962     }
1963   if (buffer[6] != seqno)
1964     {
1965       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
1966                   seqno, buffer[6]);
1967       /* Retry until we are synced again.  */
1968       goto retry;
1969     }
1970
1971   /* We need to handle the time extension request before we check that
1972      we got the expected message type.  This is in particular required
1973      for the Cherry keyboard which sends a time extension request for
1974      each key hit.  */
1975   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
1976     {
1977       /* Card present and active, time extension requested. */
1978       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
1979                   buffer[7], buffer[8]);
1980       goto retry;
1981     }
1982
1983   if (buffer[0] != expected_type && buffer[0] != RDR_to_PC_SlotStatus)
1984     {
1985       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
1986       abort_cmd (handle, seqno);
1987       return CCID_DRIVER_ERR_INV_VALUE;
1988     }
1989
1990   if (debug_level && (!no_debug || debug_level >= 3))
1991     {
1992       switch (buffer[0])
1993         {
1994         case RDR_to_PC_DataBlock:
1995           print_r2p_datablock (buffer, msglen);
1996           break;
1997         case RDR_to_PC_SlotStatus:
1998           print_r2p_slotstatus (buffer, msglen);
1999           break;
2000         case RDR_to_PC_Parameters:
2001           print_r2p_parameters (buffer, msglen);
2002           break;
2003         case RDR_to_PC_Escape:
2004           print_r2p_escape (buffer, msglen);
2005           break;
2006         case RDR_to_PC_DataRate:
2007           print_r2p_datarate (buffer, msglen);
2008           break;
2009         default:
2010           print_r2p_unknown (buffer, msglen);
2011           break;
2012         }
2013     }
2014   if (CCID_COMMAND_FAILED (buffer))
2015     print_command_failed (buffer);
2016
2017   /* Check whether a card is at all available.  Note: If you add new
2018      error codes here, check whether they need to be ignored in
2019      send_escape_cmd. */
2020   switch ((buffer[7] & 0x03))
2021     {
2022     case 0: /* no error */ break;
2023     case 1: rc = CCID_DRIVER_ERR_CARD_INACTIVE; break;
2024     case 2: rc = CCID_DRIVER_ERR_NO_CARD; break;
2025     case 3: /* RFU */ break;
2026     }
2027
2028   if (rc)
2029     {
2030       /*
2031        * Communication failure by device side.
2032        * Possibly, it was forcibly suspended and resumed.
2033        */
2034       DEBUGOUT ("CCID: card inactive/removed\n");
2035       handle->powered_off = 1;
2036       scd_kick_the_loop ();
2037     }
2038
2039   return rc;
2040 }
2041
2042
2043
2044 /* Send an abort sequence and wait until everything settled.  */
2045 static int
2046 abort_cmd (ccid_driver_t handle, int seqno)
2047 {
2048   int rc;
2049   char dummybuf[8];
2050   unsigned char msg[100];
2051   int msglen;
2052
2053   seqno &= 0xff;
2054   DEBUGOUT_1 ("sending abort sequence for seqno %d\n", seqno);
2055   /* Send the abort command to the control pipe.  Note that we don't
2056      need to keep track of sent abort commands because there should
2057      never be another thread using the same slot concurrently.  */
2058 #ifdef USE_NPTH
2059   npth_unprotect ();
2060 #endif
2061   rc = libusb_control_transfer (handle->idev,
2062                                 0x21,/* bmRequestType: host-to-device,
2063                                         class specific, to interface.  */
2064                                 1,   /* ABORT */
2065                                 (seqno << 8 | 0 /* slot */),
2066                                 handle->ifc_no,
2067                                 dummybuf, 0,
2068                                 1000 /* ms timeout */);
2069 #ifdef USE_NPTH
2070   npth_protect ();
2071 #endif
2072   if (rc)
2073     {
2074       DEBUGOUT_1 ("usb_control_msg error: %s\n", libusb_error_name (rc));
2075       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2076     }
2077
2078   /* Now send the abort command to the bulk out pipe using the same
2079      SEQNO and SLOT.  Do this in a loop to so that all seqno are
2080      tried.  */
2081   seqno--;  /* Adjust for next increment.  */
2082   do
2083     {
2084       int transferred;
2085
2086       seqno++;
2087       msg[0] = PC_to_RDR_Abort;
2088       msg[5] = 0; /* slot */
2089       msg[6] = seqno;
2090       msg[7] = 0; /* RFU */
2091       msg[8] = 0; /* RFU */
2092       msg[9] = 0; /* RFU */
2093       msglen = 10;
2094       set_msg_len (msg, 0);
2095
2096 #ifdef USE_NPTH
2097       npth_unprotect ();
2098 #endif
2099       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
2100                                  (char*)msg, msglen, &transferred,
2101                                  5000 /* ms timeout */);
2102 #ifdef USE_NPTH
2103       npth_protect ();
2104 #endif
2105       if (rc == 0 && transferred == msglen)
2106         rc = 0;
2107       else if (rc)
2108         DEBUGOUT_1 ("usb_bulk_write error in abort_cmd: %s\n",
2109                     libusb_error_name (rc));
2110
2111       if (rc)
2112         return rc;
2113
2114 #ifdef USE_NPTH
2115       npth_unprotect ();
2116 #endif
2117       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
2118                                  (char*)msg, sizeof msg, &msglen,
2119                                  5000 /*ms timeout*/);
2120 #ifdef USE_NPTH
2121       npth_protect ();
2122 #endif
2123       if (rc)
2124         {
2125           DEBUGOUT_1 ("usb_bulk_read error in abort_cmd: %s\n",
2126                       libusb_error_name (rc));
2127           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2128         }
2129
2130       if (msglen < 10)
2131         {
2132           DEBUGOUT_1 ("bulk-in msg in abort_cmd too short (%u)\n",
2133                       (unsigned int)msglen);
2134           return CCID_DRIVER_ERR_INV_VALUE;
2135         }
2136       if (msg[5] != 0)
2137         {
2138           DEBUGOUT_1 ("unexpected bulk-in slot (%d) in abort_cmd\n", msg[5]);
2139           return CCID_DRIVER_ERR_INV_VALUE;
2140         }
2141
2142       DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n",
2143                   msg[7], msg[8], msg[9]);
2144       if (CCID_COMMAND_FAILED (msg))
2145         print_command_failed (msg);
2146     }
2147   while (msg[0] != RDR_to_PC_SlotStatus && msg[5] != 0 && msg[6] != seqno);
2148
2149   handle->seqno = ((seqno + 1) & 0xff);
2150   DEBUGOUT ("sending abort sequence succeeded\n");
2151
2152   return 0;
2153 }
2154
2155
2156 /* Note that this function won't return the error codes NO_CARD or
2157    CARD_INACTIVE.  IF RESULT is not NULL, the result from the
2158    operation will get returned in RESULT and its length in RESULTLEN.
2159    If the response is larger than RESULTMAX, an error is returned and
2160    the required buffer length returned in RESULTLEN.  */
2161 static int
2162 send_escape_cmd (ccid_driver_t handle,
2163                  const unsigned char *data, size_t datalen,
2164                  unsigned char *result, size_t resultmax, size_t *resultlen)
2165 {
2166   int rc;
2167   unsigned char msg[100];
2168   size_t msglen;
2169   unsigned char seqno;
2170
2171   if (resultlen)
2172     *resultlen = 0;
2173
2174   if (datalen > sizeof msg - 10)
2175     return CCID_DRIVER_ERR_INV_VALUE; /* Escape data too large.  */
2176
2177   msg[0] = PC_to_RDR_Escape;
2178   msg[5] = 0; /* slot */
2179   msg[6] = seqno = handle->seqno++;
2180   msg[7] = 0; /* RFU */
2181   msg[8] = 0; /* RFU */
2182   msg[9] = 0; /* RFU */
2183   memcpy (msg+10, data, datalen);
2184   msglen = 10 + datalen;
2185   set_msg_len (msg, datalen);
2186
2187   rc = bulk_out (handle, msg, msglen, 0);
2188   if (rc)
2189     return rc;
2190   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Escape,
2191                 seqno, 5000, 0);
2192   if (result)
2193     switch (rc)
2194       {
2195         /* We need to ignore certain errorcode here. */
2196       case 0:
2197       case CCID_DRIVER_ERR_CARD_INACTIVE:
2198       case CCID_DRIVER_ERR_NO_CARD:
2199         {
2200           if (msglen > resultmax)
2201             rc = CCID_DRIVER_ERR_INV_VALUE; /* Response too large. */
2202           else
2203             {
2204               memcpy (result, msg, msglen);
2205               if (resultlen)
2206                 *resultlen = msglen;
2207               rc = 0;
2208             }
2209         }
2210         break;
2211       default:
2212         break;
2213       }
2214
2215   return rc;
2216 }
2217
2218
2219 int
2220 ccid_transceive_escape (ccid_driver_t handle,
2221                         const unsigned char *data, size_t datalen,
2222                         unsigned char *resp, size_t maxresplen, size_t *nresp)
2223 {
2224   return send_escape_cmd (handle, data, datalen, resp, maxresplen, nresp);
2225 }
2226
2227
2228
2229 /* experimental */
2230 int
2231 ccid_poll (ccid_driver_t handle)
2232 {
2233   int rc;
2234   unsigned char msg[10];
2235   int msglen;
2236   int i, j;
2237
2238   rc = libusb_interrupt_transfer (handle->idev, handle->ep_intr,
2239                                   (char*)msg, sizeof msg, &msglen,
2240                                   0 /* ms timeout */ );
2241   if (rc == LIBUSB_ERROR_TIMEOUT)
2242     return 0;
2243
2244   if (rc)
2245     {
2246       DEBUGOUT_1 ("usb_intr_read error: %s\n", libusb_error_name (rc));
2247       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2248     }
2249
2250   if (msglen < 1)
2251     {
2252       DEBUGOUT ("intr-in msg too short\n");
2253       return CCID_DRIVER_ERR_INV_VALUE;
2254     }
2255
2256   if (msg[0] == RDR_to_PC_NotifySlotChange)
2257     {
2258       DEBUGOUT ("notify slot change:");
2259       for (i=1; i < msglen; i++)
2260         for (j=0; j < 4; j++)
2261           DEBUGOUT_CONT_3 (" %d:%c%c",
2262                            (i-1)*4+j,
2263                            (msg[i] & (1<<(j*2)))? 'p':'-',
2264                            (msg[i] & (2<<(j*2)))? '*':' ');
2265       DEBUGOUT_LF ();
2266     }
2267   else if (msg[0] == RDR_to_PC_HardwareError)
2268     {
2269       DEBUGOUT ("hardware error occurred\n");
2270     }
2271   else
2272     {
2273       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
2274     }
2275
2276   return 0;
2277 }
2278
2279
2280 /* Note that this function won't return the error codes NO_CARD or
2281    CARD_INACTIVE */
2282 int
2283 ccid_slot_status (ccid_driver_t handle, int *statusbits, int on_wire)
2284 {
2285   int rc;
2286   unsigned char msg[100];
2287   size_t msglen;
2288   unsigned char seqno;
2289   int retries = 0;
2290
2291   if (handle->powered_off)
2292     return CCID_DRIVER_ERR_NO_READER;
2293
2294   /* If the card (with its lower-level driver) doesn't require
2295      GET_STATUS on wire (because it supports INTERRUPT transfer for
2296      status change, or it's a token which has a card always inserted),
2297      no need to send on wire.  */
2298   if (!on_wire && !ccid_require_get_status (handle))
2299     {
2300       *statusbits = 0;
2301       return 0;
2302     }
2303
2304  retry:
2305   msg[0] = PC_to_RDR_GetSlotStatus;
2306   msg[5] = 0; /* slot */
2307   msg[6] = seqno = handle->seqno++;
2308   msg[7] = 0; /* RFU */
2309   msg[8] = 0; /* RFU */
2310   msg[9] = 0; /* RFU */
2311   set_msg_len (msg, 0);
2312
2313   rc = bulk_out (handle, msg, 10, 1);
2314   if (rc)
2315     return rc;
2316   /* Note that we set the NO_DEBUG flag here, so that the logs won't
2317      get cluttered up by a ticker function checking for the slot
2318      status and debugging enabled. */
2319   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
2320                 seqno, retries? 1000 : 200, 1);
2321   if (rc == CCID_DRIVER_ERR_CARD_IO_ERROR && retries < 3)
2322     {
2323       if (!retries)
2324         {
2325           DEBUGOUT ("USB: CALLING USB_CLEAR_HALT\n");
2326 #ifdef USE_NPTH
2327           npth_unprotect ();
2328 #endif
2329           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
2330           libusb_clear_halt (handle->idev, handle->ep_bulk_out);
2331 #ifdef USE_NPTH
2332           npth_protect ();
2333 #endif
2334         }
2335       else
2336           DEBUGOUT ("USB: RETRYING bulk_in AGAIN\n");
2337       retries++;
2338       goto retry;
2339     }
2340   if (rc && rc != CCID_DRIVER_ERR_NO_CARD && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
2341     return rc;
2342   *statusbits = (msg[7] & 3);
2343
2344   return 0;
2345 }
2346
2347
2348 /* Parse ATR string (of ATRLEN) and update parameters at PARAM.
2349    Calling this routine, it should prepare default values at PARAM
2350    beforehand.  This routine assumes that card is accessed by T=1
2351    protocol.  It doesn't analyze historical bytes at all.
2352
2353    Returns < 0 value on error:
2354      -1 for parse error or integrity check error
2355      -2 for card doesn't support T=1 protocol
2356      -3 for parameters are nod explicitly defined by ATR
2357      -4 for this driver doesn't support CRC
2358
2359    Returns >= 0 on success:
2360       0 for card is negotiable mode
2361       1 for card is specific mode (and not negotiable)
2362  */
2363 static int
2364 update_param_by_atr (unsigned char *param, unsigned char *atr, size_t atrlen)
2365 {
2366   int i = -1;
2367   int t, y, chk;
2368   int historical_bytes_num, negotiable = 1;
2369
2370 #define NEXTBYTE() do { i++; if (atrlen <= i) return -1; } while (0)
2371
2372   NEXTBYTE ();
2373
2374   if (atr[i] == 0x3F)
2375     param[1] |= 0x02;           /* Convention is inverse.  */
2376   NEXTBYTE ();
2377
2378   y = (atr[i] >> 4);
2379   historical_bytes_num = atr[i] & 0x0f;
2380   NEXTBYTE ();
2381
2382   if ((y & 1))
2383     {
2384       param[0] = atr[i];        /* TA1 - Fi & Di */
2385       NEXTBYTE ();
2386     }
2387
2388   if ((y & 2))
2389     NEXTBYTE ();                /* TB1 - ignore */
2390
2391   if ((y & 4))
2392     {
2393       param[2] = atr[i];        /* TC1 - Guard Time */
2394       NEXTBYTE ();
2395     }
2396
2397   if ((y & 8))
2398     {
2399       y = (atr[i] >> 4);        /* TD1 */
2400       t = atr[i] & 0x0f;
2401       NEXTBYTE ();
2402
2403       if ((y & 1))
2404         {                       /* TA2 - PPS mode */
2405           if ((atr[i] & 0x0f) != 1)
2406             return -2;          /* Wrong card protocol (!= 1).  */
2407
2408           if ((atr[i] & 0x10) != 0x10)
2409             return -3; /* Transmission parameters are implicitly defined. */
2410
2411           negotiable = 0;       /* TA2 means specific mode.  */
2412           NEXTBYTE ();
2413         }
2414
2415       if ((y & 2))
2416         NEXTBYTE ();            /* TB2 - ignore */
2417
2418       if ((y & 4))
2419         NEXTBYTE ();            /* TC2 - ignore */
2420
2421       if ((y & 8))
2422         {
2423           y = (atr[i] >> 4);    /* TD2 */
2424           t = atr[i] & 0x0f;
2425           NEXTBYTE ();
2426         }
2427       else
2428         y = 0;
2429
2430       while (y)
2431         {
2432           if ((y & 1))
2433             {                   /* TAx */
2434               if (t == 1)
2435                 param[5] = atr[i]; /* IFSC */
2436               else if (t == 15)
2437                 /* XXX: check voltage? */
2438                 param[4] = (atr[i] >> 6); /* ClockStop */
2439
2440               NEXTBYTE ();
2441             }
2442
2443           if ((y & 2))
2444             {
2445               if (t == 1)
2446                 param[3] = atr[i]; /* TBx - BWI & CWI */
2447               NEXTBYTE ();
2448             }
2449
2450           if ((y & 4))
2451             {
2452               if (t == 1)
2453                 param[1] |= (atr[i] & 0x01); /* TCx - LRC/CRC */
2454               NEXTBYTE ();
2455
2456               if (param[1] & 0x01)
2457                 return -4;      /* CRC not supported yet.  */
2458             }
2459
2460           if ((y & 8))
2461             {
2462               y = (atr[i] >> 4); /* TDx */
2463               t = atr[i] & 0x0f;
2464               NEXTBYTE ();
2465             }
2466           else
2467             y = 0;
2468         }
2469     }
2470
2471   i += historical_bytes_num - 1;
2472   NEXTBYTE ();
2473   if (atrlen != i+1)
2474     return -1;
2475
2476 #undef NEXTBYTE
2477
2478   chk = 0;
2479   do
2480     {
2481       chk ^= atr[i];
2482       i--;
2483     }
2484   while (i > 0);
2485
2486   if (chk != 0)
2487     return -1;
2488
2489   return negotiable;
2490 }
2491
2492
2493 /* Return the ATR of the card.  This is not a cached value and thus an
2494    actual reset is done.  */
2495 int
2496 ccid_get_atr (ccid_driver_t handle,
2497               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
2498 {
2499   int rc;
2500   int statusbits;
2501   unsigned char msg[100];
2502   unsigned char *tpdu;
2503   size_t msglen, tpdulen;
2504   unsigned char seqno;
2505   int use_crc = 0;
2506   unsigned int edc;
2507   int tried_iso = 0;
2508   int got_param;
2509   unsigned char param[7] = { /* For Protocol T=1 */
2510     0x11, /* bmFindexDindex */
2511     0x10, /* bmTCCKST1 */
2512     0x00, /* bGuardTimeT1 */
2513     0x4d, /* bmWaitingIntegersT1 */
2514     0x00, /* bClockStop */
2515     0x20, /* bIFSC */
2516     0x00  /* bNadValue */
2517   };
2518
2519   /* First check whether a card is available.  */
2520   rc = ccid_slot_status (handle, &statusbits, 1);
2521   if (rc)
2522     return rc;
2523   if (statusbits == 2)
2524     return CCID_DRIVER_ERR_NO_CARD;
2525
2526   /* For an inactive and also for an active card, issue the PowerOn
2527      command to get the ATR.  */
2528  again:
2529   msg[0] = PC_to_RDR_IccPowerOn;
2530   msg[5] = 0; /* slot */
2531   msg[6] = seqno = handle->seqno++;
2532   /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
2533   msg[7] = handle->auto_voltage ? 0 : 1;
2534   msg[8] = 0; /* RFU */
2535   msg[9] = 0; /* RFU */
2536   set_msg_len (msg, 0);
2537   msglen = 10;
2538
2539   rc = bulk_out (handle, msg, msglen, 0);
2540   if (rc)
2541     return rc;
2542   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2543                 seqno, 5000, 0);
2544   if (rc)
2545     return rc;
2546   if (!tried_iso && CCID_COMMAND_FAILED (msg) && CCID_ERROR_CODE (msg) == 0xbb
2547       && ((handle->id_vendor == VENDOR_CHERRY
2548            && handle->id_product == 0x0005)
2549           || (handle->id_vendor == VENDOR_GEMPC
2550               && handle->id_product == 0x4433)
2551           ))
2552     {
2553       tried_iso = 1;
2554       /* Try switching to ISO mode. */
2555       if (!send_escape_cmd (handle, (const unsigned char*)"\xF1\x01", 2,
2556                             NULL, 0, NULL))
2557         goto again;
2558     }
2559   else if (CCID_COMMAND_FAILED (msg))
2560     return CCID_DRIVER_ERR_CARD_IO_ERROR;
2561
2562
2563   handle->powered_off = 0;
2564
2565   if (atr)
2566     {
2567       size_t n = msglen - 10;
2568
2569       if (n > maxatrlen)
2570         n = maxatrlen;
2571       memcpy (atr, msg+10, n);
2572       *atrlen = n;
2573     }
2574
2575   param[6] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2576   rc = update_param_by_atr (param, msg+10, msglen - 10);
2577   if (rc < 0)
2578     {
2579       DEBUGOUT_1 ("update_param_by_atr failed: %d\n", rc);
2580       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2581     }
2582
2583   got_param = 0;
2584
2585   if (handle->auto_param)
2586     {
2587       msg[0] = PC_to_RDR_GetParameters;
2588       msg[5] = 0; /* slot */
2589       msg[6] = seqno = handle->seqno++;
2590       msg[7] = 0; /* RFU */
2591       msg[8] = 0; /* RFU */
2592       msg[9] = 0; /* RFU */
2593       set_msg_len (msg, 0);
2594       msglen = 10;
2595       rc = bulk_out (handle, msg, msglen, 0);
2596       if (!rc)
2597         rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2598                       seqno, 2000, 0);
2599       if (rc)
2600         DEBUGOUT ("GetParameters failed\n");
2601       else if (msglen == 17 && msg[9] == 1)
2602         got_param = 1;
2603     }
2604   else if (handle->auto_pps)
2605     ;
2606   else if (rc == 1)             /* It's negotiable, send PPS.  */
2607     {
2608       msg[0] = PC_to_RDR_XfrBlock;
2609       msg[5] = 0; /* slot */
2610       msg[6] = seqno = handle->seqno++;
2611       msg[7] = 0;
2612       msg[8] = 0;
2613       msg[9] = 0;
2614       msg[10] = 0xff;           /* PPSS */
2615       msg[11] = 0x11;           /* PPS0: PPS1, Protocol T=1 */
2616       msg[12] = param[0];       /* PPS1: Fi / Di */
2617       msg[13] = 0xff ^ 0x11 ^ param[0]; /* PCK */
2618       set_msg_len (msg, 4);
2619       msglen = 10 + 4;
2620
2621       rc = bulk_out (handle, msg, msglen, 0);
2622       if (rc)
2623         return rc;
2624
2625       rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2626                     seqno, 5000, 0);
2627       if (rc)
2628         return rc;
2629
2630       if (msglen != 10 + 4)
2631         {
2632           DEBUGOUT_1 ("Setting PPS failed: %zu\n", msglen);
2633           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2634         }
2635
2636       if (msg[10] != 0xff || msg[11] != 0x11 || msg[12] != param[0])
2637         {
2638           DEBUGOUT_1 ("Setting PPS failed: 0x%02x\n", param[0]);
2639           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2640         }
2641     }
2642
2643   /* Setup parameters to select T=1. */
2644   msg[0] = PC_to_RDR_SetParameters;
2645   msg[5] = 0; /* slot */
2646   msg[6] = seqno = handle->seqno++;
2647   msg[7] = 1; /* Select T=1. */
2648   msg[8] = 0; /* RFU */
2649   msg[9] = 0; /* RFU */
2650
2651   if (!got_param)
2652     memcpy (&msg[10], param, 7);
2653   set_msg_len (msg, 7);
2654   msglen = 10 + 7;
2655
2656   rc = bulk_out (handle, msg, msglen, 0);
2657   if (rc)
2658     return rc;
2659   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2660                 seqno, 5000, 0);
2661   if (rc)
2662     DEBUGOUT ("SetParameters failed (ignored)\n");
2663
2664   if (!rc && msglen > 15 && msg[15] >= 16 && msg[15] <= 254 )
2665     handle->ifsc = msg[15];
2666   else
2667     handle->ifsc = 128; /* Something went wrong, assume 128 bytes.  */
2668
2669   if (handle->nonnull_nad && msglen > 16 && msg[16] == 0)
2670     {
2671       DEBUGOUT ("Use Null-NAD, clearing handle->nonnull_nad.\n");
2672       handle->nonnull_nad = 0;
2673     }
2674
2675   handle->t1_ns = 0;
2676   handle->t1_nr = 0;
2677
2678   /* Send an S-Block with our maximum IFSD to the CCID.  */
2679   if (!handle->apdu_level && !handle->auto_ifsd)
2680     {
2681       tpdu = msg+10;
2682       /* NAD: DAD=1, SAD=0 */
2683       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2684       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
2685       tpdu[2] = 1;
2686       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32;
2687       tpdulen = 4;
2688       edc = compute_edc (tpdu, tpdulen, use_crc);
2689       if (use_crc)
2690         tpdu[tpdulen++] = (edc >> 8);
2691       tpdu[tpdulen++] = edc;
2692
2693       msg[0] = PC_to_RDR_XfrBlock;
2694       msg[5] = 0; /* slot */
2695       msg[6] = seqno = handle->seqno++;
2696       msg[7] = 0;
2697       msg[8] = 0; /* RFU */
2698       msg[9] = 0; /* RFU */
2699       set_msg_len (msg, tpdulen);
2700       msglen = 10 + tpdulen;
2701
2702       if (debug_level > 1)
2703         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
2704                       ((msg[11] & 0xc0) == 0x80)? 'R' :
2705                                 (msg[11] & 0x80)? 'S' : 'I',
2706                       ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2707                                        : !!(msg[11] & 0x40)),
2708                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2709
2710       rc = bulk_out (handle, msg, msglen, 0);
2711       if (rc)
2712         return rc;
2713
2714
2715       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2716                     RDR_to_PC_DataBlock, seqno, 5000, 0);
2717       if (rc)
2718         return rc;
2719
2720       tpdu = msg + 10;
2721       tpdulen = msglen - 10;
2722
2723       if (tpdulen < 4)
2724         return CCID_DRIVER_ERR_ABORTED;
2725
2726       if (debug_level > 1)
2727         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
2728                     ((msg[11] & 0xc0) == 0x80)? 'R' :
2729                               (msg[11] & 0x80)? 'S' : 'I',
2730                     ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2731                                      : !!(msg[11] & 0x40)),
2732                     ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
2733                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2734
2735       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
2736         {
2737           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
2738           return -1;
2739         }
2740       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
2741     }
2742
2743   return 0;
2744 }
2745
2746
2747 \f
2748
2749 static unsigned int
2750 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
2751 {
2752   if (use_crc)
2753     {
2754       return 0x42; /* Not yet implemented. */
2755     }
2756   else
2757     {
2758       unsigned char crc = 0;
2759
2760       for (; datalen; datalen--)
2761         crc ^= *data++;
2762       return crc;
2763     }
2764 }
2765
2766
2767 /* Return true if APDU is an extended length one.  */
2768 static int
2769 is_exlen_apdu (const unsigned char *apdu, size_t apdulen)
2770 {
2771   if (apdulen < 7 || apdu[4])
2772     return 0;  /* Too short or no Z byte.  */
2773   return 1;
2774 }
2775
2776
2777 /* Helper for ccid_transceive used for APDU level exchanges.  */
2778 static int
2779 ccid_transceive_apdu_level (ccid_driver_t handle,
2780                             const unsigned char *apdu_buf, size_t apdu_len,
2781                             unsigned char *resp, size_t maxresplen,
2782                             size_t *nresp)
2783 {
2784   int rc;
2785   unsigned char msg[CCID_MAX_BUF];
2786   const unsigned char *apdu_p;
2787   size_t apdu_part_len;
2788   size_t msglen;
2789   unsigned char seqno;
2790   int bwi = 4;
2791   unsigned char chain = 0;
2792
2793   if (apdu_len == 0 || apdu_len > sizeof (msg) - 10)
2794     return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
2795
2796   apdu_p = apdu_buf;
2797   while (1)
2798     {
2799       apdu_part_len = apdu_len;
2800       if (apdu_part_len > handle->max_ccid_msglen - 10)
2801         {
2802           apdu_part_len = handle->max_ccid_msglen - 10;
2803           chain |= 0x01;
2804         }
2805
2806       msg[0] = PC_to_RDR_XfrBlock;
2807       msg[5] = 0; /* slot */
2808       msg[6] = seqno = handle->seqno++;
2809       msg[7] = bwi;
2810       msg[8] = chain;
2811       msg[9] = 0;
2812       memcpy (msg+10, apdu_p, apdu_part_len);
2813       set_msg_len (msg, apdu_part_len);
2814       msglen = 10 + apdu_part_len;
2815
2816       rc = bulk_out (handle, msg, msglen, 0);
2817       if (rc)
2818         return rc;
2819
2820       apdu_p += apdu_part_len;
2821       apdu_len -= apdu_part_len;
2822
2823       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2824                     RDR_to_PC_DataBlock, seqno, CCID_CMD_TIMEOUT, 0);
2825       if (rc)
2826         return rc;
2827
2828       if (!(chain & 0x01))
2829         break;
2830
2831       chain = 0x02;
2832     }
2833
2834   apdu_len = 0;
2835   while (1)
2836     {
2837       apdu_part_len = msglen - 10;
2838       if (resp && apdu_len + apdu_part_len <= maxresplen)
2839         memcpy (resp + apdu_len, msg+10, apdu_part_len);
2840       apdu_len += apdu_part_len;
2841
2842       if (!(msg[9] & 0x01))
2843         break;
2844
2845       msg[0] = PC_to_RDR_XfrBlock;
2846       msg[5] = 0; /* slot */
2847       msg[6] = seqno = handle->seqno++;
2848       msg[7] = bwi;
2849       msg[8] = 0x10;                /* Request next data block */
2850       msg[9] = 0;
2851       set_msg_len (msg, 0);
2852       msglen = 10;
2853
2854       rc = bulk_out (handle, msg, msglen, 0);
2855       if (rc)
2856         return rc;
2857
2858       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2859                     RDR_to_PC_DataBlock, seqno, CCID_CMD_TIMEOUT, 0);
2860       if (rc)
2861         return rc;
2862     }
2863
2864   if (resp)
2865     {
2866       if (apdu_len > maxresplen)
2867         {
2868           DEBUGOUT_2 ("provided buffer too short for received data "
2869                       "(%u/%u)\n",
2870                       (unsigned int)apdu_len, (unsigned int)maxresplen);
2871           return CCID_DRIVER_ERR_INV_VALUE;
2872         }
2873
2874       *nresp = apdu_len;
2875     }
2876
2877   return 0;
2878 }
2879
2880
2881
2882 /*
2883   Protocol T=1 overview
2884
2885   Block Structure:
2886            Prologue Field:
2887    1 byte     Node Address (NAD)
2888    1 byte     Protocol Control Byte (PCB)
2889    1 byte     Length (LEN)
2890            Information Field:
2891    0-254 byte APDU or Control Information (INF)
2892            Epilogue Field:
2893    1 byte     Error Detection Code (EDC)
2894
2895   NAD:
2896    bit 7     unused
2897    bit 4..6  Destination Node Address (DAD)
2898    bit 3     unused
2899    bit 2..0  Source Node Address (SAD)
2900
2901    If node adresses are not used, SAD and DAD should be set to 0 on
2902    the first block sent to the card.  If they are used they should
2903    have different values (0 for one is okay); that first block sets up
2904    the addresses of the nodes.
2905
2906   PCB:
2907    Information Block (I-Block):
2908       bit 7    0
2909       bit 6    Sequence number (yep, that is modulo 2)
2910       bit 5    Chaining flag
2911       bit 4..0 reserved
2912    Received-Ready Block (R-Block):
2913       bit 7    1
2914       bit 6    0
2915       bit 5    0
2916       bit 4    Sequence number
2917       bit 3..0  0 = no error
2918                 1 = EDC or parity error
2919                 2 = other error
2920                 other values are reserved
2921    Supervisory Block (S-Block):
2922       bit 7    1
2923       bit 6    1
2924       bit 5    clear=request,set=response
2925       bit 4..0  0 = resyncronisation request
2926                 1 = information field size request
2927                 2 = abort request
2928                 3 = extension of BWT request
2929                 4 = VPP error
2930                 other values are reserved
2931
2932 */
2933
2934 int
2935 ccid_transceive (ccid_driver_t handle,
2936                  const unsigned char *apdu_buf, size_t apdu_buflen,
2937                  unsigned char *resp, size_t maxresplen, size_t *nresp)
2938 {
2939   int rc;
2940   /* The size of the buffer used to be 10+259.  For the via_escape
2941      hack we need one extra byte, thus 11+259.  */
2942   unsigned char send_buffer[11+259], recv_buffer[11+259];
2943   const unsigned char *apdu;
2944   size_t apdulen;
2945   unsigned char *msg, *tpdu, *p;
2946   size_t msglen, tpdulen, last_tpdulen, n;
2947   unsigned char seqno;
2948   unsigned int edc;
2949   int use_crc = 0;
2950   int hdrlen, pcboff;
2951   size_t dummy_nresp;
2952   int via_escape = 0;
2953   int next_chunk = 1;
2954   int sending = 1;
2955   int retries = 0;
2956   int resyncing = 0;
2957   int nad_byte;
2958   int wait_more = 0;
2959
2960   if (!nresp)
2961     nresp = &dummy_nresp;
2962   *nresp = 0;
2963
2964   /* Smarter readers allow sending APDUs directly; divert here. */
2965   if (handle->apdu_level)
2966     {
2967       /* We employ a hack for Omnikey readers which are able to send
2968          TPDUs using an escape sequence.  There is no documentation
2969          but the Windows driver does it this way.  Tested using a
2970          CM6121.  This method works also for the Cherry XX44
2971          keyboards; however there are problems with the
2972          ccid_transceive_secure which leads to a loss of sync on the
2973          CCID level.  If Cherry wants to make their keyboard work
2974          again, they should hand over some docs. */
2975       if ((handle->id_vendor == VENDOR_OMNIKEY)
2976           && handle->apdu_level < 2
2977           && is_exlen_apdu (apdu_buf, apdu_buflen))
2978         via_escape = 1;
2979       else
2980         return ccid_transceive_apdu_level (handle, apdu_buf, apdu_buflen,
2981                                            resp, maxresplen, nresp);
2982     }
2983
2984   /* The other readers we support require sending TPDUs.  */
2985
2986   tpdulen = 0; /* Avoid compiler warning about no initialization. */
2987   msg = send_buffer;
2988   hdrlen = via_escape? 11 : 10;
2989
2990   /* NAD: DAD=1, SAD=0 */
2991   nad_byte = handle->nonnull_nad? ((1 << 4) | 0): 0;
2992   if (via_escape)
2993     nad_byte = 0;
2994
2995   last_tpdulen = 0;  /* Avoid gcc warning (controlled by RESYNCING). */
2996   for (;;)
2997     {
2998       if (next_chunk)
2999         {
3000           next_chunk = 0;
3001
3002           apdu = apdu_buf;
3003           apdulen = apdu_buflen;
3004           assert (apdulen);
3005
3006           /* Construct an I-Block. */
3007           tpdu = msg + hdrlen;
3008           tpdu[0] = nad_byte;
3009           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
3010           if (apdulen > handle->ifsc )
3011             {
3012               apdulen = handle->ifsc;
3013               apdu_buf += handle->ifsc;
3014               apdu_buflen -= handle->ifsc;
3015               tpdu[1] |= (1 << 5); /* Set more bit. */
3016             }
3017           tpdu[2] = apdulen;
3018           memcpy (tpdu+3, apdu, apdulen);
3019           tpdulen = 3 + apdulen;
3020           edc = compute_edc (tpdu, tpdulen, use_crc);
3021           if (use_crc)
3022             tpdu[tpdulen++] = (edc >> 8);
3023           tpdu[tpdulen++] = edc;
3024         }
3025
3026       if (via_escape)
3027         {
3028           msg[0] = PC_to_RDR_Escape;
3029           msg[5] = 0; /* slot */
3030           msg[6] = seqno = handle->seqno++;
3031           msg[7] = 0; /* RFU */
3032           msg[8] = 0; /* RFU */
3033           msg[9] = 0; /* RFU */
3034           msg[10] = 0x1a; /* Omnikey command to send a TPDU.  */
3035           set_msg_len (msg, 1 + tpdulen);
3036         }
3037       else
3038         {
3039           msg[0] = PC_to_RDR_XfrBlock;
3040           msg[5] = 0; /* slot */
3041           msg[6] = seqno = handle->seqno++;
3042           msg[7] = 4; /* bBWI */
3043           msg[8] = 0; /* RFU */
3044           msg[9] = 0; /* RFU */
3045           set_msg_len (msg, tpdulen);
3046         }
3047       msglen = hdrlen + tpdulen;
3048       if (!resyncing)
3049         last_tpdulen = tpdulen;
3050       pcboff = hdrlen+1;
3051
3052       if (debug_level > 1)
3053         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
3054                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3055                     (msg[pcboff] & 0x80)? 'S' : 'I',
3056                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3057                      : !!(msg[pcboff] & 0x40)),
3058                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3059                      " [more]":""));
3060
3061       rc = bulk_out (handle, msg, msglen, 0);
3062       if (rc)
3063         return rc;
3064
3065       msg = recv_buffer;
3066       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3067                     via_escape? RDR_to_PC_Escape : RDR_to_PC_DataBlock, seqno,
3068                     wait_more? CCID_CMD_TIMEOUT_LONGER: CCID_CMD_TIMEOUT, 0);
3069       if (rc)
3070         return rc;
3071
3072       tpdu = msg + hdrlen;
3073       tpdulen = msglen - hdrlen;
3074       resyncing = 0;
3075
3076       if (tpdulen < 4)
3077         {
3078 #ifdef USE_NPTH
3079           npth_unprotect ();
3080 #endif
3081           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
3082 #ifdef USE_NPTH
3083           npth_protect ();
3084 #endif
3085           return CCID_DRIVER_ERR_ABORTED;
3086         }
3087
3088       if (debug_level > 1)
3089         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3090                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3091                               (msg[pcboff] & 0x80)? 'S' : 'I',
3092                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3093                      : !!(msg[pcboff] & 0x40)),
3094                     ((msg[pcboff] & 0xc0) == 0x80)? (msg[pcboff] & 0x0f) : 0,
3095                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3096                      " [more]":""));
3097
3098       if (!(tpdu[1] & 0x80))
3099         { /* This is an I-block. */
3100           retries = 0;
3101           if (sending)
3102             { /* last block sent was successful. */
3103               handle->t1_ns ^= 1;
3104               sending = 0;
3105             }
3106
3107           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3108             { /* Response does not match our sequence number. */
3109               msg = send_buffer;
3110               tpdu = msg + hdrlen;
3111               tpdu[0] = nad_byte;
3112               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
3113               tpdu[2] = 0;
3114               tpdulen = 3;
3115               edc = compute_edc (tpdu, tpdulen, use_crc);
3116               if (use_crc)
3117                 tpdu[tpdulen++] = (edc >> 8);
3118               tpdu[tpdulen++] = edc;
3119
3120               continue;
3121             }
3122
3123           handle->t1_nr ^= 1;
3124
3125           p = tpdu + 3; /* Skip the prologue field. */
3126           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3127           /* fixme: verify the checksum. */
3128           if (resp)
3129             {
3130               if (n > maxresplen)
3131                 {
3132                   DEBUGOUT_2 ("provided buffer too short for received data "
3133                               "(%u/%u)\n",
3134                               (unsigned int)n, (unsigned int)maxresplen);
3135                   return CCID_DRIVER_ERR_INV_VALUE;
3136                 }
3137
3138               memcpy (resp, p, n);
3139               resp += n;
3140               *nresp += n;
3141               maxresplen -= n;
3142             }
3143
3144           if (!(tpdu[1] & 0x20))
3145             return 0; /* No chaining requested - ready. */
3146
3147           msg = send_buffer;
3148           tpdu = msg + hdrlen;
3149           tpdu[0] = nad_byte;
3150           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
3151           tpdu[2] = 0;
3152           tpdulen = 3;
3153           edc = compute_edc (tpdu, tpdulen, use_crc);
3154           if (use_crc)
3155             tpdu[tpdulen++] = (edc >> 8);
3156           tpdu[tpdulen++] = edc;
3157         }
3158       else if ((tpdu[1] & 0xc0) == 0x80)
3159         { /* This is a R-block. */
3160           if ( (tpdu[1] & 0x0f))
3161             {
3162               retries++;
3163               if (via_escape && retries == 1 && (msg[pcboff] & 0x0f))
3164                 {
3165                   /* Error probably due to switching to TPDU.  Send a
3166                      resync request.  We use the recv_buffer so that
3167                      we don't corrupt the send_buffer.  */
3168                   msg = recv_buffer;
3169                   tpdu = msg + hdrlen;
3170                   tpdu[0] = nad_byte;
3171                   tpdu[1] = 0xc0; /* S-block resync request. */
3172                   tpdu[2] = 0;
3173                   tpdulen = 3;
3174                   edc = compute_edc (tpdu, tpdulen, use_crc);
3175                   if (use_crc)
3176                     tpdu[tpdulen++] = (edc >> 8);
3177                   tpdu[tpdulen++] = edc;
3178                   resyncing = 1;
3179                   DEBUGOUT ("T=1: requesting resync\n");
3180                 }
3181               else if (retries > 3)
3182                 {
3183                   DEBUGOUT ("T=1: 3 failed retries\n");
3184                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
3185                 }
3186               else
3187                 {
3188                   /* Error: repeat last block */
3189                   msg = send_buffer;
3190                   tpdulen = last_tpdulen;
3191                 }
3192             }
3193           else if (sending && !!(tpdu[1] & 0x10) == handle->t1_ns)
3194             { /* Response does not match our sequence number. */
3195               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
3196               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3197             }
3198           else if (sending)
3199             { /* Send next chunk. */
3200               retries = 0;
3201               msg = send_buffer;
3202               next_chunk = 1;
3203               handle->t1_ns ^= 1;
3204             }
3205           else
3206             {
3207               DEBUGOUT ("unexpected ACK R-block received\n");
3208               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3209             }
3210         }
3211       else
3212         { /* This is a S-block. */
3213           retries = 0;
3214           DEBUGOUT_2 ("T=1: S-block %s received cmd=%d\n",
3215                       (tpdu[1] & 0x20)? "response": "request",
3216                       (tpdu[1] & 0x1f));
3217           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 1 && tpdu[2] == 1)
3218             {
3219               /* Information field size request.  */
3220               unsigned char ifsc = tpdu[3];
3221
3222               if (ifsc < 16 || ifsc > 254)
3223                 return CCID_DRIVER_ERR_CARD_IO_ERROR;
3224
3225               msg = send_buffer;
3226               tpdu = msg + hdrlen;
3227               tpdu[0] = nad_byte;
3228               tpdu[1] = (0xc0 | 0x20 | 1); /* S-block response */
3229               tpdu[2] = 1;
3230               tpdu[3] = ifsc;
3231               tpdulen = 4;
3232               edc = compute_edc (tpdu, tpdulen, use_crc);
3233               if (use_crc)
3234                 tpdu[tpdulen++] = (edc >> 8);
3235               tpdu[tpdulen++] = edc;
3236               DEBUGOUT_1 ("T=1: requesting an ifsc=%d\n", ifsc);
3237             }
3238           else if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
3239             {
3240               /* Wait time extension request. */
3241               unsigned char bwi = tpdu[3];
3242
3243               /* Check if it's unsual value which can't be expressed in ATR.  */
3244               if (bwi > 15)
3245                 wait_more = 1;
3246
3247               msg = send_buffer;
3248               tpdu = msg + hdrlen;
3249               tpdu[0] = nad_byte;
3250               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
3251               tpdu[2] = 1;
3252               tpdu[3] = bwi;
3253               tpdulen = 4;
3254               edc = compute_edc (tpdu, tpdulen, use_crc);
3255               if (use_crc)
3256                 tpdu[tpdulen++] = (edc >> 8);
3257               tpdu[tpdulen++] = edc;
3258               DEBUGOUT_1 ("T=1: waittime extension of bwi=%d\n", bwi);
3259               print_progress (handle);
3260             }
3261           else if ( (tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 0 && !tpdu[2])
3262             {
3263               DEBUGOUT ("T=1: resync ack from reader\n");
3264               /* Repeat previous block.  */
3265               msg = send_buffer;
3266               tpdulen = last_tpdulen;
3267             }
3268           else
3269             return CCID_DRIVER_ERR_CARD_IO_ERROR;
3270         }
3271     } /* end T=1 protocol loop. */
3272
3273   return 0;
3274 }
3275
3276
3277 /* Send the CCID Secure command to the reader.  APDU_BUF should
3278    contain the APDU template.  PIN_MODE defines how the pin gets
3279    formatted:
3280
3281      1 := The PIN is ASCII encoded and of variable length.  The
3282           length of the PIN entered will be put into Lc by the reader.
3283           The APDU should me made up of 4 bytes without Lc.
3284
3285    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
3286    may be used t enable reasonable defaults.
3287
3288    When called with RESP and NRESP set to NULL, the function will
3289    merely check whether the reader supports the secure command for the
3290    given APDU and PIN_MODE. */
3291 int
3292 ccid_transceive_secure (ccid_driver_t handle,
3293                         const unsigned char *apdu_buf, size_t apdu_buflen,
3294                         pininfo_t *pininfo,
3295                         unsigned char *resp, size_t maxresplen, size_t *nresp)
3296 {
3297   int rc;
3298   unsigned char send_buffer[10+259], recv_buffer[10+259];
3299   unsigned char *msg, *tpdu, *p;
3300   size_t msglen, tpdulen, n;
3301   unsigned char seqno;
3302   size_t dummy_nresp;
3303   int testmode;
3304   int cherry_mode = 0;
3305   int add_zero = 0;
3306   int enable_varlen = 0;
3307
3308   testmode = !resp && !nresp;
3309
3310   if (!nresp)
3311     nresp = &dummy_nresp;
3312   *nresp = 0;
3313
3314   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
3315     ;
3316   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
3317     ;
3318   else
3319     return CCID_DRIVER_ERR_NO_PINPAD;
3320
3321   if (!pininfo->minlen)
3322     pininfo->minlen = 1;
3323   if (!pininfo->maxlen)
3324     pininfo->maxlen = 15;
3325
3326   /* Note that the 25 is the maximum value the SPR532 allows.  */
3327   if (pininfo->minlen < 1 || pininfo->minlen > 25
3328       || pininfo->maxlen < 1 || pininfo->maxlen > 25
3329       || pininfo->minlen > pininfo->maxlen)
3330     return CCID_DRIVER_ERR_INV_VALUE;
3331
3332   /* We have only tested a few readers so better don't risk anything
3333      and do not allow the use with other readers. */
3334   switch (handle->id_vendor)
3335     {
3336     case VENDOR_SCM:  /* Tested with SPR 532. */
3337     case VENDOR_KAAN: /* Tested with KAAN Advanced (1.02). */
3338     case VENDOR_FSIJ: /* Tested with Gnuk (0.21). */
3339       pininfo->maxlen = 25;
3340       enable_varlen = 1;
3341       break;
3342     case VENDOR_REINER:/* Tested with cyberJack go */
3343     case VENDOR_VASCO: /* Tested with DIGIPASS 920 */
3344       enable_varlen = 1;
3345       break;
3346     case VENDOR_CHERRY:
3347       pininfo->maxlen = 15;
3348       enable_varlen = 1;
3349       /* The CHERRY XX44 keyboard echos an asterisk for each entered
3350          character on the keyboard channel.  We use a special variant
3351          of PC_to_RDR_Secure which directs these characters to the
3352          smart card's bulk-in channel.  We also need to append a zero
3353          Lc byte to the APDU.  It seems that it will be replaced with
3354          the actual length instead of being appended before the APDU
3355          is send to the card. */
3356       add_zero = 1;
3357       if (handle->id_product != CHERRY_ST2000)
3358         cherry_mode = 1;
3359       break;
3360     default:
3361       if ((handle->id_vendor == VENDOR_GEMPC &&
3362            handle->id_product == GEMPC_PINPAD)
3363           || (handle->id_vendor == VENDOR_VEGA &&
3364               handle->id_product == VEGA_ALPHA))
3365         {
3366           enable_varlen = 0;
3367           pininfo->minlen = 4;
3368           pininfo->maxlen = 8;
3369           break;
3370         }
3371      return CCID_DRIVER_ERR_NOT_SUPPORTED;
3372     }
3373
3374   if (enable_varlen)
3375     pininfo->fixedlen = 0;
3376
3377   if (testmode)
3378     return 0; /* Success */
3379
3380   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
3381     return CCID_DRIVER_ERR_NOT_SUPPORTED;
3382
3383   msg = send_buffer;
3384   if (handle->id_vendor == VENDOR_SCM)
3385     {
3386       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
3387       rc = send_escape_cmd (handle, (const unsigned char*)"\x80\x02\x00", 3,
3388                             NULL, 0, NULL);
3389       if (rc)
3390         return rc;
3391     }
3392
3393   msg[0] = cherry_mode? 0x89 : PC_to_RDR_Secure;
3394   msg[5] = 0; /* slot */
3395   msg[6] = seqno = handle->seqno++;
3396   msg[7] = 0; /* bBWI */
3397   msg[8] = 0; /* RFU */
3398   msg[9] = 0; /* RFU */
3399   msg[10] = apdu_buf[1] == 0x20 ? 0 : 1;
3400                /* Perform PIN verification or PIN modification. */
3401   msg[11] = 0; /* Timeout in seconds. */
3402   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
3403   if (handle->id_vendor == VENDOR_SCM)
3404     {
3405       /* For the SPR532 the next 2 bytes need to be zero.  We do this
3406          for all SCM products.  Kudos to Martin Paljak for this
3407          hint.  */
3408       msg[13] = msg[14] = 0;
3409     }
3410   else
3411     {
3412       msg[13] = pininfo->fixedlen; /* bmPINBlockString:
3413                                       0 bits of pin length to insert.
3414                                       PIN block size by fixedlen.  */
3415       msg[14] = 0x00; /* bmPINLengthFormat:
3416                          Units are bytes, position is 0. */
3417     }
3418
3419   msglen = 15;
3420   if (apdu_buf[1] == 0x24)
3421     {
3422       msg[msglen++] = 0;    /* bInsertionOffsetOld */
3423       msg[msglen++] = pininfo->fixedlen;    /* bInsertionOffsetNew */
3424     }
3425
3426   /* The following is a little endian word. */
3427   msg[msglen++] = pininfo->maxlen;   /* wPINMaxExtraDigit-Maximum.  */
3428   msg[msglen++] = pininfo->minlen;   /* wPINMaxExtraDigit-Minimum.  */
3429
3430   if (apdu_buf[1] == 0x24)
3431     msg[msglen++] = apdu_buf[2] == 0 ? 0x03 : 0x01;
3432               /* bConfirmPIN
3433                *    0x00: new PIN once
3434                *    0x01: new PIN twice (confirmation)
3435                *    0x02: old PIN and new PIN once
3436                *    0x03: old PIN and new PIN twice (confirmation)
3437                */
3438
3439   msg[msglen] = 0x02; /* bEntryValidationCondition:
3440                          Validation key pressed */
3441   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
3442     msg[msglen] |= 0x01; /* Max size reached.  */
3443   msglen++;
3444
3445   if (apdu_buf[1] == 0x20)
3446     msg[msglen++] = 0x01; /* bNumberMessage. */
3447   else
3448     msg[msglen++] = 0x03; /* bNumberMessage. */
3449
3450   msg[msglen++] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
3451   msg[msglen++] = 0x04; /* wLangId-High. */
3452
3453   if (apdu_buf[1] == 0x20)
3454     msg[msglen++] = 0;    /* bMsgIndex. */
3455   else
3456     {
3457       msg[msglen++] = 0;    /* bMsgIndex1. */
3458       msg[msglen++] = 1;    /* bMsgIndex2. */
3459       msg[msglen++] = 2;    /* bMsgIndex3. */
3460     }
3461
3462   /* Calculate Lc.  */
3463   n = pininfo->fixedlen;
3464   if (apdu_buf[1] == 0x24)
3465     n += pininfo->fixedlen;
3466
3467   /* bTeoProlog follows: */
3468   msg[msglen++] = handle->nonnull_nad? ((1 << 4) | 0): 0;
3469   msg[msglen++] = ((handle->t1_ns & 1) << 6); /* I-block */
3470   if (n)
3471     msg[msglen++] = n + 5; /* apdulen should be filled for fixed length.  */
3472   else
3473     msg[msglen++] = 0; /* The apdulen will be filled in by the reader.  */
3474   /* APDU follows:  */
3475   msg[msglen++] = apdu_buf[0]; /* CLA */
3476   msg[msglen++] = apdu_buf[1]; /* INS */
3477   msg[msglen++] = apdu_buf[2]; /* P1 */
3478   msg[msglen++] = apdu_buf[3]; /* P2 */
3479   if (add_zero)
3480     msg[msglen++] = 0;
3481   else if (pininfo->fixedlen != 0)
3482     {
3483       msg[msglen++] = n;
3484       memset (&msg[msglen], 0xff, n);
3485       msglen += n;
3486     }
3487   /* An EDC is not required. */
3488   set_msg_len (msg, msglen - 10);
3489
3490   rc = bulk_out (handle, msg, msglen, 0);
3491   if (rc)
3492     return rc;
3493
3494   msg = recv_buffer;
3495   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3496                 RDR_to_PC_DataBlock, seqno, 30000, 0);
3497   if (rc)
3498     return rc;
3499
3500   tpdu = msg + 10;
3501   tpdulen = msglen - 10;
3502
3503   if (handle->apdu_level)
3504     {
3505       if (resp)
3506         {
3507           if (tpdulen > maxresplen)
3508             {
3509               DEBUGOUT_2 ("provided buffer too short for received data "
3510                           "(%u/%u)\n",
3511                           (unsigned int)tpdulen, (unsigned int)maxresplen);
3512               return CCID_DRIVER_ERR_INV_VALUE;
3513             }
3514
3515           memcpy (resp, tpdu, tpdulen);
3516           *nresp = tpdulen;
3517         }
3518       return 0;
3519     }
3520
3521   if (tpdulen < 4)
3522     {
3523 #ifdef USE_NPTH
3524       npth_unprotect ();
3525 #endif
3526       libusb_clear_halt (handle->idev, handle->ep_bulk_in);
3527 #ifdef USE_NPTH
3528       npth_protect ();
3529 #endif
3530       return CCID_DRIVER_ERR_ABORTED;
3531     }
3532   if (debug_level > 1)
3533     DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3534                 ((msg[11] & 0xc0) == 0x80)? 'R' :
3535                           (msg[11] & 0x80)? 'S' : 'I',
3536                 ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
3537                 ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
3538                 (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
3539
3540   if (!(tpdu[1] & 0x80))
3541     { /* This is an I-block. */
3542       /* Last block sent was successful. */
3543       handle->t1_ns ^= 1;
3544
3545       if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3546         { /* Response does not match our sequence number. */
3547           DEBUGOUT ("I-block with wrong seqno received\n");
3548           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3549         }
3550
3551       handle->t1_nr ^= 1;
3552
3553       p = tpdu + 3; /* Skip the prologue field. */
3554       n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3555       /* fixme: verify the checksum. */
3556       if (resp)
3557         {
3558           if (n > maxresplen)
3559             {
3560               DEBUGOUT_2 ("provided buffer too short for received data "
3561                           "(%u/%u)\n",
3562                           (unsigned int)n, (unsigned int)maxresplen);
3563               return CCID_DRIVER_ERR_INV_VALUE;
3564             }
3565
3566           memcpy (resp, p, n);
3567           *nresp += n;
3568         }
3569
3570       if (!(tpdu[1] & 0x20))
3571         return 0; /* No chaining requested - ready. */
3572
3573       DEBUGOUT ("chaining requested but not supported for Secure operation\n");
3574       return CCID_DRIVER_ERR_CARD_IO_ERROR;
3575     }
3576   else if ((tpdu[1] & 0xc0) == 0x80)
3577     { /* This is a R-block. */
3578       if ( (tpdu[1] & 0x0f))
3579         { /* Error: repeat last block */
3580           DEBUGOUT ("No retries supported for Secure operation\n");
3581           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3582         }
3583       else if (!!(tpdu[1] & 0x10) == handle->t1_ns)
3584         { /* Response does not match our sequence number. */
3585           DEBUGOUT ("R-block with wrong seqno received on more bit\n");
3586           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3587         }
3588       else
3589         { /* Send next chunk. */