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