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