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