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