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