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