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