305c9d2f4966e9bcad3c820b968aff4eba3bb8a6
[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 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 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   if (handle->ep_intr >= 0)
2077     return 0;
2078
2079   /* Here comes products check for tokens which
2080      always have card inserted.  */
2081   switch (handle->id_vendor)
2082     {
2083     case VENDOR_FSIJ:
2084       return 0;
2085     }
2086
2087   return 1;
2088 }
2089
2090
2091 static void
2092 do_close_reader (ccid_driver_t handle)
2093 {
2094   int rc;
2095   unsigned char msg[100];
2096   size_t msglen;
2097   unsigned char seqno;
2098
2099   if (!handle->powered_off)
2100     {
2101       msg[0] = PC_to_RDR_IccPowerOff;
2102       msg[5] = 0; /* slot */
2103       msg[6] = seqno = handle->seqno++;
2104       msg[7] = 0; /* RFU */
2105       msg[8] = 0; /* RFU */
2106       msg[9] = 0; /* RFU */
2107       set_msg_len (msg, 0);
2108       msglen = 10;
2109
2110       rc = bulk_out (handle, msg, msglen, 0);
2111       if (!rc)
2112         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
2113                  seqno, 2000, 0);
2114     }
2115   if (handle->idev)
2116     {
2117       if (handle->transfer)
2118         {
2119           if (!handle->powered_off)
2120             {
2121               DEBUGOUT ("libusb_cancel_transfer\n");
2122
2123               rc = libusb_cancel_transfer (handle->transfer);
2124               if (rc != LIBUSB_ERROR_NOT_FOUND)
2125                 while (!handle->powered_off)
2126                   {
2127                     DEBUGOUT ("libusb_handle_events_completed\n");
2128 #ifdef USE_NPTH
2129                     npth_unprotect ();
2130 #endif
2131                     libusb_handle_events_completed (NULL, &handle->powered_off);
2132 #ifdef USE_NPTH
2133                     npth_protect ();
2134 #endif
2135                   }
2136             }
2137
2138           libusb_free_transfer (handle->transfer);
2139         }
2140       libusb_release_interface (handle->idev, handle->ifc_no);
2141       --ccid_usb_thread_is_alive;
2142       libusb_close (handle->idev);
2143       handle->idev = NULL;
2144     }
2145   if (handle->dev_fd != -1)
2146     {
2147       close (handle->dev_fd);
2148       handle->dev_fd = -1;
2149     }
2150 }
2151
2152
2153 int
2154 ccid_set_progress_cb (ccid_driver_t handle,
2155                       void (*cb)(void *, const char *, int, int, int),
2156                       void *cb_arg)
2157 {
2158   if (!handle)
2159     return CCID_DRIVER_ERR_INV_VALUE;
2160
2161   handle->progress_cb = cb;
2162   handle->progress_cb_arg = cb_arg;
2163   return 0;
2164 }
2165
2166
2167 /* Close the reader HANDLE. */
2168 int
2169 ccid_close_reader (ccid_driver_t handle)
2170 {
2171   if (!handle || (!handle->idev && handle->dev_fd == -1))
2172     return 0;
2173
2174   do_close_reader (handle);
2175   free (handle);
2176   return 0;
2177 }
2178
2179
2180 /* Return False if a card is present and powered. */
2181 int
2182 ccid_check_card_presence (ccid_driver_t handle)
2183 {
2184   (void)handle;  /* Not yet implemented.  */
2185   return -1;
2186 }
2187
2188
2189 /* Write NBYTES of BUF to file descriptor FD. */
2190 static int
2191 writen (int fd, const void *buf, size_t nbytes)
2192 {
2193   size_t nleft = nbytes;
2194   int nwritten;
2195
2196   while (nleft > 0)
2197     {
2198       nwritten = write (fd, buf, nleft);
2199       if (nwritten < 0)
2200         {
2201           if (errno == EINTR)
2202             nwritten = 0;
2203           else
2204             return -1;
2205         }
2206       nleft -= nwritten;
2207       buf = (const char*)buf + nwritten;
2208     }
2209
2210   return 0;
2211 }
2212
2213
2214 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
2215    Returns 0 on success. */
2216 static int
2217 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen,
2218           int no_debug)
2219 {
2220   int rc;
2221
2222   /* No need to continue and clutter the log with USB write error
2223      messages after we got the first ENODEV.  */
2224   if (handle->enodev_seen)
2225     return CCID_DRIVER_ERR_NO_READER;
2226
2227   if (debug_level && (!no_debug || debug_level >= 3))
2228     {
2229       switch (msglen? msg[0]:0)
2230         {
2231         case PC_to_RDR_IccPowerOn:
2232           print_p2r_iccpoweron (msg, msglen);
2233           break;
2234         case PC_to_RDR_IccPowerOff:
2235           print_p2r_iccpoweroff (msg, msglen);
2236           break;
2237         case PC_to_RDR_GetSlotStatus:
2238           print_p2r_getslotstatus (msg, msglen);
2239           break;
2240         case PC_to_RDR_XfrBlock:
2241           print_p2r_xfrblock (msg, msglen);
2242           break;
2243         case PC_to_RDR_GetParameters:
2244           print_p2r_getparameters (msg, msglen);
2245           break;
2246         case PC_to_RDR_ResetParameters:
2247           print_p2r_resetparameters (msg, msglen);
2248           break;
2249         case PC_to_RDR_SetParameters:
2250           print_p2r_setparameters (msg, msglen);
2251           break;
2252         case PC_to_RDR_Escape:
2253           print_p2r_escape (msg, msglen);
2254           break;
2255         case PC_to_RDR_IccClock:
2256           print_p2r_iccclock (msg, msglen);
2257           break;
2258         case PC_to_RDR_T0APDU:
2259           print_p2r_to0apdu (msg, msglen);
2260           break;
2261         case PC_to_RDR_Secure:
2262           print_p2r_secure (msg, msglen);
2263           break;
2264         case PC_to_RDR_Mechanical:
2265           print_p2r_mechanical (msg, msglen);
2266           break;
2267         case PC_to_RDR_Abort:
2268           print_p2r_abort (msg, msglen);
2269           break;
2270         case PC_to_RDR_SetDataRate:
2271           print_p2r_setdatarate (msg, msglen);
2272           break;
2273         default:
2274           print_p2r_unknown (msg, msglen);
2275           break;
2276         }
2277     }
2278
2279   if (handle->idev)
2280     {
2281       int transferred;
2282
2283 #ifdef USE_NPTH
2284       npth_unprotect ();
2285 #endif
2286       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
2287                                  (char*)msg, msglen, &transferred,
2288                                  5000 /* ms timeout */);
2289 #ifdef USE_NPTH
2290       npth_protect ();
2291 #endif
2292       if (rc == 0 && transferred == msglen)
2293         return 0;
2294
2295       if (rc)
2296         {
2297           DEBUGOUT_1 ("usb_bulk_write error: %s\n", libusb_error_name (rc));
2298           if (rc == LIBUSB_ERROR_NO_DEVICE)
2299             {
2300               handle->enodev_seen = 1;
2301               return CCID_DRIVER_ERR_NO_READER;
2302             }
2303         }
2304     }
2305   else
2306     {
2307       rc = writen (handle->dev_fd, msg, msglen);
2308       if (!rc)
2309         return 0;
2310       DEBUGOUT_2 ("writen to %d failed: %s\n",
2311                   handle->dev_fd, strerror (errno));
2312
2313     }
2314   return CCID_DRIVER_ERR_CARD_IO_ERROR;
2315 }
2316
2317
2318 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
2319    BUFFER and return the actual read number if bytes in NREAD. SEQNO
2320    is the sequence number used to send the request and EXPECTED_TYPE
2321    the type of message we expect. Does checks on the ccid
2322    header. TIMEOUT is the timeout value in ms. NO_DEBUG may be set to
2323    avoid debug messages in case of no error; this can be overriden
2324    with a glibal debug level of at least 3. Returns 0 on success. */
2325 static int
2326 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
2327          size_t *nread, int expected_type, int seqno, int timeout,
2328          int no_debug)
2329 {
2330   int rc;
2331   int msglen;
2332   int eagain_retries = 0;
2333
2334   /* Fixme: The next line for the current Valgrind without support
2335      for USB IOCTLs. */
2336   memset (buffer, 0, length);
2337  retry:
2338   if (handle->idev)
2339     {
2340 #ifdef USE_NPTH
2341       npth_unprotect ();
2342 #endif
2343       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
2344                                  (char*)buffer, length, &msglen, timeout);
2345 #ifdef USE_NPTH
2346       npth_protect ();
2347 #endif
2348       if (rc)
2349         {
2350           DEBUGOUT_1 ("usb_bulk_read error: %s\n", libusb_error_name (rc));
2351           if (rc == LIBUSB_ERROR_NO_DEVICE)
2352             {
2353               handle->enodev_seen = 1;
2354               return CCID_DRIVER_ERR_NO_READER;
2355             }
2356
2357           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2358         }
2359       if (msglen < 0)
2360         return CCID_DRIVER_ERR_INV_VALUE;  /* Faulty libusb.  */
2361       *nread = msglen;
2362     }
2363   else
2364     {
2365       rc = read (handle->dev_fd, buffer, length);
2366       if (rc < 0)
2367         {
2368           rc = errno;
2369           DEBUGOUT_2 ("read from %d failed: %s\n",
2370                       handle->dev_fd, strerror (rc));
2371           if (rc == EAGAIN && eagain_retries++ < 5)
2372             {
2373               my_sleep (1);
2374               goto retry;
2375             }
2376           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2377         }
2378       *nread = msglen = rc;
2379     }
2380   eagain_retries = 0;
2381
2382   if (msglen < 10)
2383     {
2384       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
2385       abort_cmd (handle, seqno);
2386       return CCID_DRIVER_ERR_INV_VALUE;
2387     }
2388   if (buffer[5] != 0)
2389     {
2390       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
2391       return CCID_DRIVER_ERR_INV_VALUE;
2392     }
2393   if (buffer[6] != seqno)
2394     {
2395       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
2396                   seqno, buffer[6]);
2397       /* Retry until we are synced again.  */
2398       goto retry;
2399     }
2400
2401   /* We need to handle the time extension request before we check that
2402      we got the expected message type.  This is in particular required
2403      for the Cherry keyboard which sends a time extension request for
2404      each key hit.  */
2405   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
2406     {
2407       /* Card present and active, time extension requested. */
2408       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
2409                   buffer[7], buffer[8]);
2410       goto retry;
2411     }
2412
2413   if (buffer[0] != expected_type)
2414     {
2415       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
2416       abort_cmd (handle, seqno);
2417       return CCID_DRIVER_ERR_INV_VALUE;
2418     }
2419
2420   if (debug_level && (!no_debug || debug_level >= 3))
2421     {
2422       switch (buffer[0])
2423         {
2424         case RDR_to_PC_DataBlock:
2425           print_r2p_datablock (buffer, msglen);
2426           break;
2427         case RDR_to_PC_SlotStatus:
2428           print_r2p_slotstatus (buffer, msglen);
2429           break;
2430         case RDR_to_PC_Parameters:
2431           print_r2p_parameters (buffer, msglen);
2432           break;
2433         case RDR_to_PC_Escape:
2434           print_r2p_escape (buffer, msglen);
2435           break;
2436         case RDR_to_PC_DataRate:
2437           print_r2p_datarate (buffer, msglen);
2438           break;
2439         default:
2440           print_r2p_unknown (buffer, msglen);
2441           break;
2442         }
2443     }
2444   if (CCID_COMMAND_FAILED (buffer))
2445     print_command_failed (buffer);
2446
2447   /* Check whether a card is at all available.  Note: If you add new
2448      error codes here, check whether they need to be ignored in
2449      send_escape_cmd. */
2450   switch ((buffer[7] & 0x03))
2451     {
2452     case 0: /* no error */ break;
2453     case 1: return CCID_DRIVER_ERR_CARD_INACTIVE;
2454     case 2: return CCID_DRIVER_ERR_NO_CARD;
2455     case 3: /* RFU */ break;
2456     }
2457   return 0;
2458 }
2459
2460
2461
2462 /* Send an abort sequence and wait until everything settled.  */
2463 static int
2464 abort_cmd (ccid_driver_t handle, int seqno)
2465 {
2466   int rc;
2467   char dummybuf[8];
2468   unsigned char msg[100];
2469   int msglen;
2470
2471   if (!handle->idev)
2472     {
2473       /* I don't know how to send an abort to non-USB devices.  */
2474       rc = CCID_DRIVER_ERR_NOT_SUPPORTED;
2475     }
2476
2477   seqno &= 0xff;
2478   DEBUGOUT_1 ("sending abort sequence for seqno %d\n", seqno);
2479   /* Send the abort command to the control pipe.  Note that we don't
2480      need to keep track of sent abort commands because there should
2481      never be another thread using the same slot concurrently.  */
2482 #ifdef USE_NPTH
2483   npth_unprotect ();
2484 #endif
2485   rc = libusb_control_transfer (handle->idev,
2486                                 0x21,/* bmRequestType: host-to-device,
2487                                         class specific, to interface.  */
2488                                 1,   /* ABORT */
2489                                 (seqno << 8 | 0 /* slot */),
2490                                 handle->ifc_no,
2491                                 dummybuf, 0,
2492                                 1000 /* ms timeout */);
2493 #ifdef USE_NPTH
2494   npth_protect ();
2495 #endif
2496   if (rc)
2497     {
2498       DEBUGOUT_1 ("usb_control_msg error: %s\n", libusb_error_name (rc));
2499       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2500     }
2501
2502   /* Now send the abort command to the bulk out pipe using the same
2503      SEQNO and SLOT.  Do this in a loop to so that all seqno are
2504      tried.  */
2505   seqno--;  /* Adjust for next increment.  */
2506   do
2507     {
2508       int transferred;
2509
2510       seqno++;
2511       msg[0] = PC_to_RDR_Abort;
2512       msg[5] = 0; /* slot */
2513       msg[6] = seqno;
2514       msg[7] = 0; /* RFU */
2515       msg[8] = 0; /* RFU */
2516       msg[9] = 0; /* RFU */
2517       msglen = 10;
2518       set_msg_len (msg, 0);
2519
2520 #ifdef USE_NPTH
2521       npth_unprotect ();
2522 #endif
2523       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
2524                                  (char*)msg, msglen, &transferred,
2525                                  5000 /* ms timeout */);
2526 #ifdef USE_NPTH
2527       npth_protect ();
2528 #endif
2529       if (rc == 0 && transferred == msglen)
2530         rc = 0;
2531       else if (rc)
2532         DEBUGOUT_1 ("usb_bulk_write error in abort_cmd: %s\n",
2533                     libusb_error_name (rc));
2534
2535       if (rc)
2536         return rc;
2537
2538 #ifdef USE_NPTH
2539       npth_unprotect ();
2540 #endif
2541       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
2542                                  (char*)msg, sizeof msg, &msglen,
2543                                  5000 /*ms timeout*/);
2544 #ifdef USE_NPTH
2545       npth_protect ();
2546 #endif
2547       if (rc)
2548         {
2549           DEBUGOUT_1 ("usb_bulk_read error in abort_cmd: %s\n",
2550                       libusb_error_name (rc));
2551           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2552         }
2553
2554       if (msglen < 10)
2555         {
2556           DEBUGOUT_1 ("bulk-in msg in abort_cmd too short (%u)\n",
2557                       (unsigned int)msglen);
2558           return CCID_DRIVER_ERR_INV_VALUE;
2559         }
2560       if (msg[5] != 0)
2561         {
2562           DEBUGOUT_1 ("unexpected bulk-in slot (%d) in abort_cmd\n", msg[5]);
2563           return CCID_DRIVER_ERR_INV_VALUE;
2564         }
2565
2566       DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n",
2567                   msg[7], msg[8], msg[9]);
2568       if (CCID_COMMAND_FAILED (msg))
2569         print_command_failed (msg);
2570     }
2571   while (msg[0] != RDR_to_PC_SlotStatus && msg[5] != 0 && msg[6] != seqno);
2572
2573   handle->seqno = ((seqno + 1) & 0xff);
2574   DEBUGOUT ("sending abort sequence succeeded\n");
2575
2576   return 0;
2577 }
2578
2579
2580 /* Note that this function won't return the error codes NO_CARD or
2581    CARD_INACTIVE.  IF RESULT is not NULL, the result from the
2582    operation will get returned in RESULT and its length in RESULTLEN.
2583    If the response is larger than RESULTMAX, an error is returned and
2584    the required buffer length returned in RESULTLEN.  */
2585 static int
2586 send_escape_cmd (ccid_driver_t handle,
2587                  const unsigned char *data, size_t datalen,
2588                  unsigned char *result, size_t resultmax, size_t *resultlen)
2589 {
2590   int rc;
2591   unsigned char msg[100];
2592   size_t msglen;
2593   unsigned char seqno;
2594
2595   if (resultlen)
2596     *resultlen = 0;
2597
2598   if (datalen > sizeof msg - 10)
2599     return CCID_DRIVER_ERR_INV_VALUE; /* Escape data too large.  */
2600
2601   msg[0] = PC_to_RDR_Escape;
2602   msg[5] = 0; /* slot */
2603   msg[6] = seqno = handle->seqno++;
2604   msg[7] = 0; /* RFU */
2605   msg[8] = 0; /* RFU */
2606   msg[9] = 0; /* RFU */
2607   memcpy (msg+10, data, datalen);
2608   msglen = 10 + datalen;
2609   set_msg_len (msg, datalen);
2610
2611   rc = bulk_out (handle, msg, msglen, 0);
2612   if (rc)
2613     return rc;
2614   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Escape,
2615                 seqno, 5000, 0);
2616   if (result)
2617     switch (rc)
2618       {
2619         /* We need to ignore certain errorcode here. */
2620       case 0:
2621       case CCID_DRIVER_ERR_CARD_INACTIVE:
2622       case CCID_DRIVER_ERR_NO_CARD:
2623         {
2624           if (msglen > resultmax)
2625             rc = CCID_DRIVER_ERR_INV_VALUE; /* Response too large. */
2626           else
2627             {
2628               memcpy (result, msg, msglen);
2629               *resultlen = msglen;
2630               rc = 0;
2631             }
2632         }
2633         break;
2634       default:
2635         break;
2636       }
2637
2638   return rc;
2639 }
2640
2641
2642 int
2643 ccid_transceive_escape (ccid_driver_t handle,
2644                         const unsigned char *data, size_t datalen,
2645                         unsigned char *resp, size_t maxresplen, size_t *nresp)
2646 {
2647   return send_escape_cmd (handle, data, datalen, resp, maxresplen, nresp);
2648 }
2649
2650
2651
2652 /* experimental */
2653 int
2654 ccid_poll (ccid_driver_t handle)
2655 {
2656   int rc;
2657   unsigned char msg[10];
2658   int msglen;
2659   int i, j;
2660
2661   if (handle->idev)
2662     {
2663       rc = libusb_interrupt_transfer (handle->idev, handle->ep_intr,
2664                                       (char*)msg, sizeof msg, &msglen,
2665                                       0 /* ms timeout */ );
2666       if (rc == LIBUSB_ERROR_TIMEOUT)
2667         return 0;
2668     }
2669   else
2670     return 0;
2671
2672   if (rc)
2673     {
2674       DEBUGOUT_1 ("usb_intr_read error: %s\n", libusb_error_name (rc));
2675       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2676     }
2677
2678   if (msglen < 1)
2679     {
2680       DEBUGOUT ("intr-in msg too short\n");
2681       return CCID_DRIVER_ERR_INV_VALUE;
2682     }
2683
2684   if (msg[0] == RDR_to_PC_NotifySlotChange)
2685     {
2686       DEBUGOUT ("notify slot change:");
2687       for (i=1; i < msglen; i++)
2688         for (j=0; j < 4; j++)
2689           DEBUGOUT_CONT_3 (" %d:%c%c",
2690                            (i-1)*4+j,
2691                            (msg[i] & (1<<(j*2)))? 'p':'-',
2692                            (msg[i] & (2<<(j*2)))? '*':' ');
2693       DEBUGOUT_LF ();
2694     }
2695   else if (msg[0] == RDR_to_PC_HardwareError)
2696     {
2697       DEBUGOUT ("hardware error occurred\n");
2698     }
2699   else
2700     {
2701       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
2702     }
2703
2704   return 0;
2705 }
2706
2707
2708 /* Note that this function won't return the error codes NO_CARD or
2709    CARD_INACTIVE */
2710 int
2711 ccid_slot_status (ccid_driver_t handle, int *statusbits)
2712 {
2713   int rc;
2714   unsigned char msg[100];
2715   size_t msglen;
2716   unsigned char seqno;
2717   int retries = 0;
2718
2719   if (handle->powered_off)
2720     return CCID_DRIVER_ERR_NO_READER;
2721
2722  retry:
2723   msg[0] = PC_to_RDR_GetSlotStatus;
2724   msg[5] = 0; /* slot */
2725   msg[6] = seqno = handle->seqno++;
2726   msg[7] = 0; /* RFU */
2727   msg[8] = 0; /* RFU */
2728   msg[9] = 0; /* RFU */
2729   set_msg_len (msg, 0);
2730
2731   rc = bulk_out (handle, msg, 10, 1);
2732   if (rc)
2733     return rc;
2734   /* Note that we set the NO_DEBUG flag here, so that the logs won't
2735      get cluttered up by a ticker function checking for the slot
2736      status and debugging enabled. */
2737   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
2738                 seqno, retries? 1000 : 200, 1);
2739   if (rc == CCID_DRIVER_ERR_CARD_IO_ERROR && retries < 3)
2740     {
2741       if (!retries)
2742         {
2743           DEBUGOUT ("USB: CALLING USB_CLEAR_HALT\n");
2744 #ifdef USE_NPTH
2745           npth_unprotect ();
2746 #endif
2747           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
2748           libusb_clear_halt (handle->idev, handle->ep_bulk_out);
2749 #ifdef USE_NPTH
2750           npth_protect ();
2751 #endif
2752         }
2753       else
2754           DEBUGOUT ("USB: RETRYING bulk_in AGAIN\n");
2755       retries++;
2756       goto retry;
2757     }
2758   if (rc && rc != CCID_DRIVER_ERR_NO_CARD && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
2759     return rc;
2760   *statusbits = (msg[7] & 3);
2761
2762   return 0;
2763 }
2764
2765
2766 /* Parse ATR string (of ATRLEN) and update parameters at PARAM.
2767    Calling this routine, it should prepare default values at PARAM
2768    beforehand.  This routine assumes that card is accessed by T=1
2769    protocol.  It doesn't analyze historical bytes at all.
2770
2771    Returns < 0 value on error:
2772      -1 for parse error or integrity check error
2773      -2 for card doesn't support T=1 protocol
2774      -3 for parameters are nod explicitly defined by ATR
2775      -4 for this driver doesn't support CRC
2776
2777    Returns >= 0 on success:
2778       0 for card is negotiable mode
2779       1 for card is specific mode (and not negotiable)
2780  */
2781 static int
2782 update_param_by_atr (unsigned char *param, unsigned char *atr, size_t atrlen)
2783 {
2784   int i = -1;
2785   int t, y, chk;
2786   int historical_bytes_num, negotiable = 1;
2787
2788 #define NEXTBYTE() do { i++; if (atrlen <= i) return -1; } while (0)
2789
2790   NEXTBYTE ();
2791
2792   if (atr[i] == 0x3F)
2793     param[1] |= 0x02;           /* Convention is inverse.  */
2794   NEXTBYTE ();
2795
2796   y = (atr[i] >> 4);
2797   historical_bytes_num = atr[i] & 0x0f;
2798   NEXTBYTE ();
2799
2800   if ((y & 1))
2801     {
2802       param[0] = atr[i];        /* TA1 - Fi & Di */
2803       NEXTBYTE ();
2804     }
2805
2806   if ((y & 2))
2807     NEXTBYTE ();                /* TB1 - ignore */
2808
2809   if ((y & 4))
2810     {
2811       param[2] = atr[i];        /* TC1 - Guard Time */
2812       NEXTBYTE ();
2813     }
2814
2815   if ((y & 8))
2816     {
2817       y = (atr[i] >> 4);        /* TD1 */
2818       t = atr[i] & 0x0f;
2819       NEXTBYTE ();
2820
2821       if ((y & 1))
2822         {                       /* TA2 - PPS mode */
2823           if ((atr[i] & 0x0f) != 1)
2824             return -2;          /* Wrong card protocol (!= 1).  */
2825
2826           if ((atr[i] & 0x10) != 0x10)
2827             return -3; /* Transmission parameters are implicitly defined. */
2828
2829           negotiable = 0;       /* TA2 means specific mode.  */
2830           NEXTBYTE ();
2831         }
2832
2833       if ((y & 2))
2834         NEXTBYTE ();            /* TB2 - ignore */
2835
2836       if ((y & 4))
2837         NEXTBYTE ();            /* TC2 - ignore */
2838
2839       if ((y & 8))
2840         {
2841           y = (atr[i] >> 4);    /* TD2 */
2842           t = atr[i] & 0x0f;
2843           NEXTBYTE ();
2844         }
2845       else
2846         y = 0;
2847
2848       while (y)
2849         {
2850           if ((y & 1))
2851             {                   /* TAx */
2852               if (t == 1)
2853                 param[5] = atr[i]; /* IFSC */
2854               else if (t == 15)
2855                 /* XXX: check voltage? */
2856                 param[4] = (atr[i] >> 6); /* ClockStop */
2857
2858               NEXTBYTE ();
2859             }
2860
2861           if ((y & 2))
2862             {
2863               if (t == 1)
2864                 param[3] = atr[i]; /* TBx - BWI & CWI */
2865               NEXTBYTE ();
2866             }
2867
2868           if ((y & 4))
2869             {
2870               if (t == 1)
2871                 param[1] |= (atr[i] & 0x01); /* TCx - LRC/CRC */
2872               NEXTBYTE ();
2873
2874               if (param[1] & 0x01)
2875                 return -4;      /* CRC not supported yet.  */
2876             }
2877
2878           if ((y & 8))
2879             {
2880               y = (atr[i] >> 4); /* TDx */
2881               t = atr[i] & 0x0f;
2882               NEXTBYTE ();
2883             }
2884           else
2885             y = 0;
2886         }
2887     }
2888
2889   i += historical_bytes_num - 1;
2890   NEXTBYTE ();
2891   if (atrlen != i+1)
2892     return -1;
2893
2894 #undef NEXTBYTE
2895
2896   chk = 0;
2897   do
2898     {
2899       chk ^= atr[i];
2900       i--;
2901     }
2902   while (i > 0);
2903
2904   if (chk != 0)
2905     return -1;
2906
2907   return negotiable;
2908 }
2909
2910
2911 /* Return the ATR of the card.  This is not a cached value and thus an
2912    actual reset is done.  */
2913 int
2914 ccid_get_atr (ccid_driver_t handle,
2915               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
2916 {
2917   int rc;
2918   int statusbits;
2919   unsigned char msg[100];
2920   unsigned char *tpdu;
2921   size_t msglen, tpdulen;
2922   unsigned char seqno;
2923   int use_crc = 0;
2924   unsigned int edc;
2925   int tried_iso = 0;
2926   int got_param;
2927   unsigned char param[7] = { /* For Protocol T=1 */
2928     0x11, /* bmFindexDindex */
2929     0x10, /* bmTCCKST1 */
2930     0x00, /* bGuardTimeT1 */
2931     0x4d, /* bmWaitingIntegersT1 */
2932     0x00, /* bClockStop */
2933     0x20, /* bIFSC */
2934     0x00  /* bNadValue */
2935   };
2936
2937   /* First check whether a card is available.  */
2938   rc = ccid_slot_status (handle, &statusbits);
2939   if (rc)
2940     return rc;
2941   if (statusbits == 2)
2942     return CCID_DRIVER_ERR_NO_CARD;
2943
2944   /* For an inactive and also for an active card, issue the PowerOn
2945      command to get the ATR.  */
2946  again:
2947   msg[0] = PC_to_RDR_IccPowerOn;
2948   msg[5] = 0; /* slot */
2949   msg[6] = seqno = handle->seqno++;
2950   /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
2951   msg[7] = handle->auto_voltage ? 0 : 1;
2952   msg[8] = 0; /* RFU */
2953   msg[9] = 0; /* RFU */
2954   set_msg_len (msg, 0);
2955   msglen = 10;
2956
2957   rc = bulk_out (handle, msg, msglen, 0);
2958   if (rc)
2959     return rc;
2960   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2961                 seqno, 5000, 0);
2962   if (rc)
2963     return rc;
2964   if (!tried_iso && CCID_COMMAND_FAILED (msg) && CCID_ERROR_CODE (msg) == 0xbb
2965       && ((handle->id_vendor == VENDOR_CHERRY
2966            && handle->id_product == 0x0005)
2967           || (handle->id_vendor == VENDOR_GEMPC
2968               && handle->id_product == 0x4433)
2969           ))
2970     {
2971       tried_iso = 1;
2972       /* Try switching to ISO mode. */
2973       if (!send_escape_cmd (handle, (const unsigned char*)"\xF1\x01", 2,
2974                             NULL, 0, NULL))
2975         goto again;
2976     }
2977   else if (CCID_COMMAND_FAILED (msg))
2978     return CCID_DRIVER_ERR_CARD_IO_ERROR;
2979
2980
2981   handle->powered_off = 0;
2982
2983   if (atr)
2984     {
2985       size_t n = msglen - 10;
2986
2987       if (n > maxatrlen)
2988         n = maxatrlen;
2989       memcpy (atr, msg+10, n);
2990       *atrlen = n;
2991     }
2992
2993   param[6] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2994   rc = update_param_by_atr (param, msg+10, msglen - 10);
2995   if (rc < 0)
2996     {
2997       DEBUGOUT_1 ("update_param_by_atr failed: %d\n", rc);
2998       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2999     }
3000
3001   got_param = 0;
3002
3003   if (handle->auto_param)
3004     {
3005       msg[0] = PC_to_RDR_GetParameters;
3006       msg[5] = 0; /* slot */
3007       msg[6] = seqno = handle->seqno++;
3008       msg[7] = 0; /* RFU */
3009       msg[8] = 0; /* RFU */
3010       msg[9] = 0; /* RFU */
3011       set_msg_len (msg, 0);
3012       msglen = 10;
3013       rc = bulk_out (handle, msg, msglen, 0);
3014       if (!rc)
3015         rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
3016                       seqno, 2000, 0);
3017       if (rc)
3018         DEBUGOUT ("GetParameters failed\n");
3019       else if (msglen == 17 && msg[9] == 1)
3020         got_param = 1;
3021     }
3022   else if (handle->auto_pps)
3023     ;
3024   else if (rc == 1)             /* It's negotiable, send PPS.  */
3025     {
3026       msg[0] = PC_to_RDR_XfrBlock;
3027       msg[5] = 0; /* slot */
3028       msg[6] = seqno = handle->seqno++;
3029       msg[7] = 0;
3030       msg[8] = 0;
3031       msg[9] = 0;
3032       msg[10] = 0xff;           /* PPSS */
3033       msg[11] = 0x11;           /* PPS0: PPS1, Protocol T=1 */
3034       msg[12] = param[0];       /* PPS1: Fi / Di */
3035       msg[13] = 0xff ^ 0x11 ^ param[0]; /* PCK */
3036       set_msg_len (msg, 4);
3037       msglen = 10 + 4;
3038
3039       rc = bulk_out (handle, msg, msglen, 0);
3040       if (rc)
3041         return rc;
3042
3043       rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
3044                     seqno, 5000, 0);
3045       if (rc)
3046         return rc;
3047
3048       if (msglen != 10 + 4)
3049         {
3050           DEBUGOUT_1 ("Setting PPS failed: %zu\n", msglen);
3051           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3052         }
3053
3054       if (msg[10] != 0xff || msg[11] != 0x11 || msg[12] != param[0])
3055         {
3056           DEBUGOUT_1 ("Setting PPS failed: 0x%02x\n", param[0]);
3057           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3058         }
3059     }
3060
3061   /* Setup parameters to select T=1. */
3062   msg[0] = PC_to_RDR_SetParameters;
3063   msg[5] = 0; /* slot */
3064   msg[6] = seqno = handle->seqno++;
3065   msg[7] = 1; /* Select T=1. */
3066   msg[8] = 0; /* RFU */
3067   msg[9] = 0; /* RFU */
3068
3069   if (!got_param)
3070     memcpy (&msg[10], param, 7);
3071   set_msg_len (msg, 7);
3072   msglen = 10 + 7;
3073
3074   rc = bulk_out (handle, msg, msglen, 0);
3075   if (rc)
3076     return rc;
3077   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
3078                 seqno, 5000, 0);
3079   if (rc)
3080     DEBUGOUT ("SetParameters failed (ignored)\n");
3081
3082   if (!rc && msglen > 15 && msg[15] >= 16 && msg[15] <= 254 )
3083     handle->ifsc = msg[15];
3084   else
3085     handle->ifsc = 128; /* Something went wrong, assume 128 bytes.  */
3086
3087   if (handle->nonnull_nad && msglen > 16 && msg[16] == 0)
3088     {
3089       DEBUGOUT ("Use Null-NAD, clearing handle->nonnull_nad.\n");
3090       handle->nonnull_nad = 0;
3091     }
3092
3093   handle->t1_ns = 0;
3094   handle->t1_nr = 0;
3095
3096   /* Send an S-Block with our maximum IFSD to the CCID.  */
3097   if (!handle->apdu_level && !handle->auto_ifsd)
3098     {
3099       tpdu = msg+10;
3100       /* NAD: DAD=1, SAD=0 */
3101       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
3102       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
3103       tpdu[2] = 1;
3104       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32;
3105       tpdulen = 4;
3106       edc = compute_edc (tpdu, tpdulen, use_crc);
3107       if (use_crc)
3108         tpdu[tpdulen++] = (edc >> 8);
3109       tpdu[tpdulen++] = edc;
3110
3111       msg[0] = PC_to_RDR_XfrBlock;
3112       msg[5] = 0; /* slot */
3113       msg[6] = seqno = handle->seqno++;
3114       msg[7] = 0;
3115       msg[8] = 0; /* RFU */
3116       msg[9] = 0; /* RFU */
3117       set_msg_len (msg, tpdulen);
3118       msglen = 10 + tpdulen;
3119
3120       if (debug_level > 1)
3121         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
3122                       ((msg[11] & 0xc0) == 0x80)? 'R' :
3123                                 (msg[11] & 0x80)? 'S' : 'I',
3124                       ((msg[11] & 0x80)? !!(msg[11]& 0x10)
3125                                        : !!(msg[11] & 0x40)),
3126                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
3127
3128       rc = bulk_out (handle, msg, msglen, 0);
3129       if (rc)
3130         return rc;
3131
3132
3133       rc = bulk_in (handle, msg, sizeof msg, &msglen,
3134                     RDR_to_PC_DataBlock, seqno, 5000, 0);
3135       if (rc)
3136         return rc;
3137
3138       tpdu = msg + 10;
3139       tpdulen = msglen - 10;
3140
3141       if (tpdulen < 4)
3142         return CCID_DRIVER_ERR_ABORTED;
3143
3144       if (debug_level > 1)
3145         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3146                     ((msg[11] & 0xc0) == 0x80)? 'R' :
3147                               (msg[11] & 0x80)? 'S' : 'I',
3148                     ((msg[11] & 0x80)? !!(msg[11]& 0x10)
3149                                      : !!(msg[11] & 0x40)),
3150                     ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
3151                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
3152
3153       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
3154         {
3155           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
3156           return -1;
3157         }
3158       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
3159     }
3160
3161   return 0;
3162 }
3163
3164
3165 \f
3166
3167 static unsigned int
3168 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
3169 {
3170   if (use_crc)
3171     {
3172       return 0x42; /* Not yet implemented. */
3173     }
3174   else
3175     {
3176       unsigned char crc = 0;
3177
3178       for (; datalen; datalen--)
3179         crc ^= *data++;
3180       return crc;
3181     }
3182 }
3183
3184
3185 /* Return true if APDU is an extended length one.  */
3186 static int
3187 is_exlen_apdu (const unsigned char *apdu, size_t apdulen)
3188 {
3189   if (apdulen < 7 || apdu[4])
3190     return 0;  /* Too short or no Z byte.  */
3191   return 1;
3192 }
3193
3194
3195 /* Helper for ccid_transceive used for APDU level exchanges.  */
3196 static int
3197 ccid_transceive_apdu_level (ccid_driver_t handle,
3198                             const unsigned char *apdu_buf, size_t apdu_len,
3199                             unsigned char *resp, size_t maxresplen,
3200                             size_t *nresp)
3201 {
3202   int rc;
3203   unsigned char msg[CCID_MAX_BUF];
3204   const unsigned char *apdu_p;
3205   size_t apdu_part_len;
3206   size_t msglen;
3207   unsigned char seqno;
3208   int bwi = 4;
3209   unsigned char chain = 0;
3210
3211   if (apdu_len == 0 || apdu_len > sizeof (msg) - 10)
3212     return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
3213
3214   apdu_p = apdu_buf;
3215   while (1)
3216     {
3217       apdu_part_len = apdu_len;
3218       if (apdu_part_len > handle->max_ccid_msglen - 10)
3219         {
3220           apdu_part_len = handle->max_ccid_msglen - 10;
3221           chain |= 0x01;
3222         }
3223
3224       msg[0] = PC_to_RDR_XfrBlock;
3225       msg[5] = 0; /* slot */
3226       msg[6] = seqno = handle->seqno++;
3227       msg[7] = bwi;
3228       msg[8] = chain;
3229       msg[9] = 0;
3230       memcpy (msg+10, apdu_p, apdu_part_len);
3231       set_msg_len (msg, apdu_part_len);
3232       msglen = 10 + apdu_part_len;
3233
3234       rc = bulk_out (handle, msg, msglen, 0);
3235       if (rc)
3236         return rc;
3237
3238       apdu_p += apdu_part_len;
3239       apdu_len -= apdu_part_len;
3240
3241       rc = bulk_in (handle, msg, sizeof msg, &msglen,
3242                     RDR_to_PC_DataBlock, seqno, CCID_CMD_TIMEOUT, 0);
3243       if (rc)
3244         return rc;
3245
3246       if (!(chain & 0x01))
3247         break;
3248
3249       chain = 0x02;
3250     }
3251
3252   apdu_len = 0;
3253   while (1)
3254     {
3255       apdu_part_len = msglen - 10;
3256       if (resp && apdu_len + apdu_part_len <= maxresplen)
3257         memcpy (resp + apdu_len, msg+10, apdu_part_len);
3258       apdu_len += apdu_part_len;
3259
3260       if (!(msg[9] & 0x01))
3261         break;
3262
3263       msg[0] = PC_to_RDR_XfrBlock;
3264       msg[5] = 0; /* slot */
3265       msg[6] = seqno = handle->seqno++;
3266       msg[7] = bwi;
3267       msg[8] = 0x10;                /* Request next data block */
3268       msg[9] = 0;
3269       set_msg_len (msg, 0);
3270       msglen = 10;
3271
3272       rc = bulk_out (handle, msg, msglen, 0);
3273       if (rc)
3274         return rc;
3275
3276       rc = bulk_in (handle, msg, sizeof msg, &msglen,
3277                     RDR_to_PC_DataBlock, seqno, CCID_CMD_TIMEOUT, 0);
3278       if (rc)
3279         return rc;
3280     }
3281
3282   if (resp)
3283     {
3284       if (apdu_len > maxresplen)
3285         {
3286           DEBUGOUT_2 ("provided buffer too short for received data "
3287                       "(%u/%u)\n",
3288                       (unsigned int)apdu_len, (unsigned int)maxresplen);
3289           return CCID_DRIVER_ERR_INV_VALUE;
3290         }
3291
3292       *nresp = apdu_len;
3293     }
3294
3295   return 0;
3296 }
3297
3298
3299
3300 /*
3301   Protocol T=1 overview
3302
3303   Block Structure:
3304            Prologue Field:
3305    1 byte     Node Address (NAD)
3306    1 byte     Protocol Control Byte (PCB)
3307    1 byte     Length (LEN)
3308            Information Field:
3309    0-254 byte APDU or Control Information (INF)
3310            Epilogue Field:
3311    1 byte     Error Detection Code (EDC)
3312
3313   NAD:
3314    bit 7     unused
3315    bit 4..6  Destination Node Address (DAD)
3316    bit 3     unused
3317    bit 2..0  Source Node Address (SAD)
3318
3319    If node adresses are not used, SAD and DAD should be set to 0 on
3320    the first block sent to the card.  If they are used they should
3321    have different values (0 for one is okay); that first block sets up
3322    the addresses of the nodes.
3323
3324   PCB:
3325    Information Block (I-Block):
3326       bit 7    0
3327       bit 6    Sequence number (yep, that is modulo 2)
3328       bit 5    Chaining flag
3329       bit 4..0 reserved
3330    Received-Ready Block (R-Block):
3331       bit 7    1
3332       bit 6    0
3333       bit 5    0
3334       bit 4    Sequence number
3335       bit 3..0  0 = no error
3336                 1 = EDC or parity error
3337                 2 = other error
3338                 other values are reserved
3339    Supervisory Block (S-Block):
3340       bit 7    1
3341       bit 6    1
3342       bit 5    clear=request,set=response
3343       bit 4..0  0 = resyncronisation request
3344                 1 = information field size request
3345                 2 = abort request
3346                 3 = extension of BWT request
3347                 4 = VPP error
3348                 other values are reserved
3349
3350 */
3351
3352 int
3353 ccid_transceive (ccid_driver_t handle,
3354                  const unsigned char *apdu_buf, size_t apdu_buflen,
3355                  unsigned char *resp, size_t maxresplen, size_t *nresp)
3356 {
3357   int rc;
3358   /* The size of the buffer used to be 10+259.  For the via_escape
3359      hack we need one extra byte, thus 11+259.  */
3360   unsigned char send_buffer[11+259], recv_buffer[11+259];
3361   const unsigned char *apdu;
3362   size_t apdulen;
3363   unsigned char *msg, *tpdu, *p;
3364   size_t msglen, tpdulen, last_tpdulen, n;
3365   unsigned char seqno;
3366   unsigned int edc;
3367   int use_crc = 0;
3368   int hdrlen, pcboff;
3369   size_t dummy_nresp;
3370   int via_escape = 0;
3371   int next_chunk = 1;
3372   int sending = 1;
3373   int retries = 0;
3374   int resyncing = 0;
3375   int nad_byte;
3376
3377   if (!nresp)
3378     nresp = &dummy_nresp;
3379   *nresp = 0;
3380
3381   /* Smarter readers allow sending APDUs directly; divert here. */
3382   if (handle->apdu_level)
3383     {
3384       /* We employ a hack for Omnikey readers which are able to send
3385          TPDUs using an escape sequence.  There is no documentation
3386          but the Windows driver does it this way.  Tested using a
3387          CM6121.  This method works also for the Cherry XX44
3388          keyboards; however there are problems with the
3389          ccid_tranceive_secure which leads to a loss of sync on the
3390          CCID level.  If Cherry wants to make their keyboard work
3391          again, they should hand over some docs. */
3392       if ((handle->id_vendor == VENDOR_OMNIKEY
3393            || (!handle->idev && handle->id_product == TRANSPORT_CM4040))
3394           && handle->apdu_level < 2
3395           && is_exlen_apdu (apdu_buf, apdu_buflen))
3396         via_escape = 1;
3397       else
3398         return ccid_transceive_apdu_level (handle, apdu_buf, apdu_buflen,
3399                                            resp, maxresplen, nresp);
3400     }
3401
3402   /* The other readers we support require sending TPDUs.  */
3403
3404   tpdulen = 0; /* Avoid compiler warning about no initialization. */
3405   msg = send_buffer;
3406   hdrlen = via_escape? 11 : 10;
3407
3408   /* NAD: DAD=1, SAD=0 */
3409   nad_byte = handle->nonnull_nad? ((1 << 4) | 0): 0;
3410   if (via_escape)
3411     nad_byte = 0;
3412
3413   last_tpdulen = 0;  /* Avoid gcc warning (controlled by RESYNCING). */
3414   for (;;)
3415     {
3416       if (next_chunk)
3417         {
3418           next_chunk = 0;
3419
3420           apdu = apdu_buf;
3421           apdulen = apdu_buflen;
3422           assert (apdulen);
3423
3424           /* Construct an I-Block. */
3425           tpdu = msg + hdrlen;
3426           tpdu[0] = nad_byte;
3427           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
3428           if (apdulen > handle->ifsc )
3429             {
3430               apdulen = handle->ifsc;
3431               apdu_buf += handle->ifsc;
3432               apdu_buflen -= handle->ifsc;
3433               tpdu[1] |= (1 << 5); /* Set more bit. */
3434             }
3435           tpdu[2] = apdulen;
3436           memcpy (tpdu+3, apdu, apdulen);
3437           tpdulen = 3 + apdulen;
3438           edc = compute_edc (tpdu, tpdulen, use_crc);
3439           if (use_crc)
3440             tpdu[tpdulen++] = (edc >> 8);
3441           tpdu[tpdulen++] = edc;
3442         }
3443
3444       if (via_escape)
3445         {
3446           msg[0] = PC_to_RDR_Escape;
3447           msg[5] = 0; /* slot */
3448           msg[6] = seqno = handle->seqno++;
3449           msg[7] = 0; /* RFU */
3450           msg[8] = 0; /* RFU */
3451           msg[9] = 0; /* RFU */
3452           msg[10] = 0x1a; /* Omnikey command to send a TPDU.  */
3453           set_msg_len (msg, 1 + tpdulen);
3454         }
3455       else
3456         {
3457           msg[0] = PC_to_RDR_XfrBlock;
3458           msg[5] = 0; /* slot */
3459           msg[6] = seqno = handle->seqno++;
3460           msg[7] = 4; /* bBWI */
3461           msg[8] = 0; /* RFU */
3462           msg[9] = 0; /* RFU */
3463           set_msg_len (msg, tpdulen);
3464         }
3465       msglen = hdrlen + tpdulen;
3466       if (!resyncing)
3467         last_tpdulen = tpdulen;
3468       pcboff = hdrlen+1;
3469
3470       if (debug_level > 1)
3471         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
3472                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3473                     (msg[pcboff] & 0x80)? 'S' : 'I',
3474                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3475                      : !!(msg[pcboff] & 0x40)),
3476                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3477                      " [more]":""));
3478
3479       rc = bulk_out (handle, msg, msglen, 0);
3480       if (rc)
3481         return rc;
3482
3483       msg = recv_buffer;
3484       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3485                     via_escape? RDR_to_PC_Escape : RDR_to_PC_DataBlock,
3486                     seqno, CCID_CMD_TIMEOUT, 0);
3487       if (rc)
3488         return rc;
3489
3490       tpdu = msg + hdrlen;
3491       tpdulen = msglen - hdrlen;
3492       resyncing = 0;
3493
3494       if (tpdulen < 4)
3495         {
3496 #ifdef USE_NPTH
3497           npth_unprotect ();
3498 #endif
3499           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
3500 #ifdef USE_NPTH
3501           npth_protect ();
3502 #endif
3503           return CCID_DRIVER_ERR_ABORTED;
3504         }
3505
3506       if (debug_level > 1)
3507         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3508                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3509                               (msg[pcboff] & 0x80)? 'S' : 'I',
3510                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3511                      : !!(msg[pcboff] & 0x40)),
3512                     ((msg[pcboff] & 0xc0) == 0x80)? (msg[pcboff] & 0x0f) : 0,
3513                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3514                      " [more]":""));
3515
3516       if (!(tpdu[1] & 0x80))
3517         { /* This is an I-block. */
3518           retries = 0;
3519           if (sending)
3520             { /* last block sent was successful. */
3521               handle->t1_ns ^= 1;
3522               sending = 0;
3523             }
3524
3525           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3526             { /* Response does not match our sequence number. */
3527               msg = send_buffer;
3528               tpdu = msg + hdrlen;
3529               tpdu[0] = nad_byte;
3530               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
3531               tpdu[2] = 0;
3532               tpdulen = 3;
3533               edc = compute_edc (tpdu, tpdulen, use_crc);
3534               if (use_crc)
3535                 tpdu[tpdulen++] = (edc >> 8);
3536               tpdu[tpdulen++] = edc;
3537
3538               continue;
3539             }
3540
3541           handle->t1_nr ^= 1;
3542
3543           p = tpdu + 3; /* Skip the prologue field. */
3544           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3545           /* fixme: verify the checksum. */
3546           if (resp)
3547             {
3548               if (n > maxresplen)
3549                 {
3550                   DEBUGOUT_2 ("provided buffer too short for received data "
3551                               "(%u/%u)\n",
3552                               (unsigned int)n, (unsigned int)maxresplen);
3553                   return CCID_DRIVER_ERR_INV_VALUE;
3554                 }
3555
3556               memcpy (resp, p, n);
3557               resp += n;
3558               *nresp += n;
3559               maxresplen -= n;
3560             }
3561
3562           if (!(tpdu[1] & 0x20))
3563             return 0; /* No chaining requested - ready. */
3564
3565           msg = send_buffer;
3566           tpdu = msg + hdrlen;
3567           tpdu[0] = nad_byte;
3568           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
3569           tpdu[2] = 0;
3570           tpdulen = 3;
3571           edc = compute_edc (tpdu, tpdulen, use_crc);
3572           if (use_crc)
3573             tpdu[tpdulen++] = (edc >> 8);
3574           tpdu[tpdulen++] = edc;
3575         }
3576       else if ((tpdu[1] & 0xc0) == 0x80)
3577         { /* This is a R-block. */
3578           if ( (tpdu[1] & 0x0f))
3579             {
3580               retries++;
3581               if (via_escape && retries == 1 && (msg[pcboff] & 0x0f))
3582                 {
3583                   /* Error probably due to switching to TPDU.  Send a
3584                      resync request.  We use the recv_buffer so that
3585                      we don't corrupt the send_buffer.  */
3586                   msg = recv_buffer;
3587                   tpdu = msg + hdrlen;
3588                   tpdu[0] = nad_byte;
3589                   tpdu[1] = 0xc0; /* S-block resync request. */
3590                   tpdu[2] = 0;
3591                   tpdulen = 3;
3592                   edc = compute_edc (tpdu, tpdulen, use_crc);
3593                   if (use_crc)
3594                     tpdu[tpdulen++] = (edc >> 8);
3595                   tpdu[tpdulen++] = edc;
3596                   resyncing = 1;
3597                   DEBUGOUT ("T=1: requesting resync\n");
3598                 }
3599               else if (retries > 3)
3600                 {
3601                   DEBUGOUT ("T=1: 3 failed retries\n");
3602                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
3603                 }
3604               else
3605                 {
3606                   /* Error: repeat last block */
3607                   msg = send_buffer;
3608                   tpdulen = last_tpdulen;
3609                 }
3610             }
3611           else if (sending && !!(tpdu[1] & 0x10) == handle->t1_ns)
3612             { /* Response does not match our sequence number. */
3613               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
3614               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3615             }
3616           else if (sending)
3617             { /* Send next chunk. */
3618               retries = 0;
3619               msg = send_buffer;
3620               next_chunk = 1;
3621               handle->t1_ns ^= 1;
3622             }
3623           else
3624             {
3625               DEBUGOUT ("unexpected ACK R-block received\n");
3626               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3627             }
3628         }
3629       else
3630         { /* This is a S-block. */
3631           retries = 0;
3632           DEBUGOUT_2 ("T=1: S-block %s received cmd=%d\n",
3633                       (tpdu[1] & 0x20)? "response": "request",
3634                       (tpdu[1] & 0x1f));
3635           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 1 && tpdu[2] == 1)
3636             {
3637               /* Information field size request.  */
3638               unsigned char ifsc = tpdu[3];
3639
3640               if (ifsc < 16 || ifsc > 254)
3641                 return CCID_DRIVER_ERR_CARD_IO_ERROR;
3642
3643               msg = send_buffer;
3644               tpdu = msg + hdrlen;
3645               tpdu[0] = nad_byte;
3646               tpdu[1] = (0xc0 | 0x20 | 1); /* S-block response */
3647               tpdu[2] = 1;
3648               tpdu[3] = ifsc;
3649               tpdulen = 4;
3650               edc = compute_edc (tpdu, tpdulen, use_crc);
3651               if (use_crc)
3652                 tpdu[tpdulen++] = (edc >> 8);
3653               tpdu[tpdulen++] = edc;
3654               DEBUGOUT_1 ("T=1: requesting an ifsc=%d\n", ifsc);
3655             }
3656           else if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
3657             {
3658               /* Wait time extension request. */
3659               unsigned char bwi = tpdu[3];
3660               msg = send_buffer;
3661               tpdu = msg + hdrlen;
3662               tpdu[0] = nad_byte;
3663               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
3664               tpdu[2] = 1;
3665               tpdu[3] = bwi;
3666               tpdulen = 4;
3667               edc = compute_edc (tpdu, tpdulen, use_crc);
3668               if (use_crc)
3669                 tpdu[tpdulen++] = (edc >> 8);
3670               tpdu[tpdulen++] = edc;
3671               DEBUGOUT_1 ("T=1: waittime extension of bwi=%d\n", bwi);
3672               print_progress (handle);
3673             }
3674           else if ( (tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 0 && !tpdu[2])
3675             {
3676               DEBUGOUT ("T=1: resync ack from reader\n");
3677               /* Repeat previous block.  */
3678               msg = send_buffer;
3679               tpdulen = last_tpdulen;
3680             }
3681           else
3682             return CCID_DRIVER_ERR_CARD_IO_ERROR;
3683         }
3684     } /* end T=1 protocol loop. */
3685
3686   return 0;
3687 }
3688
3689
3690 /* Send the CCID Secure command to the reader.  APDU_BUF should
3691    contain the APDU template.  PIN_MODE defines how the pin gets
3692    formatted:
3693
3694      1 := The PIN is ASCII encoded and of variable length.  The
3695           length of the PIN entered will be put into Lc by the reader.
3696           The APDU should me made up of 4 bytes without Lc.
3697
3698    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
3699    may be used t enable reasonable defaults.
3700
3701    When called with RESP and NRESP set to NULL, the function will
3702    merely check whether the reader supports the secure command for the
3703    given APDU and PIN_MODE. */
3704 int
3705 ccid_transceive_secure (ccid_driver_t handle,
3706                         const unsigned char *apdu_buf, size_t apdu_buflen,
3707                         pininfo_t *pininfo,
3708                         unsigned char *resp, size_t maxresplen, size_t *nresp)
3709 {
3710   int rc;
3711   unsigned char send_buffer[10+259], recv_buffer[10+259];
3712   unsigned char *msg, *tpdu, *p;
3713   size_t msglen, tpdulen, n;
3714   unsigned char seqno;
3715   size_t dummy_nresp;
3716   int testmode;
3717   int cherry_mode = 0;
3718   int add_zero = 0;
3719   int enable_varlen = 0;
3720
3721   testmode = !resp && !nresp;
3722
3723   if (!nresp)
3724     nresp = &dummy_nresp;
3725   *nresp = 0;
3726
3727   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
3728     ;
3729   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
3730     ;
3731   else
3732     return CCID_DRIVER_ERR_NO_PINPAD;
3733
3734   if (!pininfo->minlen)
3735     pininfo->minlen = 1;
3736   if (!pininfo->maxlen)
3737     pininfo->maxlen = 15;
3738
3739   /* Note that the 25 is the maximum value the SPR532 allows.  */
3740   if (pininfo->minlen < 1 || pininfo->minlen > 25
3741       || pininfo->maxlen < 1 || pininfo->maxlen > 25
3742       || pininfo->minlen > pininfo->maxlen)
3743     return CCID_DRIVER_ERR_INV_VALUE;
3744
3745   /* We have only tested a few readers so better don't risk anything
3746      and do not allow the use with other readers. */
3747   switch (handle->id_vendor)
3748     {
3749     case VENDOR_SCM:  /* Tested with SPR 532. */
3750     case VENDOR_KAAN: /* Tested with KAAN Advanced (1.02). */
3751     case VENDOR_FSIJ: /* Tested with Gnuk (0.21). */
3752       pininfo->maxlen = 25;
3753       enable_varlen = 1;
3754       break;
3755     case VENDOR_REINER:/* Tested with cyberJack go */
3756     case VENDOR_VASCO: /* Tested with DIGIPASS 920 */
3757       enable_varlen = 1;
3758       break;
3759     case VENDOR_CHERRY:
3760       pininfo->maxlen = 15;
3761       enable_varlen = 1;
3762       /* The CHERRY XX44 keyboard echos an asterisk for each entered
3763          character on the keyboard channel.  We use a special variant
3764          of PC_to_RDR_Secure which directs these characters to the
3765          smart card's bulk-in channel.  We also need to append a zero
3766          Lc byte to the APDU.  It seems that it will be replaced with
3767          the actual length instead of being appended before the APDU
3768          is send to the card. */
3769       add_zero = 1;
3770       if (handle->id_product != CHERRY_ST2000)
3771         cherry_mode = 1;
3772       break;
3773     default:
3774       if ((handle->id_vendor == VENDOR_GEMPC &&
3775            handle->id_product == GEMPC_PINPAD)
3776           || (handle->id_vendor == VENDOR_VEGA &&
3777               handle->id_product == VEGA_ALPHA))
3778         {
3779           enable_varlen = 0;
3780           pininfo->minlen = 4;
3781           pininfo->maxlen = 8;
3782           break;
3783         }
3784      return CCID_DRIVER_ERR_NOT_SUPPORTED;
3785     }
3786
3787   if (enable_varlen)
3788     pininfo->fixedlen = 0;
3789
3790   if (testmode)
3791     return 0; /* Success */
3792
3793   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
3794     return CCID_DRIVER_ERR_NOT_SUPPORTED;
3795
3796   msg = send_buffer;
3797   if (handle->id_vendor == VENDOR_SCM)
3798     {
3799       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
3800       rc = send_escape_cmd (handle, (const unsigned char*)"\x80\x02\x00", 3,
3801                             NULL, 0, NULL);
3802       if (rc)
3803         return rc;
3804     }
3805
3806   msg[0] = cherry_mode? 0x89 : PC_to_RDR_Secure;
3807   msg[5] = 0; /* slot */
3808   msg[6] = seqno = handle->seqno++;
3809   msg[7] = 0; /* bBWI */
3810   msg[8] = 0; /* RFU */
3811   msg[9] = 0; /* RFU */
3812   msg[10] = apdu_buf[1] == 0x20 ? 0 : 1;
3813                /* Perform PIN verification or PIN modification. */
3814   msg[11] = 0; /* Timeout in seconds. */
3815   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
3816   if (handle->id_vendor == VENDOR_SCM)
3817     {
3818       /* For the SPR532 the next 2 bytes need to be zero.  We do this
3819          for all SCM products.  Kudos to Martin Paljak for this
3820          hint.  */
3821       msg[13] = msg[14] = 0;
3822     }
3823   else
3824     {
3825       msg[13] = pininfo->fixedlen; /* bmPINBlockString:
3826                                       0 bits of pin length to insert.
3827                                       PIN block size by fixedlen.  */
3828       msg[14] = 0x00; /* bmPINLengthFormat:
3829                          Units are bytes, position is 0. */
3830     }
3831
3832   msglen = 15;
3833   if (apdu_buf[1] == 0x24)
3834     {
3835       msg[msglen++] = 0;    /* bInsertionOffsetOld */
3836       msg[msglen++] = pininfo->fixedlen;    /* bInsertionOffsetNew */
3837     }
3838
3839   /* The following is a little endian word. */
3840   msg[msglen++] = pininfo->maxlen;   /* wPINMaxExtraDigit-Maximum.  */
3841   msg[msglen++] = pininfo->minlen;   /* wPINMaxExtraDigit-Minimum.  */
3842
3843   if (apdu_buf[1] == 0x24)
3844     msg[msglen++] = apdu_buf[2] == 0 ? 0x03 : 0x01;
3845               /* bConfirmPIN
3846                *    0x00: new PIN once
3847                *    0x01: new PIN twice (confirmation)
3848                *    0x02: old PIN and new PIN once
3849                *    0x03: old PIN and new PIN twice (confirmation)
3850                */
3851
3852   msg[msglen] = 0x02; /* bEntryValidationCondition:
3853                          Validation key pressed */
3854   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
3855     msg[msglen] |= 0x01; /* Max size reached.  */
3856   msglen++;
3857
3858   if (apdu_buf[1] == 0x20)
3859     msg[msglen++] = 0x01; /* bNumberMessage. */
3860   else
3861     msg[msglen++] = 0x03; /* bNumberMessage. */
3862
3863   msg[msglen++] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
3864   msg[msglen++] = 0x04; /* wLangId-High. */
3865
3866   if (apdu_buf[1] == 0x20)
3867     msg[msglen++] = 0;    /* bMsgIndex. */
3868   else
3869     {
3870       msg[msglen++] = 0;    /* bMsgIndex1. */
3871       msg[msglen++] = 1;    /* bMsgIndex2. */
3872       msg[msglen++] = 2;    /* bMsgIndex3. */
3873     }
3874
3875   /* Calculate Lc.  */
3876   n = pininfo->fixedlen;
3877   if (apdu_buf[1] == 0x24)
3878     n += pininfo->fixedlen;
3879
3880   /* bTeoProlog follows: */
3881   msg[msglen++] = handle->nonnull_nad? ((1 << 4) | 0): 0;
3882   msg[msglen++] = ((handle->t1_ns & 1) << 6); /* I-block */
3883   if (n)
3884     msg[msglen++] = n + 5; /* apdulen should be filled for fixed length.  */
3885   else
3886     msg[msglen++] = 0; /* The apdulen will be filled in by the reader.  */
3887   /* APDU follows:  */
3888   msg[msglen++] = apdu_buf[0]; /* CLA */
3889   msg[msglen++] = apdu_buf[1]; /* INS */
3890   msg[msglen++] = apdu_buf[2]; /* P1 */
3891   msg[msglen++] = apdu_buf[3]; /* P2 */
3892   if (add_zero)
3893     msg[msglen++] = 0;
3894   else if (pininfo->fixedlen != 0)
3895     {
3896       msg[msglen++] = n;
3897       memset (&msg[msglen], 0xff, n);
3898       msglen += n;
3899     }
3900   /* An EDC is not required. */
3901   set_msg_len (msg, msglen - 10);
3902
3903   rc = bulk_out (handle, msg, msglen, 0);
3904   if (rc)
3905     return rc;
3906
3907   msg = recv_buffer;
3908   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3909                 RDR_to_PC_DataBlock, seqno, 30000, 0);
3910   if (rc)
3911     return rc;
3912
3913   tpdu = msg + 10;
3914   tpdulen = msglen - 10;
3915
3916   if (handle->apdu_level)
3917     {
3918       if (resp)
3919         {
3920           if (tpdulen > maxresplen)
3921             {
3922               DEBUGOUT_2 ("provided buffer too short for received data "
3923                           "(%u/%u)\n",
3924                           (unsigned int)tpdulen, (unsigned int)maxresplen);
3925               return CCID_DRIVER_ERR_INV_VALUE;
3926             }
3927
3928           memcpy (resp, tpdu, tpdulen);
3929           *nresp = tpdulen;
3930         }
3931       return 0;
3932     }
3933
3934   if (tpdulen < 4)
3935     {
3936 #ifdef USE_NPTH
3937       npth_unprotect ();
3938 #endif
3939       libusb_clear_halt (handle->idev, handle->ep_bulk_in);
3940 #ifdef USE_NPTH
3941       npth_protect ();
3942 #endif
3943       return CCID_DRIVER_ERR_ABORTED;
3944     }
3945   if (debug_level > 1)
3946     DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3947                 ((msg[11] & 0xc0) == 0x80)? 'R' :
3948                           (msg[11] & 0x80)? 'S' : 'I',
3949                 ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
3950                 ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
3951                 (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
3952
3953   if (!(tpdu[1] & 0x80))
3954     { /* This is an I-block. */
3955       /* Last block sent was successful. */
3956       handle->t1_ns ^= 1;
3957
3958       if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3959         { /* Response does not match our sequence number. */
3960           DEBUGOUT ("I-block with wrong seqno received\n");
3961           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3962         }
3963
3964       handle->t1_nr ^= 1;
3965
3966       p = tpdu + 3; /* Skip the prologue field. */
3967       n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3968       /* fixme: verify the checksum. */
3969       if (resp)
3970         {
3971           if (n > maxresplen)
3972             {
3973               DEBUGOUT_2 ("provided buffer too short for received data "
3974                           "(%u/%u)\n",
3975                           (unsigned int)n, (unsigned int)maxresplen);
3976               return CCID_DRIVER_ERR_INV_VALUE;
3977             }
3978
3979           memcpy (resp, p, n);
3980           resp += n;
3981           *nresp += n;
3982           maxresplen -= n;
3983         }
3984
3985       if (!(tpdu[1] & 0x20))
3986         return 0; /* No chaining requested - ready. */
3987
3988       DEBUGOUT ("chaining requested but not supported for Secure operation\n");
3989       return CCID_DRIVER_ERR_CARD_IO_ERROR;
3990     }
3991   else if ((tpdu[1] & 0xc0) == 0x80)
3992     { /* This is a R-block. */
3993       if ( (tpdu[1] & 0x0f))
3994         { /* Error: repeat last block */
3995           DEBUGOUT ("No retries supported for Secure operation\n");
3996           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3997         }
3998       else if (!!(tpdu[1] & 0x10) == handle->t1_ns)
3999         { /* Response does not match our sequence number. */
4000           DEBUGOUT ("R-block with wrong seqno received on more bit\n");
4001           return CCID_DRIVER_ERR_CARD_IO_ERROR;
4002         }
4003       else
4004         { /* Send next chunk. */
4005           DEBUGOUT ("chaining not supported on Secure operation\n");
4006           return CCID_DRIVER_ERR_CARD_IO_ERROR;
4007         }
4008     }
4009   else
4010     { /* This is a S-block. */
4011       DEBUGOUT_2 ("T=1: S-block %s received cmd=%d for Secure operation\n",
4012                   (tpdu[1] & 0x20)? "response": "request",
4013                   (tpdu[1] & 0x1f));
4014       return CCID_DRIVER_ERR_CARD_IO_ERROR;
4015     }
4016
4017   return 0;
4018 }
4019
4020
4021
4022
4023 #ifdef TEST
4024
4025
4026 static void
4027 print_error (int err)
4028 {
4029   const char *p;
4030   char buf[50];
4031
4032   switch (err)
4033     {
4034     case 0: p = "success";
4035     case CCID_DRIVER_ERR_OUT_OF_CORE: p = "out of core"; break;
4036     case CCID_DRIVER_ERR_INV_VALUE: p = "invalid value"; break;
4037     case CCID_DRIVER_ERR_NO_DRIVER: p = "no driver"; break;
4038     case CCID_DRIVER_ERR_NOT_SUPPORTED: p = "not supported"; break;
4039     case CCID_DRIVER_ERR_LOCKING_FAILED: p = "locking failed"; break;
4040     case CCID_DRIVER_ERR_BUSY: p = "busy"; break;
4041     case CCID_DRIVER_ERR_NO_CARD: p = "no card"; break;
4042     case CCID_DRIVER_ERR_CARD_INACTIVE: p = "card inactive"; break;
4043     case CCID_DRIVER_ERR_CARD_IO_ERROR: p = "card I/O error"; break;
4044     case CCID_DRIVER_ERR_GENERAL_ERROR: p = "general error"; break;
4045     case CCID_DRIVER_ERR_NO_READER: p = "no reader"; break;
4046     case CCID_DRIVER_ERR_ABORTED: p = "aborted"; break;
4047     default: sprintf (buf, "0x%05x", err); p = buf; break;
4048     }
4049   fprintf (stderr, "operation failed: %s\n", p);
4050 }
4051
4052
4053 static void
4054 print_data (const unsigned char *data, size_t length)
4055 {
4056   if (length >= 2)
4057     {
4058       fprintf (stderr, "operation status: %02X%02X\n",
4059                data[length-2], data[length-1]);
4060       length -= 2;
4061     }
4062   if (length)
4063     {
4064         fputs ("   returned data:", stderr);
4065         for (; length; length--, data++)
4066           fprintf (stderr, " %02X", *data);
4067         putc ('\n', stderr);
4068     }
4069 }
4070
4071 static void
4072 print_result (int rc, const unsigned char *data, size_t length)
4073 {
4074   if (rc)
4075     print_error (rc);
4076   else if (data)
4077     print_data (data, length);
4078 }
4079
4080 int
4081 main (int argc, char **argv)
4082 {
4083   int rc;
4084   ccid_driver_t ccid;
4085   int slotstat;
4086   unsigned char result[512];
4087   size_t resultlen;
4088   int no_pinpad = 0;
4089   int verify_123456 = 0;
4090   int did_verify = 0;
4091   int no_poll = 0;
4092
4093   if (argc)
4094     {
4095       argc--;
4096       argv++;
4097     }
4098
4099   while (argc)
4100     {
4101       if ( !strcmp (*argv, "--list"))
4102         {
4103           char *p;
4104           p = ccid_get_reader_list ();
4105           if (!p)
4106             return 1;
4107           fputs (p, stderr);
4108           free (p);
4109           return 0;
4110         }
4111       else if ( !strcmp (*argv, "--debug"))
4112         {
4113           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
4114           argc--; argv++;
4115         }
4116       else if ( !strcmp (*argv, "--no-poll"))
4117         {
4118           no_poll = 1;
4119           argc--; argv++;
4120         }
4121       else if ( !strcmp (*argv, "--no-pinpad"))
4122         {
4123           no_pinpad = 1;
4124           argc--; argv++;
4125         }
4126       else if ( !strcmp (*argv, "--verify-123456"))
4127         {
4128           verify_123456 = 1;
4129           argc--; argv++;
4130         }
4131       else
4132         break;
4133     }
4134
4135   rc = ccid_open_reader (&ccid, argc? *argv:NULL, NULL);
4136   if (rc)
4137     return 1;
4138
4139   if (!no_poll)
4140     ccid_poll (ccid);
4141   fputs ("getting ATR ...\n", stderr);
4142   rc = ccid_get_atr (ccid, NULL, 0, NULL);
4143   if (rc)
4144     {
4145       print_error (rc);
4146       return 1;
4147     }
4148
4149   if (!no_poll)
4150     ccid_poll (ccid);
4151   fputs ("getting slot status ...\n", stderr);
4152   rc = ccid_slot_status (ccid, &slotstat);
4153   if (rc)
4154     {
4155       print_error (rc);
4156       return 1;
4157     }
4158
4159   if (!no_poll)
4160     ccid_poll (ccid);
4161
4162   fputs ("selecting application OpenPGP ....\n", stderr);
4163   {
4164     static unsigned char apdu[] = {
4165       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
4166     rc = ccid_transceive (ccid,
4167                           apdu, sizeof apdu,
4168                           result, sizeof result, &resultlen);
4169     print_result (rc, result, resultlen);
4170   }
4171
4172
4173   if (!no_poll)
4174     ccid_poll (ccid);
4175
4176   fputs ("getting OpenPGP DO 0x65 ....\n", stderr);
4177   {
4178     static unsigned char apdu[] = { 0, 0xCA, 0, 0x65, 254 };
4179     rc = ccid_transceive (ccid, apdu, sizeof apdu,
4180                           result, sizeof result, &resultlen);
4181     print_result (rc, result, resultlen);
4182   }
4183
4184   if (!no_pinpad)
4185     {
4186     }
4187
4188   if (!no_pinpad)
4189     {
4190       static unsigned char apdu[] = { 0, 0x20, 0, 0x81 };
4191
4192
4193       if (ccid_transceive_secure (ccid,
4194                                   apdu, sizeof apdu,
4195                                   1, 0, 0, 0,
4196                                   NULL, 0, NULL))
4197         fputs ("can't verify using a PIN-Pad reader\n", stderr);
4198       else
4199         {
4200           fputs ("verifying CHV1 using the PINPad ....\n", stderr);
4201
4202           rc = ccid_transceive_secure (ccid,
4203                                        apdu, sizeof apdu,
4204                                        1, 0, 0, 0,
4205                                        result, sizeof result, &resultlen);
4206           print_result (rc, result, resultlen);
4207           did_verify = 1;
4208         }
4209     }
4210
4211   if (verify_123456 && !did_verify)
4212     {
4213       fputs ("verifying that CHV1 is 123456....\n", stderr);
4214       {
4215         static unsigned char apdu[] = {0, 0x20, 0, 0x81,
4216                                   &