common: Cleanup the use of USE_NPTH and HAVE_NPTH macros.
[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
967   return 0;
968 }
969
970
971 static char *
972 get_escaped_usb_string (usb_dev_handle *idev, int idx,
973                         const char *prefix, const char *suffix)
974 {
975   int rc;
976   unsigned char buf[280];
977   unsigned char *s;
978   unsigned int langid;
979   size_t i, n, len;
980   char *result;
981
982   if (!idx)
983     return NULL;
984
985   /* Fixme: The next line is for the current Valgrid without support
986      for USB IOCTLs. */
987   memset (buf, 0, sizeof buf);
988
989   /* First get the list of supported languages and use the first one.
990      If we do don't find it we try to use English.  Note that this is
991      all in a 2 bute Unicode encoding using little endian. */
992   rc = usb_control_msg (idev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
993                         (USB_DT_STRING << 8), 0,
994                         (char*)buf, sizeof buf, 1000 /* ms timeout */);
995   if (rc < 4)
996     langid = 0x0409; /* English.  */
997   else
998     langid = (buf[3] << 8) | buf[2];
999
1000   rc = usb_control_msg (idev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
1001                         (USB_DT_STRING << 8) + idx, langid,
1002                         (char*)buf, sizeof buf, 1000 /* ms timeout */);
1003   if (rc < 2 || buf[1] != USB_DT_STRING)
1004     return NULL; /* Error or not a string. */
1005   len = buf[0];
1006   if (len > rc)
1007     return NULL; /* Larger than our buffer. */
1008
1009   for (s=buf+2, i=2, n=0; i+1 < len; i += 2, s += 2)
1010     {
1011       if (s[1])
1012         n++; /* High byte set. */
1013       else if (*s <= 0x20 || *s >= 0x7f || *s == '%' || *s == ':')
1014         n += 3 ;
1015       else
1016         n++;
1017     }
1018
1019   result = malloc (strlen (prefix) + n + strlen (suffix) + 1);
1020   if (!result)
1021     return NULL;
1022
1023   strcpy (result, prefix);
1024   n = strlen (prefix);
1025   for (s=buf+2, i=2; i+1 < len; i += 2, s += 2)
1026     {
1027       if (s[1])
1028         result[n++] = '\xff'; /* High byte set. */
1029       else if (*s <= 0x20 || *s >= 0x7f || *s == '%' || *s == ':')
1030         {
1031           sprintf (result+n, "%%%02X", *s);
1032           n += 3;
1033         }
1034       else
1035         result[n++] = *s;
1036     }
1037   strcpy (result+n, suffix);
1038
1039   return result;
1040 }
1041
1042 /* This function creates an reader id to be used to find the same
1043    physical reader after a reset.  It returns an allocated and possibly
1044    percent escaped string or NULL if not enough memory is available. */
1045 static char *
1046 make_reader_id (usb_dev_handle *idev,
1047                 unsigned int vendor, unsigned int product,
1048                 unsigned char serialno_index)
1049 {
1050   char *rid;
1051   char prefix[20];
1052
1053   sprintf (prefix, "%04X:%04X:", (vendor & 0xffff), (product & 0xffff));
1054   rid = get_escaped_usb_string (idev, serialno_index, prefix, ":0");
1055   if (!rid)
1056     {
1057       rid = malloc (strlen (prefix) + 3 + 1);
1058       if (!rid)
1059         return NULL;
1060       strcpy (rid, prefix);
1061       strcat (rid, "X:0");
1062     }
1063   return rid;
1064 }
1065
1066
1067 /* Helper to find the endpoint from an interface descriptor.  */
1068 static int
1069 find_endpoint (struct usb_interface_descriptor *ifcdesc, int mode)
1070 {
1071   int no;
1072   int want_bulk_in = 0;
1073
1074   if (mode == 1)
1075     want_bulk_in = 0x80;
1076   for (no=0; no < ifcdesc->bNumEndpoints; no++)
1077     {
1078       struct usb_endpoint_descriptor *ep = ifcdesc->endpoint + no;
1079       if (ep->bDescriptorType != USB_DT_ENDPOINT)
1080         ;
1081       else if (mode == 2
1082           && ((ep->bmAttributes & USB_ENDPOINT_TYPE_MASK)
1083               == USB_ENDPOINT_TYPE_INTERRUPT)
1084           && (ep->bEndpointAddress & 0x80))
1085         return (ep->bEndpointAddress & 0x0f);
1086       else if (((ep->bmAttributes & USB_ENDPOINT_TYPE_MASK)
1087                 == USB_ENDPOINT_TYPE_BULK)
1088                && (ep->bEndpointAddress & 0x80) == want_bulk_in)
1089         return (ep->bEndpointAddress & 0x0f);
1090     }
1091   /* Should never happen.  */
1092   return mode == 2? 0x83 : mode == 1? 0x82 :1;
1093 }
1094
1095
1096 /* Helper for scan_or_find_devices. This function returns true if a
1097    requested device has been found or the caller should stop scanning
1098    for other reasons. */
1099 static int
1100 scan_or_find_usb_device (int scan_mode,
1101                          int *readerno, int *count, char **rid_list,
1102                          const char *readerid,
1103                          struct usb_device *dev,
1104                          char **r_rid,
1105                          struct usb_device **r_dev,
1106                          usb_dev_handle **r_idev,
1107                          unsigned char **ifcdesc_extra,
1108                          size_t *ifcdesc_extra_len,
1109                          int *interface_number,
1110                          int *ep_bulk_out, int *ep_bulk_in, int *ep_intr)
1111 {
1112   int cfg_no;
1113   int ifc_no;
1114   int set_no;
1115   struct usb_config_descriptor *config;
1116   struct usb_interface *interface;
1117   struct usb_interface_descriptor *ifcdesc;
1118   char *rid;
1119   usb_dev_handle *idev;
1120
1121   *r_idev = NULL;
1122
1123   for (cfg_no=0; cfg_no < dev->descriptor.bNumConfigurations; cfg_no++)
1124     {
1125       config = dev->config + cfg_no;
1126       if(!config)
1127         continue;
1128
1129       for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
1130         {
1131           interface = config->interface + ifc_no;
1132           if (!interface)
1133             continue;
1134
1135           for (set_no=0; set_no < interface->num_altsetting; set_no++)
1136             {
1137               ifcdesc = (interface->altsetting + set_no);
1138               /* The second condition is for older SCM SPR 532 who did
1139                  not know about the assigned CCID class.  The third
1140                  condition does the same for a Cherry SmartTerminal
1141                  ST-2000.  Instead of trying to interpret the strings
1142                  we simply check the product ID. */
1143               if (ifcdesc && ifcdesc->extra
1144                   && ((ifcdesc->bInterfaceClass == 11
1145                        && ifcdesc->bInterfaceSubClass == 0
1146                        && ifcdesc->bInterfaceProtocol == 0)
1147                       || (ifcdesc->bInterfaceClass == 255
1148                           && dev->descriptor.idVendor == VENDOR_SCM
1149                           && dev->descriptor.idProduct == SCM_SPR532)
1150                       || (ifcdesc->bInterfaceClass == 255
1151                           && dev->descriptor.idVendor == VENDOR_CHERRY
1152                           && dev->descriptor.idProduct == CHERRY_ST2000)))
1153                 {
1154                   idev = usb_open (dev);
1155                   if (!idev)
1156                     {
1157                       DEBUGOUT_1 ("usb_open failed: %s\n",
1158                                   strerror (errno));
1159                       continue; /* with next setting. */
1160                     }
1161
1162                   rid = make_reader_id (idev,
1163                                         dev->descriptor.idVendor,
1164                                         dev->descriptor.idProduct,
1165                                         dev->descriptor.iSerialNumber);
1166                   if (rid)
1167                     {
1168                       if (scan_mode)
1169                         {
1170                           char *p;
1171
1172                           /* We are collecting infos about all
1173                              available CCID readers.  Store them and
1174                              continue. */
1175                           DEBUGOUT_2 ("found CCID reader %d (ID=%s)\n",
1176                                       *count, rid );
1177                           p = malloc ((*rid_list? strlen (*rid_list):0) + 1
1178                                       + strlen (rid) + 1);
1179                           if (p)
1180                             {
1181                               *p = 0;
1182                               if (*rid_list)
1183                                 {
1184                                   strcat (p, *rid_list);
1185                                   free (*rid_list);
1186                                 }
1187                               strcat (p, rid);
1188                               strcat (p, "\n");
1189                               *rid_list = p;
1190                             }
1191                           else /* Out of memory. */
1192                             free (rid);
1193
1194                           rid = NULL;
1195                           ++*count;
1196                         }
1197                       else if (!*readerno
1198                                || (*readerno < 0
1199                                    && readerid
1200                                    && !strcmp (readerid, rid)))
1201                         {
1202                           /* We found the requested reader. */
1203                           if (ifcdesc_extra && ifcdesc_extra_len)
1204                             {
1205                               *ifcdesc_extra = malloc (ifcdesc
1206                                                        ->extralen);
1207                               if (!*ifcdesc_extra)
1208                                 {
1209                                   usb_close (idev);
1210                                   free (rid);
1211                                   return 1; /* Out of core. */
1212                                 }
1213                               memcpy (*ifcdesc_extra, ifcdesc->extra,
1214                                       ifcdesc->extralen);
1215                               *ifcdesc_extra_len = ifcdesc->extralen;
1216                             }
1217
1218                           if (interface_number)
1219                             *interface_number = (ifcdesc->bInterfaceNumber);
1220
1221                           if (ep_bulk_out)
1222                             *ep_bulk_out = find_endpoint (ifcdesc, 0);
1223                           if (ep_bulk_in)
1224                             *ep_bulk_in = find_endpoint (ifcdesc, 1);
1225                           if (ep_intr)
1226                             *ep_intr = find_endpoint (ifcdesc, 2);
1227
1228                           if (r_dev)
1229                             *r_dev = dev;
1230                           if (r_rid)
1231                             {
1232                               *r_rid = rid;
1233                               rid = NULL;
1234                             }
1235                           else
1236                             free (rid);
1237
1238                           *r_idev = idev;
1239                           return 1; /* Found requested device. */
1240                         }
1241                       else
1242                         {
1243                           /* This is not yet the reader we want.
1244                              fixme: We should avoid the extra usb_open
1245                              in this case. */
1246                           if (*readerno >= 0)
1247                             --*readerno;
1248                         }
1249                       free (rid);
1250                     }
1251
1252                   usb_close (idev);
1253                   idev = NULL;
1254                   return 0;
1255                 }
1256             }
1257         }
1258     }
1259
1260   return 0;
1261 }
1262
1263 /* Combination function to either scan all CCID devices or to find and
1264    open one specific device.
1265
1266    The function returns 0 if a reader has been found or when a scan
1267    returned without error.
1268
1269    With READERNO = -1 and READERID is NULL, scan mode is used and
1270    R_RID should be the address where to store the list of reader_ids
1271    we found.  If on return this list is empty, no CCID device has been
1272    found; otherwise it points to an allocated linked list of reader
1273    IDs.  Note that in this mode the function always returns NULL.
1274
1275    With READERNO >= 0 or READERID is not NULL find mode is used.  This
1276    uses the same algorithm as the scan mode but stops and returns at
1277    the entry number READERNO and return the handle for the the opened
1278    USB device. If R_RID is not NULL it will receive the reader ID of
1279    that device.  If R_DEV is not NULL it will the device pointer of
1280    that device.  If IFCDESC_EXTRA is NOT NULL it will receive a
1281    malloced copy of the interfaces "extra: data filed;
1282    IFCDESC_EXTRA_LEN receive the length of this field.  If there is
1283    no reader with number READERNO or that reader is not usable by our
1284    implementation NULL will be returned.  The caller must close a
1285    returned USB device handle and free (if not passed as NULL) the
1286    returned reader ID info as well as the IFCDESC_EXTRA.  On error
1287    NULL will get stored at R_RID, R_DEV, IFCDESC_EXTRA and
1288    IFCDESC_EXTRA_LEN.  With READERID being -1 the function stops if
1289    the READERID was found.
1290
1291    If R_FD is not -1 on return the device is not using USB for
1292    transport but the device associated with that file descriptor.  In
1293    this case INTERFACE will receive the transport type and the other
1294    USB specific return values are not used; the return value is
1295    (void*)(1).
1296
1297    Note that the first entry of the returned reader ID list in scan mode
1298    corresponds with a READERNO of 0 in find mode.
1299 */
1300 static int
1301 scan_or_find_devices (int readerno, const char *readerid,
1302                       char **r_rid,
1303                       struct usb_device **r_dev,
1304                       unsigned char **ifcdesc_extra,
1305                       size_t *ifcdesc_extra_len,
1306                       int *interface_number,
1307                       int *ep_bulk_out, int *ep_bulk_in, int *ep_intr,
1308                       usb_dev_handle **r_idev,
1309                       int *r_fd)
1310 {
1311   char *rid_list = NULL;
1312   int count = 0;
1313   struct usb_bus *busses, *bus;
1314   struct usb_device *dev = NULL;
1315   usb_dev_handle *idev = NULL;
1316   int scan_mode = (readerno == -1 && !readerid);
1317   int i;
1318
1319   /* Set return values to a default. */
1320   if (r_rid)
1321     *r_rid = NULL;
1322   if (r_dev)
1323     *r_dev = NULL;
1324   if (ifcdesc_extra)
1325     *ifcdesc_extra = NULL;
1326   if (ifcdesc_extra_len)
1327     *ifcdesc_extra_len = 0;
1328   if (interface_number)
1329     *interface_number = 0;
1330   if (r_idev)
1331     *r_idev = NULL;
1332   if (r_fd)
1333     *r_fd = -1;
1334
1335   /* See whether we want scan or find mode. */
1336   if (scan_mode)
1337     {
1338       assert (r_rid);
1339     }
1340
1341   usb_find_busses();
1342   usb_find_devices();
1343
1344 #ifdef HAVE_USB_GET_BUSSES
1345   busses = usb_get_busses();
1346 #else
1347   busses = usb_busses;
1348 #endif
1349
1350   for (bus = busses; bus; bus = bus->next)
1351     {
1352       for (dev = bus->devices; dev; dev = dev->next)
1353         {
1354           if (scan_or_find_usb_device (scan_mode, &readerno, &count, &rid_list,
1355                                        readerid,
1356                                        dev,
1357                                        r_rid,
1358                                        r_dev,
1359                                        &idev,
1360                                        ifcdesc_extra,
1361                                        ifcdesc_extra_len,
1362                                        interface_number,
1363                                        ep_bulk_out, ep_bulk_in, ep_intr))
1364             {
1365               /* Found requested device or out of core. */
1366               if (!idev)
1367                 {
1368                   free (rid_list);
1369                   return -1; /* error */
1370                 }
1371               *r_idev = idev;
1372               return 0;
1373             }
1374         }
1375     }
1376
1377   /* Now check whether there are any devices with special transport types. */
1378   for (i=0; transports[i].name; i++)
1379     {
1380       int fd;
1381       char *rid, *p;
1382
1383       fd = open (transports[i].name, O_RDWR);
1384       if (fd == -1 && scan_mode && errno == EBUSY)
1385         {
1386           /* Ignore this error in scan mode because it indicates that
1387              the device exists but is already open (most likely by us)
1388              and thus in general suitable as a reader.  */
1389         }
1390       else if (fd == -1)
1391         {
1392           DEBUGOUT_2 ("failed to open '%s': %s\n",
1393                      transports[i].name, strerror (errno));
1394           continue;
1395         }
1396
1397       rid = malloc (strlen (transports[i].name) + 30 + 10);
1398       if (!rid)
1399         {
1400           if (fd != -1)
1401             close (fd);
1402           free (rid_list);
1403           return -1; /* Error. */
1404         }
1405       sprintf (rid, "0000:%04X:%s:0", transports[i].type, transports[i].name);
1406       if (scan_mode)
1407         {
1408           DEBUGOUT_2 ("found CCID reader %d (ID=%s)\n", count, rid);
1409           p = malloc ((rid_list? strlen (rid_list):0) + 1 + strlen (rid) + 1);
1410           if (!p)
1411             {
1412               if (fd != -1)
1413                 close (fd);
1414               free (rid_list);
1415               free (rid);
1416               return -1; /* Error. */
1417             }
1418           *p = 0;
1419           if (rid_list)
1420             {
1421               strcat (p, rid_list);
1422               free (rid_list);
1423             }
1424           strcat (p, rid);
1425           strcat (p, "\n");
1426           rid_list = p;
1427           ++count;
1428         }
1429       else if (!readerno ||
1430                (readerno < 0 && readerid && !strcmp (readerid, rid)))
1431         {
1432           /* Found requested device. */
1433           if (interface_number)
1434             *interface_number = transports[i].type;
1435           if (r_rid)
1436             *r_rid = rid;
1437           else
1438             free (rid);
1439           if (r_fd)
1440             *r_fd = fd;
1441           return 0; /* Okay, found device */
1442         }
1443       else /* This is not yet the reader we want. */
1444         {
1445           if (readerno >= 0)
1446             --readerno;
1447         }
1448       free (rid);
1449       if (fd != -1)
1450         close (fd);
1451     }
1452
1453   if (scan_mode)
1454     {
1455       *r_rid = rid_list;
1456       return 0;
1457     }
1458   else
1459     return -1;
1460 }
1461
1462
1463 /* Set the level of debugging to LEVEL and return the old level.  -1
1464    just returns the old level.  A level of 0 disables debugging, 1
1465    enables debugging, 2 enables additional tracing of the T=1
1466    protocol, 3 additionally enables debugging for GetSlotStatus, other
1467    values are not yet defined.
1468
1469    Note that libusb may provide its own debugging feature which is
1470    enabled by setting the envvar USB_DEBUG.  */
1471 int
1472 ccid_set_debug_level (int level)
1473 {
1474   int old = debug_level;
1475   if (level != -1)
1476     debug_level = level;
1477   return old;
1478 }
1479
1480
1481 char *
1482 ccid_get_reader_list (void)
1483 {
1484   char *reader_list;
1485
1486   if (!initialized_usb)
1487     {
1488       usb_init ();
1489       initialized_usb = 1;
1490     }
1491
1492   if (scan_or_find_devices (-1, NULL, &reader_list, NULL, NULL, NULL, NULL,
1493                             NULL, NULL, NULL, NULL, NULL))
1494     return NULL; /* Error. */
1495   return reader_list;
1496 }
1497
1498
1499 /* Vendor specific custom initialization.  */
1500 static int
1501 ccid_vendor_specific_init (ccid_driver_t handle)
1502 {
1503   if (handle->id_vendor == VENDOR_VEGA && handle->id_product == VEGA_ALPHA)
1504     {
1505       int r;
1506       /*
1507        * Vega alpha has a feature to show retry counter on the pinpad
1508        * display.  But it assumes that the card returns the value of
1509        * retry counter by VERIFY with empty data (return code of
1510        * 63Cx).  Unfortunately, existing OpenPGP cards don't support
1511        * VERIFY command with empty data.  This vendor specific command
1512        * sequence is to disable the feature.
1513        */
1514       const unsigned char cmd[] = { '\xb5', '\x01', '\x00', '\x03', '\x00' };
1515
1516       r = send_escape_cmd (handle, cmd, sizeof (cmd), NULL, 0, NULL);
1517       if (r != 0 && r != CCID_DRIVER_ERR_CARD_INACTIVE
1518           && r != CCID_DRIVER_ERR_NO_CARD)
1519         return r;
1520     }
1521
1522   return 0;
1523 }
1524
1525
1526 /* Open the reader with the internal number READERNO and return a
1527    pointer to be used as handle in HANDLE.  Returns 0 on success. */
1528 int
1529 ccid_open_reader (ccid_driver_t *handle, const char *readerid)
1530 {
1531   int rc = 0;
1532   struct usb_device *dev = NULL;
1533   usb_dev_handle *idev = NULL;
1534   int dev_fd = -1;
1535   char *rid = NULL;
1536   unsigned char *ifcdesc_extra = NULL;
1537   size_t ifcdesc_extra_len;
1538   int readerno;
1539   int ifc_no, ep_bulk_out, ep_bulk_in, ep_intr;
1540
1541   *handle = NULL;
1542
1543   if (!initialized_usb)
1544     {
1545       usb_init ();
1546       initialized_usb = 1;
1547     }
1548
1549   /* See whether we want to use the reader ID string or a reader
1550      number. A readerno of -1 indicates that the reader ID string is
1551      to be used. */
1552   if (readerid && strchr (readerid, ':'))
1553     readerno = -1; /* We want to use the readerid.  */
1554   else if (readerid)
1555     {
1556       readerno = atoi (readerid);
1557       if (readerno < 0)
1558         {
1559           DEBUGOUT ("no CCID readers found\n");
1560           rc = CCID_DRIVER_ERR_NO_READER;
1561           goto leave;
1562         }
1563     }
1564   else
1565     readerno = 0;  /* Default. */
1566
1567   if (scan_or_find_devices (readerno, readerid, &rid, &dev,
1568                             &ifcdesc_extra, &ifcdesc_extra_len,
1569                             &ifc_no, &ep_bulk_out, &ep_bulk_in, &ep_intr,
1570                             &idev, &dev_fd) )
1571     {
1572       if (readerno == -1)
1573         DEBUGOUT_1 ("no CCID reader with ID %s\n", readerid );
1574       else
1575         DEBUGOUT_1 ("no CCID reader with number %d\n", readerno );
1576       rc = CCID_DRIVER_ERR_NO_READER;
1577       goto leave;
1578     }
1579
1580   /* Okay, this is a CCID reader. */
1581   *handle = calloc (1, sizeof **handle);
1582   if (!*handle)
1583     {
1584       DEBUGOUT ("out of memory\n");
1585       rc = CCID_DRIVER_ERR_OUT_OF_CORE;
1586       goto leave;
1587     }
1588   (*handle)->rid = rid;
1589   if (idev) /* Regular USB transport. */
1590     {
1591       (*handle)->idev = idev;
1592       (*handle)->dev_fd = -1;
1593       (*handle)->id_vendor = dev->descriptor.idVendor;
1594       (*handle)->id_product = dev->descriptor.idProduct;
1595       (*handle)->bcd_device = dev->descriptor.bcdDevice;
1596       (*handle)->ifc_no = ifc_no;
1597       (*handle)->ep_bulk_out = ep_bulk_out;
1598       (*handle)->ep_bulk_in = ep_bulk_in;
1599       (*handle)->ep_intr = ep_intr;
1600     }
1601   else if (dev_fd != -1) /* Device transport. */
1602     {
1603       (*handle)->idev = NULL;
1604       (*handle)->dev_fd = dev_fd;
1605       (*handle)->id_vendor = 0;  /* Magic vendor for special transport. */
1606       (*handle)->id_product = ifc_no; /* Transport type */
1607       prepare_special_transport (*handle);
1608     }
1609   else
1610     {
1611       assert (!"no transport"); /* Bug. */
1612     }
1613
1614   DEBUGOUT_2 ("using CCID reader %d (ID=%s)\n",  readerno, rid );
1615
1616   if (idev)
1617     {
1618       if (parse_ccid_descriptor (*handle, ifcdesc_extra, ifcdesc_extra_len))
1619         {
1620           DEBUGOUT ("device not supported\n");
1621           rc = CCID_DRIVER_ERR_NO_READER;
1622           goto leave;
1623         }
1624
1625       rc = usb_claim_interface (idev, ifc_no);
1626       if (rc)
1627         {
1628           DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
1629           rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1630           goto leave;
1631         }
1632     }
1633
1634   rc = ccid_vendor_specific_init (*handle);
1635
1636  leave:
1637   free (ifcdesc_extra);
1638   if (rc)
1639     {
1640       free (rid);
1641       if (idev)
1642         usb_close (idev);
1643       if (dev_fd != -1)
1644         close (dev_fd);
1645       free (*handle);
1646       *handle = NULL;
1647     }
1648
1649   return rc;
1650 }
1651
1652
1653 static void
1654 do_close_reader (ccid_driver_t handle)
1655 {
1656   int rc;
1657   unsigned char msg[100];
1658   size_t msglen;
1659   unsigned char seqno;
1660
1661   if (!handle->powered_off)
1662     {
1663       msg[0] = PC_to_RDR_IccPowerOff;
1664       msg[5] = 0; /* slot */
1665       msg[6] = seqno = handle->seqno++;
1666       msg[7] = 0; /* RFU */
1667       msg[8] = 0; /* RFU */
1668       msg[9] = 0; /* RFU */
1669       set_msg_len (msg, 0);
1670       msglen = 10;
1671
1672       rc = bulk_out (handle, msg, msglen, 0);
1673       if (!rc)
1674         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
1675                  seqno, 2000, 0);
1676       handle->powered_off = 1;
1677     }
1678   if (handle->idev)
1679     {
1680       usb_release_interface (handle->idev, handle->ifc_no);
1681       usb_close (handle->idev);
1682       handle->idev = NULL;
1683     }
1684   if (handle->dev_fd != -1)
1685     {
1686       close (handle->dev_fd);
1687       handle->dev_fd = -1;
1688     }
1689 }
1690
1691
1692 /* Reset a reader on HANDLE.  This is useful in case a reader has been
1693    plugged of and inserted at a different port.  By resetting the
1694    handle, the same reader will be get used.  Note, that on error the
1695    handle won't get released.
1696
1697    This does not return an ATR, so ccid_get_atr should be called right
1698    after this one.
1699 */
1700 int
1701 ccid_shutdown_reader (ccid_driver_t handle)
1702 {
1703   int rc = 0;
1704   struct usb_device *dev = NULL;
1705   usb_dev_handle *idev = NULL;
1706   unsigned char *ifcdesc_extra = NULL;
1707   size_t ifcdesc_extra_len;
1708   int ifc_no, ep_bulk_out, ep_bulk_in, ep_intr;
1709
1710   if (!handle || !handle->rid)
1711     return CCID_DRIVER_ERR_INV_VALUE;
1712
1713   do_close_reader (handle);
1714
1715   if (scan_or_find_devices (-1, handle->rid, NULL, &dev,
1716                             &ifcdesc_extra, &ifcdesc_extra_len,
1717                             &ifc_no, &ep_bulk_out, &ep_bulk_in, &ep_intr,
1718                             &idev, NULL) || !idev)
1719     {
1720       DEBUGOUT_1 ("no CCID reader with ID %s\n", handle->rid);
1721       return CCID_DRIVER_ERR_NO_READER;
1722     }
1723
1724   if (idev)
1725     {
1726       handle->idev = idev;
1727       handle->ifc_no = ifc_no;
1728       handle->ep_bulk_out = ep_bulk_out;
1729       handle->ep_bulk_in = ep_bulk_in;
1730       handle->ep_intr = ep_intr;
1731
1732       if (parse_ccid_descriptor (handle, ifcdesc_extra, ifcdesc_extra_len))
1733         {
1734           DEBUGOUT ("device not supported\n");
1735           rc = CCID_DRIVER_ERR_NO_READER;
1736           goto leave;
1737         }
1738
1739       rc = usb_claim_interface (idev, ifc_no);
1740       if (rc)
1741         {
1742           DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
1743           rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1744           goto leave;
1745         }
1746     }
1747
1748  leave:
1749   free (ifcdesc_extra);
1750   if (rc)
1751     {
1752       if (handle->idev)
1753         usb_close (handle->idev);
1754       handle->idev = NULL;
1755       if (handle->dev_fd != -1)
1756         close (handle->dev_fd);
1757       handle->dev_fd = -1;
1758     }
1759
1760   return rc;
1761
1762 }
1763
1764
1765 int
1766 ccid_set_progress_cb (ccid_driver_t handle,
1767                       void (*cb)(void *, const char *, int, int, int),
1768                       void *cb_arg)
1769 {
1770   if (!handle || !handle->rid)
1771     return CCID_DRIVER_ERR_INV_VALUE;
1772
1773   handle->progress_cb = cb;
1774   handle->progress_cb_arg = cb_arg;
1775   return 0;
1776 }
1777
1778
1779 /* Close the reader HANDLE. */
1780 int
1781 ccid_close_reader (ccid_driver_t handle)
1782 {
1783   if (!handle || (!handle->idev && handle->dev_fd == -1))
1784     return 0;
1785
1786   do_close_reader (handle);
1787   free (handle->rid);
1788   free (handle);
1789   return 0;
1790 }
1791
1792
1793 /* Return False if a card is present and powered. */
1794 int
1795 ccid_check_card_presence (ccid_driver_t handle)
1796 {
1797   (void)handle;  /* Not yet implemented.  */
1798   return -1;
1799 }
1800
1801
1802 /* Write NBYTES of BUF to file descriptor FD. */
1803 static int
1804 writen (int fd, const void *buf, size_t nbytes)
1805 {
1806   size_t nleft = nbytes;
1807   int nwritten;
1808
1809   while (nleft > 0)
1810     {
1811       nwritten = write (fd, buf, nleft);
1812       if (nwritten < 0)
1813         {
1814           if (errno == EINTR)
1815             nwritten = 0;
1816           else
1817             return -1;
1818         }
1819       nleft -= nwritten;
1820       buf = (const char*)buf + nwritten;
1821     }
1822
1823   return 0;
1824 }
1825
1826
1827 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
1828    Returns 0 on success. */
1829 static int
1830 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen,
1831           int no_debug)
1832 {
1833   int rc;
1834
1835   /* No need to continue and clutter the log with USB write error
1836      messages after we got the first ENODEV.  */
1837   if (handle->enodev_seen)
1838     return CCID_DRIVER_ERR_NO_READER;
1839
1840   if (debug_level && (!no_debug || debug_level >= 3))
1841     {
1842       switch (msglen? msg[0]:0)
1843         {
1844         case PC_to_RDR_IccPowerOn:
1845           print_p2r_iccpoweron (msg, msglen);
1846           break;
1847         case PC_to_RDR_IccPowerOff:
1848           print_p2r_iccpoweroff (msg, msglen);
1849           break;
1850         case PC_to_RDR_GetSlotStatus:
1851           print_p2r_getslotstatus (msg, msglen);
1852           break;
1853         case PC_to_RDR_XfrBlock:
1854           print_p2r_xfrblock (msg, msglen);
1855           break;
1856         case PC_to_RDR_GetParameters:
1857           print_p2r_getparameters (msg, msglen);
1858           break;
1859         case PC_to_RDR_ResetParameters:
1860           print_p2r_resetparameters (msg, msglen);
1861           break;
1862         case PC_to_RDR_SetParameters:
1863           print_p2r_setparameters (msg, msglen);
1864           break;
1865         case PC_to_RDR_Escape:
1866           print_p2r_escape (msg, msglen);
1867           break;
1868         case PC_to_RDR_IccClock:
1869           print_p2r_iccclock (msg, msglen);
1870           break;
1871         case PC_to_RDR_T0APDU:
1872           print_p2r_to0apdu (msg, msglen);
1873           break;
1874         case PC_to_RDR_Secure:
1875           print_p2r_secure (msg, msglen);
1876           break;
1877         case PC_to_RDR_Mechanical:
1878           print_p2r_mechanical (msg, msglen);
1879           break;
1880         case PC_to_RDR_Abort:
1881           print_p2r_abort (msg, msglen);
1882           break;
1883         case PC_to_RDR_SetDataRate:
1884           print_p2r_setdatarate (msg, msglen);
1885           break;
1886         default:
1887           print_p2r_unknown (msg, msglen);
1888           break;
1889         }
1890     }
1891
1892   if (handle->idev)
1893     {
1894       rc = usb_bulk_write (handle->idev,
1895                            handle->ep_bulk_out,
1896                            (char*)msg, msglen,
1897                            5000 /* ms timeout */);
1898       if (rc == msglen)
1899         return 0;
1900 #ifdef ENODEV
1901       if (rc == -(ENODEV))
1902         {
1903           /* The Linux libusb returns a negative error value.  Catch
1904              the most important one.  */
1905           errno = ENODEV;
1906           rc = -1;
1907         }
1908 #endif /*ENODEV*/
1909
1910       if (rc == -1)
1911         {
1912           DEBUGOUT_1 ("usb_bulk_write error: %s\n", strerror (errno));
1913 #ifdef ENODEV
1914           if (errno == ENODEV)
1915             {
1916               handle->enodev_seen = 1;
1917               return CCID_DRIVER_ERR_NO_READER;
1918             }
1919 #endif /*ENODEV*/
1920         }
1921       else
1922         DEBUGOUT_1 ("usb_bulk_write failed: %d\n", rc);
1923     }
1924   else
1925     {
1926       rc = writen (handle->dev_fd, msg, msglen);
1927       if (!rc)
1928         return 0;
1929       DEBUGOUT_2 ("writen to %d failed: %s\n",
1930                   handle->dev_fd, strerror (errno));
1931
1932     }
1933   return CCID_DRIVER_ERR_CARD_IO_ERROR;
1934 }
1935
1936
1937 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
1938    BUFFER and return the actual read number if bytes in NREAD. SEQNO
1939    is the sequence number used to send the request and EXPECTED_TYPE
1940    the type of message we expect. Does checks on the ccid
1941    header. TIMEOUT is the timeout value in ms. NO_DEBUG may be set to
1942    avoid debug messages in case of no error; this can be overriden
1943    with a glibal debug level of at least 3. Returns 0 on success. */
1944 static int
1945 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
1946          size_t *nread, int expected_type, int seqno, int timeout,
1947          int no_debug)
1948 {
1949   int rc;
1950   size_t msglen;
1951   int eagain_retries = 0;
1952
1953   /* Fixme: The next line for the current Valgrind without support
1954      for USB IOCTLs. */
1955   memset (buffer, 0, length);
1956  retry:
1957   if (handle->idev)
1958     {
1959       rc = usb_bulk_read (handle->idev,
1960                           handle->ep_bulk_in,
1961                           (char*)buffer, length,
1962                           timeout);
1963       if (rc < 0)
1964         {
1965           rc = errno;
1966           DEBUGOUT_1 ("usb_bulk_read error: %s\n", strerror (rc));
1967           if (rc == EAGAIN && eagain_retries++ < 3)
1968             {
1969               my_sleep (1);
1970               goto retry;
1971             }
1972           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1973         }
1974       *nread = msglen = rc;
1975     }
1976   else
1977     {
1978       rc = read (handle->dev_fd, buffer, length);
1979       if (rc < 0)
1980         {
1981           rc = errno;
1982           DEBUGOUT_2 ("read from %d failed: %s\n",
1983                       handle->dev_fd, strerror (rc));
1984           if (rc == EAGAIN && eagain_retries++ < 5)
1985             {
1986               my_sleep (1);
1987               goto retry;
1988             }
1989           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1990         }
1991       *nread = msglen = rc;
1992     }
1993   eagain_retries = 0;
1994
1995   if (msglen < 10)
1996     {
1997       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
1998       abort_cmd (handle, seqno);
1999       return CCID_DRIVER_ERR_INV_VALUE;
2000     }
2001   if (buffer[5] != 0)
2002     {
2003       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
2004       return CCID_DRIVER_ERR_INV_VALUE;
2005     }
2006   if (buffer[6] != seqno)
2007     {
2008       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
2009                   seqno, buffer[6]);
2010       /* Retry until we are synced again.  */
2011       goto retry;
2012     }
2013
2014   /* We need to handle the time extension request before we check that
2015      we got the expected message type.  This is in particular required
2016      for the Cherry keyboard which sends a time extension request for
2017      each key hit.  */
2018   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
2019     {
2020       /* Card present and active, time extension requested. */
2021       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
2022                   buffer[7], buffer[8]);
2023       goto retry;
2024     }
2025
2026   if (buffer[0] != expected_type)
2027     {
2028       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
2029       abort_cmd (handle, seqno);
2030       return CCID_DRIVER_ERR_INV_VALUE;
2031     }
2032
2033   if (debug_level && (!no_debug || debug_level >= 3))
2034     {
2035       switch (buffer[0])
2036         {
2037         case RDR_to_PC_DataBlock:
2038           print_r2p_datablock (buffer, msglen);
2039           break;
2040         case RDR_to_PC_SlotStatus:
2041           print_r2p_slotstatus (buffer, msglen);
2042           break;
2043         case RDR_to_PC_Parameters:
2044           print_r2p_parameters (buffer, msglen);
2045           break;
2046         case RDR_to_PC_Escape:
2047           print_r2p_escape (buffer, msglen);
2048           break;
2049         case RDR_to_PC_DataRate:
2050           print_r2p_datarate (buffer, msglen);
2051           break;
2052         default:
2053           print_r2p_unknown (buffer, msglen);
2054           break;
2055         }
2056     }
2057   if (CCID_COMMAND_FAILED (buffer))
2058     print_command_failed (buffer);
2059
2060   /* Check whether a card is at all available.  Note: If you add new
2061      error codes here, check whether they need to be ignored in
2062      send_escape_cmd. */
2063   switch ((buffer[7] & 0x03))
2064     {
2065     case 0: /* no error */ break;
2066     case 1: return CCID_DRIVER_ERR_CARD_INACTIVE;
2067     case 2: return CCID_DRIVER_ERR_NO_CARD;
2068     case 3: /* RFU */ break;
2069     }
2070   return 0;
2071 }
2072
2073
2074
2075 /* Send an abort sequence and wait until everything settled.  */
2076 static int
2077 abort_cmd (ccid_driver_t handle, int seqno)
2078 {
2079   int rc;
2080   char dummybuf[8];
2081   unsigned char msg[100];
2082   size_t msglen;
2083
2084   if (!handle->idev)
2085     {
2086       /* I don't know how to send an abort to non-USB devices.  */
2087       rc = CCID_DRIVER_ERR_NOT_SUPPORTED;
2088     }
2089
2090   seqno &= 0xff;
2091   DEBUGOUT_1 ("sending abort sequence for seqno %d\n", seqno);
2092   /* Send the abort command to the control pipe.  Note that we don't
2093      need to keep track of sent abort commands because there should
2094      never be another thread using the same slot concurrently.  */
2095   rc = usb_control_msg (handle->idev,
2096                         0x21,/* bmRequestType: host-to-device,
2097                                 class specific, to interface.  */
2098                         1,   /* ABORT */
2099                         (seqno << 8 | 0 /* slot */),
2100                         handle->ifc_no,
2101                         dummybuf, 0,
2102                         1000 /* ms timeout */);
2103   if (rc < 0)
2104     {
2105       DEBUGOUT_1 ("usb_control_msg error: %s\n", strerror (errno));
2106       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2107     }
2108
2109   /* Now send the abort command to the bulk out pipe using the same
2110      SEQNO and SLOT.  Do this in a loop to so that all seqno are
2111      tried.  */
2112   seqno--;  /* Adjust for next increment.  */
2113   do
2114     {
2115       seqno++;
2116       msg[0] = PC_to_RDR_Abort;
2117       msg[5] = 0; /* slot */
2118       msg[6] = seqno;
2119       msg[7] = 0; /* RFU */
2120       msg[8] = 0; /* RFU */
2121       msg[9] = 0; /* RFU */
2122       msglen = 10;
2123       set_msg_len (msg, 0);
2124
2125       rc = usb_bulk_write (handle->idev,
2126                            handle->ep_bulk_out,
2127                            (char*)msg, msglen,
2128                            5000 /* ms timeout */);
2129       if (rc == msglen)
2130         rc = 0;
2131       else if (rc == -1)
2132         DEBUGOUT_1 ("usb_bulk_write error in abort_cmd: %s\n",
2133                     strerror (errno));
2134       else
2135         DEBUGOUT_1 ("usb_bulk_write failed in abort_cmd: %d\n", rc);
2136
2137       if (rc)
2138         return rc;
2139
2140       rc = usb_bulk_read (handle->idev,
2141                           handle->ep_bulk_in,
2142                           (char*)msg, sizeof msg,
2143                           5000 /*ms timeout*/);
2144       if (rc < 0)
2145         {
2146           DEBUGOUT_1 ("usb_bulk_read error in abort_cmd: %s\n",
2147                       strerror (errno));
2148           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2149         }
2150       msglen = rc;
2151
2152       if (msglen < 10)
2153         {
2154           DEBUGOUT_1 ("bulk-in msg in abort_cmd too short (%u)\n",
2155                       (unsigned int)msglen);
2156           return CCID_DRIVER_ERR_INV_VALUE;
2157         }
2158       if (msg[5] != 0)
2159         {
2160           DEBUGOUT_1 ("unexpected bulk-in slot (%d) in abort_cmd\n", msg[5]);
2161           return CCID_DRIVER_ERR_INV_VALUE;
2162         }
2163
2164       DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n",
2165                   msg[7], msg[8], msg[9]);
2166       if (CCID_COMMAND_FAILED (msg))
2167         print_command_failed (msg);
2168     }
2169   while (msg[0] != RDR_to_PC_SlotStatus && msg[5] != 0 && msg[6] != seqno);
2170
2171   handle->seqno = ((seqno + 1) & 0xff);
2172   DEBUGOUT ("sending abort sequence succeeded\n");
2173
2174   return 0;
2175 }
2176
2177
2178 /* Note that this function won't return the error codes NO_CARD or
2179    CARD_INACTIVE.  IF RESULT is not NULL, the result from the
2180    operation will get returned in RESULT and its length in RESULTLEN.
2181    If the response is larger than RESULTMAX, an error is returned and
2182    the required buffer length returned in RESULTLEN.  */
2183 static int
2184 send_escape_cmd (ccid_driver_t handle,
2185                  const unsigned char *data, size_t datalen,
2186                  unsigned char *result, size_t resultmax, size_t *resultlen)
2187 {
2188   int rc;
2189   unsigned char msg[100];
2190   size_t msglen;
2191   unsigned char seqno;
2192
2193   if (resultlen)
2194     *resultlen = 0;
2195
2196   if (datalen > sizeof msg - 10)
2197     return CCID_DRIVER_ERR_INV_VALUE; /* Escape data too large.  */
2198
2199   msg[0] = PC_to_RDR_Escape;
2200   msg[5] = 0; /* slot */
2201   msg[6] = seqno = handle->seqno++;
2202   msg[7] = 0; /* RFU */
2203   msg[8] = 0; /* RFU */
2204   msg[9] = 0; /* RFU */
2205   memcpy (msg+10, data, datalen);
2206   msglen = 10 + datalen;
2207   set_msg_len (msg, datalen);
2208
2209   rc = bulk_out (handle, msg, msglen, 0);
2210   if (rc)
2211     return rc;
2212   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Escape,
2213                 seqno, 5000, 0);
2214   if (result)
2215     switch (rc)
2216       {
2217         /* We need to ignore certain errorcode here. */
2218       case 0:
2219       case CCID_DRIVER_ERR_CARD_INACTIVE:
2220       case CCID_DRIVER_ERR_NO_CARD:
2221         {
2222           if (msglen > resultmax)
2223             rc = CCID_DRIVER_ERR_INV_VALUE; /* Response too large. */
2224           else
2225             {
2226               memcpy (result, msg, msglen);
2227               *resultlen = msglen;
2228             }
2229           rc = 0;
2230         }
2231         break;
2232       default:
2233         break;
2234       }
2235
2236   return rc;
2237 }
2238
2239
2240 int
2241 ccid_transceive_escape (ccid_driver_t handle,
2242                         const unsigned char *data, size_t datalen,
2243                         unsigned char *resp, size_t maxresplen, size_t *nresp)
2244 {
2245   return send_escape_cmd (handle, data, datalen, resp, maxresplen, nresp);
2246 }
2247
2248
2249
2250 /* experimental */
2251 int
2252 ccid_poll (ccid_driver_t handle)
2253 {
2254   int rc;
2255   unsigned char msg[10];
2256   size_t msglen;
2257   int i, j;
2258
2259   if (handle->idev)
2260     {
2261       rc = usb_bulk_read (handle->idev,
2262                           handle->ep_intr,
2263                           (char*)msg, sizeof msg,
2264                           0 /* ms timeout */ );
2265       if (rc < 0 && errno == ETIMEDOUT)
2266         return 0;
2267     }
2268   else
2269     return 0;
2270
2271   if (rc < 0)
2272     {
2273       DEBUGOUT_1 ("usb_intr_read error: %s\n", strerror (errno));
2274       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2275     }
2276
2277   msglen = rc;
2278   rc = 0;
2279
2280   if (msglen < 1)
2281     {
2282       DEBUGOUT ("intr-in msg too short\n");
2283       return CCID_DRIVER_ERR_INV_VALUE;
2284     }
2285
2286   if (msg[0] == RDR_to_PC_NotifySlotChange)
2287     {
2288       DEBUGOUT ("notify slot change:");
2289       for (i=1; i < msglen; i++)
2290         for (j=0; j < 4; j++)
2291           DEBUGOUT_CONT_3 (" %d:%c%c",
2292                            (i-1)*4+j,
2293                            (msg[i] & (1<<(j*2)))? 'p':'-',
2294                            (msg[i] & (2<<(j*2)))? '*':' ');
2295       DEBUGOUT_LF ();
2296     }
2297   else if (msg[0] == RDR_to_PC_HardwareError)
2298     {
2299       DEBUGOUT ("hardware error occured\n");
2300     }
2301   else
2302     {
2303       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
2304     }
2305
2306   return 0;
2307 }
2308
2309
2310 /* Note that this function won't return the error codes NO_CARD or
2311    CARD_INACTIVE */
2312 int
2313 ccid_slot_status (ccid_driver_t handle, int *statusbits)
2314 {
2315   int rc;
2316   unsigned char msg[100];
2317   size_t msglen;
2318   unsigned char seqno;
2319   int retries = 0;
2320
2321  retry:
2322   msg[0] = PC_to_RDR_GetSlotStatus;
2323   msg[5] = 0; /* slot */
2324   msg[6] = seqno = handle->seqno++;
2325   msg[7] = 0; /* RFU */
2326   msg[8] = 0; /* RFU */
2327   msg[9] = 0; /* RFU */
2328   set_msg_len (msg, 0);
2329
2330   rc = bulk_out (handle, msg, 10, 1);
2331   if (rc)
2332     return rc;
2333   /* Note that we set the NO_DEBUG flag here, so that the logs won't
2334      get cluttered up by a ticker function checking for the slot
2335      status and debugging enabled. */
2336   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
2337                 seqno, retries? 1000 : 200, 1);
2338   if (rc == CCID_DRIVER_ERR_CARD_IO_ERROR && retries < 3)
2339     {
2340       if (!retries)
2341         {
2342           DEBUGOUT ("USB: CALLING USB_CLEAR_HALT\n");
2343           usb_clear_halt (handle->idev, handle->ep_bulk_in);
2344           usb_clear_halt (handle->idev, handle->ep_bulk_out);
2345         }
2346       else
2347           DEBUGOUT ("USB: RETRYING bulk_in AGAIN\n");
2348       retries++;
2349       goto retry;
2350     }
2351   if (rc && rc != CCID_DRIVER_ERR_NO_CARD
2352       && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
2353     return rc;
2354   *statusbits = (msg[7] & 3);
2355
2356   return 0;
2357 }
2358
2359
2360 /* Parse ATR string (of ATRLEN) and update parameters at PARAM.
2361    Calling this routine, it should prepare default values at PARAM
2362    beforehand.  This routine assumes that card is accessed by T=1
2363    protocol.  It doesn't analyze historical bytes at all.
2364
2365    Returns < 0 value on error:
2366      -1 for parse error or integrity check error
2367      -2 for card doesn't support T=1 protocol
2368      -3 for parameters are nod explicitly defined by ATR
2369      -4 for this driver doesn't support CRC
2370
2371    Returns >= 0 on success:
2372       0 for card is negotiable mode
2373       1 for card is specific mode (and not negotiable)
2374  */
2375 static int
2376 update_param_by_atr (unsigned char *param, unsigned char *atr, size_t atrlen)
2377 {
2378   int i = -1;
2379   int t, y, chk;
2380   int historical_bytes_num, negotiable = 1;
2381
2382 #define NEXTBYTE() do { i++; if (atrlen <= i) return -1; } while (0)
2383
2384   NEXTBYTE ();
2385
2386   if (atr[i] == 0x3F)
2387     param[1] |= 0x02;           /* Convention is inverse.  */
2388   NEXTBYTE ();
2389
2390   y = (atr[i] >> 4);
2391   historical_bytes_num = atr[i] & 0x0f;
2392   NEXTBYTE ();
2393
2394   if ((y & 1))
2395     {
2396       param[0] = atr[i];        /* TA1 - Fi & Di */
2397       NEXTBYTE ();
2398     }
2399
2400   if ((y & 2))
2401     NEXTBYTE ();                /* TB1 - ignore */
2402
2403   if ((y & 4))
2404     {
2405       param[2] = atr[i];        /* TC1 - Guard Time */
2406       NEXTBYTE ();
2407     }
2408
2409   if ((y & 8))
2410     {
2411       y = (atr[i] >> 4);        /* TD1 */
2412       t = atr[i] & 0x0f;
2413       NEXTBYTE ();
2414
2415       if ((y & 1))
2416         {                       /* TA2 - PPS mode */
2417           if ((atr[i] & 0x0f) != 1)
2418             return -2;          /* Wrong card protocol (!= 1).  */
2419
2420           if ((atr[i] & 0x10) != 0x10)
2421             return -3; /* Transmission parameters are implicitly defined. */
2422
2423           negotiable = 0;       /* TA2 means specific mode.  */
2424           NEXTBYTE ();
2425         }
2426
2427       if ((y & 2))
2428         NEXTBYTE ();            /* TB2 - ignore */
2429
2430       if ((y & 4))
2431         NEXTBYTE ();            /* TC2 - ignore */
2432
2433       if ((y & 8))
2434         {
2435           y = (atr[i] >> 4);    /* TD2 */
2436           t = atr[i] & 0x0f;
2437           NEXTBYTE ();
2438         }
2439       else
2440         y = 0;
2441
2442       while (y)
2443         {
2444           if ((y & 1))
2445             {                   /* TAx */
2446               if (t == 1)
2447                 param[5] = atr[i]; /* IFSC */
2448               else if (t == 15)
2449                 /* XXX: check voltage? */
2450                 param[4] = (atr[i] >> 6); /* ClockStop */
2451
2452               NEXTBYTE ();
2453             }
2454
2455           if ((y & 2))
2456             {
2457               if (t == 1)
2458                 param[3] = atr[i]; /* TBx - BWI & CWI */
2459               NEXTBYTE ();
2460             }
2461
2462           if ((y & 4))
2463             {
2464               if (t == 1)
2465                 param[1] |= (atr[i] & 0x01); /* TCx - LRC/CRC */
2466               NEXTBYTE ();
2467
2468               if (param[1] & 0x01)
2469                 return -4;      /* CRC not supported yet.  */
2470             }
2471
2472           if ((y & 8))
2473             {
2474               y = (atr[i] >> 4); /* TDx */
2475               t = atr[i] & 0x0f;
2476               NEXTBYTE ();
2477             }
2478           else
2479             y = 0;
2480         }
2481     }
2482
2483   i += historical_bytes_num - 1;
2484   NEXTBYTE ();
2485   if (atrlen != i+1)
2486     return -1;
2487
2488 #undef NEXTBYTE
2489
2490   chk = 0;
2491   do
2492     {
2493       chk ^= atr[i];
2494       i--;
2495     }
2496   while (i > 0);
2497
2498   if (chk != 0)
2499     return -1;
2500
2501   return negotiable;
2502 }
2503
2504
2505 /* Return the ATR of the card.  This is not a cached value and thus an
2506    actual reset is done.  */
2507 int
2508 ccid_get_atr (ccid_driver_t handle,
2509               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
2510 {
2511   int rc;
2512   int statusbits;
2513   unsigned char msg[100];
2514   unsigned char *tpdu;
2515   size_t msglen, tpdulen;
2516   unsigned char seqno;
2517   int use_crc = 0;
2518   unsigned int edc;
2519   int tried_iso = 0;
2520   int got_param;
2521   unsigned char param[7] = { /* For Protocol T=1 */
2522     0x11, /* bmFindexDindex */
2523     0x10, /* bmTCCKST1 */
2524     0x00, /* bGuardTimeT1 */
2525     0x4d, /* bmWaitingIntegersT1 */
2526     0x00, /* bClockStop */
2527     0x20, /* bIFSC */
2528     0x00  /* bNadValue */
2529   };
2530
2531   /* First check whether a card is available.  */
2532   rc = ccid_slot_status (handle, &statusbits);
2533   if (rc)
2534     return rc;
2535   if (statusbits == 2)
2536     return CCID_DRIVER_ERR_NO_CARD;
2537
2538   /* For an inactive and also for an active card, issue the PowerOn
2539      command to get the ATR.  */
2540  again:
2541   msg[0] = PC_to_RDR_IccPowerOn;
2542   msg[5] = 0; /* slot */
2543   msg[6] = seqno = handle->seqno++;
2544   /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
2545   msg[7] = handle->auto_voltage ? 0 : 1;
2546   msg[8] = 0; /* RFU */
2547   msg[9] = 0; /* RFU */
2548   set_msg_len (msg, 0);
2549   msglen = 10;
2550
2551   rc = bulk_out (handle, msg, msglen, 0);
2552   if (rc)
2553     return rc;
2554   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2555                 seqno, 5000, 0);
2556   if (rc)
2557     return rc;
2558   if (!tried_iso && CCID_COMMAND_FAILED (msg) && CCID_ERROR_CODE (msg) == 0xbb
2559       && ((handle->id_vendor == VENDOR_CHERRY
2560            && handle->id_product == 0x0005)
2561           || (handle->id_vendor == VENDOR_GEMPC
2562               && handle->id_product == 0x4433)
2563           ))
2564     {
2565       tried_iso = 1;
2566       /* Try switching to ISO mode. */
2567       if (!send_escape_cmd (handle, (const unsigned char*)"\xF1\x01", 2,
2568                             NULL, 0, NULL))
2569         goto again;
2570     }
2571   else if (CCID_COMMAND_FAILED (msg))
2572     return CCID_DRIVER_ERR_CARD_IO_ERROR;
2573
2574
2575   handle->powered_off = 0;
2576
2577   if (atr)
2578     {
2579       size_t n = msglen - 10;
2580
2581       if (n > maxatrlen)
2582         n = maxatrlen;
2583       memcpy (atr, msg+10, n);
2584       *atrlen = n;
2585     }
2586
2587   param[6] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2588   rc = update_param_by_atr (param, msg+10, msglen - 10);
2589   if (rc < 0)
2590     {
2591       DEBUGOUT_1 ("update_param_by_atr failed: %d\n", rc);
2592       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2593     }
2594
2595   got_param = 0;
2596
2597   if (handle->auto_param)
2598     {
2599       msg[0] = PC_to_RDR_GetParameters;
2600       msg[5] = 0; /* slot */
2601       msg[6] = seqno = handle->seqno++;
2602       msg[7] = 0; /* RFU */
2603       msg[8] = 0; /* RFU */
2604       msg[9] = 0; /* RFU */
2605       set_msg_len (msg, 0);
2606       msglen = 10;
2607       rc = bulk_out (handle, msg, msglen, 0);
2608       if (!rc)
2609         rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2610                       seqno, 2000, 0);
2611       if (rc)
2612         DEBUGOUT ("GetParameters failed\n");
2613       else if (msglen == 17 && msg[9] == 1)
2614         got_param = 1;
2615     }
2616   else if (handle->auto_pps)
2617     ;
2618   else if (rc == 1)             /* It's negotiable, send PPS.  */
2619     {
2620       msg[0] = PC_to_RDR_XfrBlock;
2621       msg[5] = 0; /* slot */
2622       msg[6] = seqno = handle->seqno++;
2623       msg[7] = 0;
2624       msg[8] = 0;
2625       msg[9] = 0;
2626       msg[10] = 0xff;           /* PPSS */
2627       msg[11] = 0x11;           /* PPS0: PPS1, Protocol T=1 */
2628       msg[12] = param[0];       /* PPS1: Fi / Di */
2629       msg[13] = 0xff ^ 0x11 ^ param[0]; /* PCK */
2630       set_msg_len (msg, 4);
2631       msglen = 10 + 4;
2632
2633       rc = bulk_out (handle, msg, msglen, 0);
2634       if (rc)
2635         return rc;
2636
2637       rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2638                     seqno, 5000, 0);
2639       if (rc)
2640         return rc;
2641
2642       if (msglen != 10 + 4)
2643         {
2644           DEBUGOUT_1 ("Setting PPS failed: %zu\n", msglen);
2645           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2646         }
2647
2648       if (msg[10] != 0xff || msg[11] != 0x11 || msg[12] != param[0])
2649         {
2650           DEBUGOUT_1 ("Setting PPS failed: 0x%02x\n", param[0]);
2651           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2652         }
2653     }
2654
2655   /* Setup parameters to select T=1. */
2656   msg[0] = PC_to_RDR_SetParameters;
2657   msg[5] = 0; /* slot */
2658   msg[6] = seqno = handle->seqno++;
2659   msg[7] = 1; /* Select T=1. */
2660   msg[8] = 0; /* RFU */
2661   msg[9] = 0; /* RFU */
2662
2663   if (!got_param)
2664     memcpy (&msg[10], param, 7);
2665   set_msg_len (msg, 7);
2666   msglen = 10 + 7;
2667
2668   rc = bulk_out (handle, msg, msglen, 0);
2669   if (rc)
2670     return rc;
2671   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2672                 seqno, 5000, 0);
2673   if (rc)
2674     DEBUGOUT ("SetParameters failed (ignored)\n");
2675
2676   if (!rc && msglen > 15 && msg[15] >= 16 && msg[15] <= 254 )
2677     handle->ifsc = msg[15];
2678   else
2679     handle->ifsc = 128; /* Something went wrong, assume 128 bytes.  */
2680
2681   if (handle->nonnull_nad && msglen > 16 && msg[16] == 0)
2682     {
2683       DEBUGOUT ("Use Null-NAD, clearing handle->nonnull_nad.\n");
2684       handle->nonnull_nad = 0;
2685     }
2686
2687   handle->t1_ns = 0;
2688   handle->t1_nr = 0;
2689
2690   /* Send an S-Block with our maximum IFSD to the CCID.  */
2691   if (!handle->apdu_level && !handle->auto_ifsd)
2692     {
2693       tpdu = msg+10;
2694       /* NAD: DAD=1, SAD=0 */
2695       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2696       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
2697       tpdu[2] = 1;
2698       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32;
2699       tpdulen = 4;
2700       edc = compute_edc (tpdu, tpdulen, use_crc);
2701       if (use_crc)
2702         tpdu[tpdulen++] = (edc >> 8);
2703       tpdu[tpdulen++] = edc;
2704
2705       msg[0] = PC_to_RDR_XfrBlock;
2706       msg[5] = 0; /* slot */
2707       msg[6] = seqno = handle->seqno++;
2708       msg[7] = 0;
2709       msg[8] = 0; /* RFU */
2710       msg[9] = 0; /* RFU */
2711       set_msg_len (msg, tpdulen);
2712       msglen = 10 + tpdulen;
2713
2714       if (debug_level > 1)
2715         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
2716                       ((msg[11] & 0xc0) == 0x80)? 'R' :
2717                                 (msg[11] & 0x80)? 'S' : 'I',
2718                       ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2719                                        : !!(msg[11] & 0x40)),
2720                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2721
2722       rc = bulk_out (handle, msg, msglen, 0);
2723       if (rc)
2724         return rc;
2725
2726
2727       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2728                     RDR_to_PC_DataBlock, seqno, 5000, 0);
2729       if (rc)
2730         return rc;
2731
2732       tpdu = msg + 10;
2733       tpdulen = msglen - 10;
2734
2735       if (tpdulen < 4)
2736         return CCID_DRIVER_ERR_ABORTED;
2737
2738       if (debug_level > 1)
2739         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
2740                     ((msg[11] & 0xc0) == 0x80)? 'R' :
2741                               (msg[11] & 0x80)? 'S' : 'I',
2742                     ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2743                                      : !!(msg[11] & 0x40)),
2744                     ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
2745                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2746
2747       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
2748         {
2749           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
2750           return -1;
2751         }
2752       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
2753     }
2754
2755   return 0;
2756 }
2757
2758
2759 \f
2760
2761 static unsigned int
2762 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
2763 {
2764   if (use_crc)
2765     {
2766       return 0x42; /* Not yet implemented. */
2767     }
2768   else
2769     {
2770       unsigned char crc = 0;
2771
2772       for (; datalen; datalen--)
2773         crc ^= *data++;
2774       return crc;
2775     }
2776 }
2777
2778
2779 /* Return true if APDU is an extended length one.  */
2780 static int
2781 is_exlen_apdu (const unsigned char *apdu, size_t apdulen)
2782 {
2783   if (apdulen < 7 || apdu[4])
2784     return 0;  /* Too short or no Z byte.  */
2785   return 1;
2786 }
2787
2788
2789 /* Helper for ccid_transceive used for APDU level exchanges.  */
2790 static int
2791 ccid_transceive_apdu_level (ccid_driver_t handle,
2792                             const unsigned char *apdu_buf, size_t apdu_buflen,
2793                             unsigned char *resp, size_t maxresplen,
2794                             size_t *nresp)
2795 {
2796   int rc;
2797   unsigned char send_buffer[10+261+300], recv_buffer[10+261+300];
2798   const unsigned char *apdu;
2799   size_t apdulen;
2800   unsigned char *msg;
2801   size_t msglen;
2802   unsigned char seqno;
2803   int bwi = 4;
2804
2805   msg = send_buffer;
2806
2807   apdu = apdu_buf;
2808   apdulen = apdu_buflen;
2809   assert (apdulen);
2810
2811   /* The maximum length for a short APDU T=1 block is 261.  For an
2812      extended APDU T=1 block the maximum length 65544; however
2813      extended APDU exchange level is not fully supported yet.  */
2814   if (apdulen > sizeof (send_buffer) - 10)
2815     return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
2816
2817   msg[0] = PC_to_RDR_XfrBlock;
2818   msg[5] = 0; /* slot */
2819   msg[6] = seqno = handle->seqno++;
2820   msg[7] = bwi; /* bBWI */
2821   msg[8] = 0; /* RFU */
2822   msg[9] = 0; /* RFU */
2823   memcpy (msg+10, apdu, apdulen);
2824   set_msg_len (msg, apdulen);
2825   msglen = 10 + apdulen;
2826
2827   rc = bulk_out (handle, msg, msglen, 0);
2828   if (rc)
2829     return rc;
2830
2831   msg = recv_buffer;
2832   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
2833                 RDR_to_PC_DataBlock, seqno, 5000, 0);
2834   if (rc)
2835     return rc;
2836
2837   if (msg[9] == 1)
2838     {
2839       size_t total_msglen = msglen;
2840
2841       while (1)
2842         {
2843           unsigned char status;
2844
2845           msg = recv_buffer + total_msglen;
2846
2847           msg[0] = PC_to_RDR_XfrBlock;
2848           msg[5] = 0; /* slot */
2849           msg[6] = seqno = handle->seqno++;
2850           msg[7] = bwi; /* bBWI */
2851           msg[8] = 0x10;                /* Request next data block */
2852           msg[9] = 0;
2853           set_msg_len (msg, 0);
2854           msglen = 10;
2855
2856           rc = bulk_out (handle, msg, msglen, 0);
2857           if (rc)
2858             return rc;
2859
2860           rc = bulk_in (handle, msg, sizeof recv_buffer - total_msglen, &msglen,
2861                         RDR_to_PC_DataBlock, seqno, 5000, 0);
2862           if (rc)
2863             return rc;
2864           status = msg[9];
2865           memmove (msg, msg+10, msglen - 10);
2866           total_msglen += msglen - 10;
2867           if (total_msglen >= sizeof recv_buffer)
2868             return CCID_DRIVER_ERR_OUT_OF_CORE;
2869
2870           if (status == 0x02)
2871             break;
2872         }
2873
2874       apdu = recv_buffer + 10;
2875       apdulen = total_msglen - 10;
2876     }
2877   else
2878     {
2879       apdu = msg + 10;
2880       apdulen = msglen - 10;
2881     }
2882
2883   if (resp)
2884     {
2885       if (apdulen > maxresplen)
2886         {
2887           DEBUGOUT_2 ("provided buffer too short for received data "
2888                       "(%u/%u)\n",
2889                       (unsigned int)apdulen, (unsigned int)maxresplen);
2890           return CCID_DRIVER_ERR_INV_VALUE;
2891         }
2892
2893       memcpy (resp, apdu, apdulen);
2894       *nresp = apdulen;
2895     }
2896
2897   return 0;
2898 }
2899
2900
2901
2902 /*
2903   Protocol T=1 overview
2904
2905   Block Structure:
2906            Prologue Field:
2907    1 byte     Node Address (NAD)
2908    1 byte     Protocol Control Byte (PCB)
2909    1 byte     Length (LEN)
2910            Information Field:
2911    0-254 byte APDU or Control Information (INF)
2912            Epilogue Field:
2913    1 byte     Error Detection Code (EDC)
2914
2915   NAD:
2916    bit 7     unused
2917    bit 4..6  Destination Node Address (DAD)
2918    bit 3     unused
2919    bit 2..0  Source Node Address (SAD)
2920
2921    If node adresses are not used, SAD and DAD should be set to 0 on
2922    the first block sent to the card.  If they are used they should
2923    have different values (0 for one is okay); that first block sets up
2924    the addresses of the nodes.
2925
2926   PCB:
2927    Information Block (I-Block):
2928       bit 7    0
2929       bit 6    Sequence number (yep, that is modulo 2)
2930       bit 5    Chaining flag
2931       bit 4..0 reserved
2932    Received-Ready Block (R-Block):
2933       bit 7    1
2934       bit 6    0
2935       bit 5    0
2936       bit 4    Sequence number
2937       bit 3..0  0 = no error
2938                 1 = EDC or parity error
2939                 2 = other error
2940                 other values are reserved
2941    Supervisory Block (S-Block):
2942       bit 7    1
2943       bit 6    1
2944       bit 5    clear=request,set=response
2945       bit 4..0  0 = resyncronisation request
2946                 1 = information field size request
2947                 2 = abort request
2948                 3 = extension of BWT request
2949                 4 = VPP error
2950                 other values are reserved
2951
2952 */
2953
2954 int
2955 ccid_transceive (ccid_driver_t handle,
2956                  const unsigned char *apdu_buf, size_t apdu_buflen,
2957                  unsigned char *resp, size_t maxresplen, size_t *nresp)
2958 {
2959   int rc;
2960   /* The size of the buffer used to be 10+259.  For the via_escape
2961      hack we need one extra byte, thus 11+259.  */
2962   unsigned char send_buffer[11+259], recv_buffer[11+259];
2963   const unsigned char *apdu;
2964   size_t apdulen;
2965   unsigned char *msg, *tpdu, *p;
2966   size_t msglen, tpdulen, last_tpdulen, n;
2967   unsigned char seqno;
2968   unsigned int edc;
2969   int use_crc = 0;
2970   int hdrlen, pcboff;
2971   size_t dummy_nresp;
2972   int via_escape = 0;
2973   int next_chunk = 1;
2974   int sending = 1;
2975   int retries = 0;
2976   int resyncing = 0;
2977   int nad_byte;
2978
2979   if (!nresp)
2980     nresp = &dummy_nresp;
2981   *nresp = 0;
2982
2983   /* Smarter readers allow to send APDUs directly; divert here. */
2984   if (handle->apdu_level)
2985     {
2986       /* We employ a hack for Omnikey readers which are able to send
2987          TPDUs using an escape sequence.  There is no documentation
2988          but the Windows driver does it this way.  Tested using a
2989          CM6121.  This method works also for the Cherry XX44
2990          keyboards; however there are problems with the
2991          ccid_tranceive_secure which leads to a loss of sync on the
2992          CCID level.  If Cherry wants to make their keyboard work
2993          again, they should hand over some docs. */
2994       if ((handle->id_vendor == VENDOR_OMNIKEY
2995            || (!handle->idev && handle->id_product == TRANSPORT_CM4040))
2996           && handle->apdu_level < 2
2997           && is_exlen_apdu (apdu_buf, apdu_buflen))
2998         via_escape = 1;
2999       else
3000         return ccid_transceive_apdu_level (handle, apdu_buf, apdu_buflen,
3001                                            resp, maxresplen, nresp);
3002     }
3003
3004   /* The other readers we support require sending TPDUs.  */
3005
3006   tpdulen = 0; /* Avoid compiler warning about no initialization. */
3007   msg = send_buffer;
3008   hdrlen = via_escape? 11 : 10;
3009
3010   /* NAD: DAD=1, SAD=0 */
3011   nad_byte = handle->nonnull_nad? ((1 << 4) | 0): 0;
3012   if (via_escape)
3013     nad_byte = 0;
3014
3015   last_tpdulen = 0;  /* Avoid gcc warning (controlled by RESYNCING). */
3016   for (;;)
3017     {
3018       if (next_chunk)
3019         {
3020           next_chunk = 0;
3021
3022           apdu = apdu_buf;
3023           apdulen = apdu_buflen;
3024           assert (apdulen);
3025
3026           /* Construct an I-Block. */
3027           tpdu = msg + hdrlen;
3028           tpdu[0] = nad_byte;
3029           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
3030           if (apdulen > handle->ifsc )
3031             {
3032               apdulen = handle->ifsc;
3033               apdu_buf += handle->ifsc;
3034               apdu_buflen -= handle->ifsc;
3035               tpdu[1] |= (1 << 5); /* Set more bit. */
3036             }
3037           tpdu[2] = apdulen;
3038           memcpy (tpdu+3, apdu, apdulen);
3039           tpdulen = 3 + apdulen;
3040           edc = compute_edc (tpdu, tpdulen, use_crc);
3041           if (use_crc)
3042             tpdu[tpdulen++] = (edc >> 8);
3043           tpdu[tpdulen++] = edc;
3044         }
3045
3046       if (via_escape)
3047         {
3048           msg[0] = PC_to_RDR_Escape;
3049           msg[5] = 0; /* slot */
3050           msg[6] = seqno = handle->seqno++;
3051           msg[7] = 0; /* RFU */
3052           msg[8] = 0; /* RFU */
3053           msg[9] = 0; /* RFU */
3054           msg[10] = 0x1a; /* Omnikey command to send a TPDU.  */
3055           set_msg_len (msg, 1 + tpdulen);
3056         }
3057       else
3058         {
3059           msg[0] = PC_to_RDR_XfrBlock;
3060           msg[5] = 0; /* slot */
3061           msg[6] = seqno = handle->seqno++;
3062           msg[7] = 4; /* bBWI */
3063           msg[8] = 0; /* RFU */
3064           msg[9] = 0; /* RFU */
3065           set_msg_len (msg, tpdulen);
3066         }
3067       msglen = hdrlen + tpdulen;
3068       if (!resyncing)
3069         last_tpdulen = tpdulen;
3070       pcboff = hdrlen+1;
3071
3072       if (debug_level > 1)
3073         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
3074                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3075                     (msg[pcboff] & 0x80)? 'S' : 'I',
3076                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3077                      : !!(msg[pcboff] & 0x40)),
3078                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3079                      " [more]":""));
3080
3081       rc = bulk_out (handle, msg, msglen, 0);
3082       if (rc)
3083         return rc;
3084
3085       msg = recv_buffer;
3086       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3087                     via_escape? RDR_to_PC_Escape : RDR_to_PC_DataBlock,
3088                     seqno, 5000, 0);
3089       if (rc)
3090         return rc;
3091
3092       tpdu = msg + hdrlen;
3093       tpdulen = msglen - hdrlen;
3094       resyncing = 0;
3095
3096       if (tpdulen < 4)
3097         {
3098           usb_clear_halt (handle->idev, handle->ep_bulk_in);
3099           return CCID_DRIVER_ERR_ABORTED;
3100         }
3101
3102       if (debug_level > 1)
3103         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3104                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3105                               (msg[pcboff] & 0x80)? 'S' : 'I',
3106                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3107                      : !!(msg[pcboff] & 0x40)),
3108                     ((msg[pcboff] & 0xc0) == 0x80)? (msg[pcboff] & 0x0f) : 0,
3109                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3110                      " [more]":""));
3111
3112       if (!(tpdu[1] & 0x80))
3113         { /* This is an I-block. */
3114           retries = 0;
3115           if (sending)
3116             { /* last block sent was successful. */
3117               handle->t1_ns ^= 1;
3118               sending = 0;
3119             }
3120
3121           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3122             { /* Reponse does not match our sequence number. */
3123               msg = send_buffer;
3124               tpdu = msg + hdrlen;
3125               tpdu[0] = nad_byte;
3126               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
3127               tpdu[2] = 0;
3128               tpdulen = 3;
3129               edc = compute_edc (tpdu, tpdulen, use_crc);
3130               if (use_crc)
3131                 tpdu[tpdulen++] = (edc >> 8);
3132               tpdu[tpdulen++] = edc;
3133
3134               continue;
3135             }
3136
3137           handle->t1_nr ^= 1;
3138
3139           p = tpdu + 3; /* Skip the prologue field. */
3140           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3141           /* fixme: verify the checksum. */
3142           if (resp)
3143             {
3144               if (n > maxresplen)
3145                 {
3146                   DEBUGOUT_2 ("provided buffer too short for received data "
3147                               "(%u/%u)\n",
3148                               (unsigned int)n, (unsigned int)maxresplen);
3149                   return CCID_DRIVER_ERR_INV_VALUE;
3150                 }
3151
3152               memcpy (resp, p, n);
3153               resp += n;
3154               *nresp += n;
3155               maxresplen -= n;
3156             }
3157
3158           if (!(tpdu[1] & 0x20))
3159             return 0; /* No chaining requested - ready. */
3160
3161           msg = send_buffer;
3162           tpdu = msg + hdrlen;
3163           tpdu[0] = nad_byte;
3164           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
3165           tpdu[2] = 0;
3166           tpdulen = 3;
3167           edc = compute_edc (tpdu, tpdulen, use_crc);
3168           if (use_crc)
3169             tpdu[tpdulen++] = (edc >> 8);
3170           tpdu[tpdulen++] = edc;
3171         }
3172       else if ((tpdu[1] & 0xc0) == 0x80)
3173         { /* This is a R-block. */
3174           if ( (tpdu[1] & 0x0f))
3175             {
3176               retries++;
3177               if (via_escape && retries == 1 && (msg[pcboff] & 0x0f))
3178                 {
3179                   /* Error probably due to switching to TPDU.  Send a
3180                      resync request.  We use the recv_buffer so that
3181                      we don't corrupt the send_buffer.  */
3182                   msg = recv_buffer;
3183                   tpdu = msg + hdrlen;
3184                   tpdu[0] = nad_byte;
3185                   tpdu[1] = 0xc0; /* S-block resync request. */
3186                   tpdu[2] = 0;
3187                   tpdulen = 3;
3188                   edc = compute_edc (tpdu, tpdulen, use_crc);
3189                   if (use_crc)
3190                     tpdu[tpdulen++] = (edc >> 8);
3191                   tpdu[tpdulen++] = edc;
3192                   resyncing = 1;
3193                   DEBUGOUT ("T=1: requesting resync\n");
3194                 }
3195               else if (retries > 3)
3196                 {
3197                   DEBUGOUT ("T=1: 3 failed retries\n");
3198                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
3199                 }
3200               else
3201                 {
3202                   /* Error: repeat last block */
3203                   msg = send_buffer;
3204                   tpdulen = last_tpdulen;
3205                 }
3206             }
3207           else if (sending && !!(tpdu[1] & 0x10) == handle->t1_ns)
3208             { /* Response does not match our sequence number. */
3209               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
3210               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3211             }
3212           else if (sending)
3213             { /* Send next chunk. */
3214               retries = 0;
3215               msg = send_buffer;
3216               next_chunk = 1;
3217               handle->t1_ns ^= 1;
3218             }
3219           else
3220             {
3221               DEBUGOUT ("unexpected ACK R-block received\n");
3222               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3223             }
3224         }
3225       else
3226         { /* This is a S-block. */
3227           retries = 0;
3228           DEBUGOUT_2 ("T=1: S-block %s received cmd=%d\n",
3229                       (tpdu[1] & 0x20)? "response": "request",
3230                       (tpdu[1] & 0x1f));
3231           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 1 && tpdu[2] == 1)
3232             {
3233               /* Information field size request.  */
3234               unsigned char ifsc = tpdu[3];
3235
3236               if (ifsc < 16 || ifsc > 254)
3237                 return CCID_DRIVER_ERR_CARD_IO_ERROR;
3238
3239               msg = send_buffer;
3240               tpdu = msg + hdrlen;
3241               tpdu[0] = nad_byte;
3242               tpdu[1] = (0xc0 | 0x20 | 1); /* S-block response */
3243               tpdu[2] = 1;
3244               tpdu[3] = ifsc;
3245               tpdulen = 4;
3246               edc = compute_edc (tpdu, tpdulen, use_crc);
3247               if (use_crc)
3248                 tpdu[tpdulen++] = (edc >> 8);
3249               tpdu[tpdulen++] = edc;
3250               DEBUGOUT_1 ("T=1: requesting an ifsc=%d\n", ifsc);
3251             }
3252           else if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
3253             {
3254               /* Wait time extension request. */
3255               unsigned char bwi = tpdu[3];
3256               msg = send_buffer;
3257               tpdu = msg + hdrlen;
3258               tpdu[0] = nad_byte;
3259               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
3260               tpdu[2] = 1;
3261               tpdu[3] = bwi;
3262               tpdulen = 4;
3263               edc = compute_edc (tpdu, tpdulen, use_crc);
3264               if (use_crc)
3265                 tpdu[tpdulen++] = (edc >> 8);
3266               tpdu[tpdulen++] = edc;
3267               DEBUGOUT_1 ("T=1: waittime extension of bwi=%d\n", bwi);
3268               print_progress (handle);
3269             }
3270           else if ( (tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 0 && !tpdu[2])
3271             {
3272               DEBUGOUT ("T=1: resync ack from reader\n");
3273               /* Repeat previous block.  */
3274               msg = send_buffer;
3275               tpdulen = last_tpdulen;
3276             }
3277           else
3278             return CCID_DRIVER_ERR_CARD_IO_ERROR;
3279         }
3280     } /* end T=1 protocol loop. */
3281
3282   return 0;
3283 }
3284
3285
3286 /* Send the CCID Secure command to the reader.  APDU_BUF should
3287    contain the APDU template.  PIN_MODE defines how the pin gets
3288    formatted:
3289
3290      1 := The PIN is ASCII encoded and of variable length.  The
3291           length of the PIN entered will be put into Lc by the reader.
3292           The APDU should me made up of 4 bytes without Lc.
3293
3294    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
3295    may be used t enable reasonable defaults.
3296
3297    When called with RESP and NRESP set to NULL, the function will
3298    merely check whether the reader supports the secure command for the
3299    given APDU and PIN_MODE. */
3300 int
3301 ccid_transceive_secure (ccid_driver_t handle,
3302                         const unsigned char *apdu_buf, size_t apdu_buflen,
3303                         pininfo_t *pininfo,
3304                         unsigned char *resp, size_t maxresplen, size_t *nresp)
3305 {
3306   int rc;
3307   unsigned char send_buffer[10+259], recv_buffer[10+259];
3308   unsigned char *msg, *tpdu, *p;
3309   size_t msglen, tpdulen, n;
3310   unsigned char seqno;
3311   size_t dummy_nresp;
3312   int testmode;
3313   int cherry_mode = 0;
3314   int enable_varlen = 0;
3315
3316   testmode = !resp && !nresp;
3317
3318   if (!nresp)
3319     nresp = &dummy_nresp;
3320   *nresp = 0;
3321
3322   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
3323     ;
3324   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
3325     ;
3326   else
3327     return CCID_DRIVER_ERR_NO_PINPAD;
3328
3329   if (!pininfo->minlen)
3330     pininfo->minlen = 1;
3331   if (!pininfo->maxlen)
3332     pininfo->maxlen = 15;
3333
3334   /* Note that the 25 is the maximum value the SPR532 allows.  */
3335   if (pininfo->minlen < 1 || pininfo->minlen > 25
3336       || pininfo->maxlen < 1 || pininfo->maxlen > 25
3337       || pininfo->minlen > pininfo->maxlen)
3338     return CCID_DRIVER_ERR_INV_VALUE;
3339
3340   /* We have only tested a few readers so better don't risk anything
3341      and do not allow the use with other readers. */
3342   switch (handle->id_vendor)
3343     {
3344     case VENDOR_SCM:  /* Tested with SPR 532. */
3345     case VENDOR_KAAN: /* Tested with KAAN Advanced (1.02). */
3346     case VENDOR_FSIJ: /* Tested with Gnuk (0.21). */
3347       pininfo->maxlen = 25;
3348       enable_varlen = 1;
3349       break;
3350     case VENDOR_VASCO: /* Tested with DIGIPASS 920 */
3351       enable_varlen = 1;
3352       break;
3353     case VENDOR_CHERRY:
3354       pininfo->maxlen = 25;
3355       enable_varlen = 1;
3356       /* The CHERRY XX44 keyboard echos an asterisk for each entered
3357          character on the keyboard channel.  We use a special variant
3358          of PC_to_RDR_Secure which directs these characters to the
3359          smart card's bulk-in channel.  We also need to append a zero
3360          Lc byte to the APDU.  It seems that it will be replaced with
3361          the actual length instead of being appended before the APDU
3362          is send to the card. */
3363       if (handle->id_product != CHERRY_ST2000)
3364         cherry_mode = 1;
3365       break;
3366     default:
3367       if ((handle->id_vendor == VENDOR_GEMPC &&
3368            handle->id_product == GEMPC_PINPAD)
3369           || (handle->id_vendor == VENDOR_VEGA &&
3370               handle->id_product == VEGA_ALPHA))
3371         {
3372           enable_varlen = 0;
3373           pininfo->minlen = 4;
3374           pininfo->maxlen = 8;
3375           break;
3376         }
3377      return CCID_DRIVER_ERR_NOT_SUPPORTED;
3378     }
3379
3380   if (enable_varlen)
3381     pininfo->fixedlen = 0;
3382
3383   if (testmode)
3384     return 0; /* Success */
3385
3386   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
3387     return CCID_DRIVER_ERR_NOT_SUPPORTED;
3388
3389   msg = send_buffer;
3390   if (handle->id_vendor == VENDOR_SCM)
3391     {
3392       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
3393       rc = send_escape_cmd (handle, (const unsigned char*)"\x80\x02\x00", 3,
3394                             NULL, 0, NULL);
3395       if (rc)
3396         return rc;
3397     }
3398
3399   msg[0] = cherry_mode? 0x89 : PC_to_RDR_Secure;
3400   msg[5] = 0; /* slot */
3401   msg[6] = seqno = handle->seqno++;
3402   msg[7] = 0; /* bBWI */
3403   msg[8] = 0; /* RFU */
3404   msg[9] = 0; /* RFU */
3405   msg[10] = apdu_buf[1] == 0x20 ? 0 : 1;
3406                /* Perform PIN verification or PIN modification. */
3407   msg[11] = 0; /* Timeout in seconds. */
3408   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
3409   if (handle->id_vendor == VENDOR_SCM)
3410     {
3411       /* For the SPR532 the next 2 bytes need to be zero.  We do this
3412          for all SCM products.  Kudos to Martin Paljak for this
3413          hint.  */
3414       msg[13] = msg[14] = 0;
3415     }
3416   else
3417     {
3418       msg[13] = pininfo->fixedlen; /* bmPINBlockString:
3419                                       0 bits of pin length to insert.
3420                                       PIN block size by fixedlen.  */
3421       msg[14] = 0x00; /* bmPINLengthFormat:
3422                          Units are bytes, position is 0. */
3423     }
3424
3425   msglen = 15;
3426   if (apdu_buf[1] == 0x24)
3427     {
3428       msg[msglen++] = 0;    /* bInsertionOffsetOld */
3429       msg[msglen++] = pininfo->fixedlen;    /* bInsertionOffsetNew */
3430     }
3431
3432   /* The following is a little endian word. */
3433   msg[msglen++] = pininfo->maxlen;   /* wPINMaxExtraDigit-Maximum.  */
3434   msg[msglen++] = pininfo->minlen;   /* wPINMaxExtraDigit-Minimum.  */
3435
3436   if (apdu_buf[1] == 0x24)
3437     msg[msglen++] = apdu_buf[2] == 0 ? 0x03 : 0x01;
3438               /* bConfirmPIN
3439                *    0x00: new PIN once
3440                *    0x01: new PIN twice (confirmation)
3441                *    0x02: old PIN and new PIN once
3442                *    0x03: old PIN and new PIN twice (confirmation)
3443                */
3444
3445   msg[msglen] = 0x02; /* bEntryValidationCondition:
3446                          Validation key pressed */
3447   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
3448     msg[msglen] |= 0x01; /* Max size reached.  */
3449   msglen++;
3450
3451   if (apdu_buf[1] == 0x20)
3452     msg[msglen++] = 0x01; /* bNumberMessage. */
3453   else
3454     msg[msglen++] = 0x03; /* bNumberMessage. */
3455
3456   msg[msglen++] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
3457   msg[msglen++] = 0x04; /* wLangId-High. */
3458
3459   if (apdu_buf[1] == 0x20)
3460     msg[msglen++] = 0;    /* bMsgIndex. */
3461   else
3462     {
3463       msg[msglen++] = 0;    /* bMsgIndex1. */
3464       msg[msglen++] = 1;    /* bMsgIndex2. */
3465       msg[msglen++] = 2;    /* bMsgIndex3. */
3466     }
3467
3468   /* Calculate Lc.  */
3469   n = pininfo->fixedlen;
3470   if (apdu_buf[1] == 0x24)
3471     n += pininfo->fixedlen;
3472
3473   /* bTeoProlog follows: */
3474   msg[msglen++] = handle->nonnull_nad? ((1 << 4) | 0): 0;
3475   msg[msglen++] = ((handle->t1_ns & 1) << 6); /* I-block */
3476   if (n)
3477     msg[msglen++] = n + 5; /* apdulen should be filled for fixed length.  */
3478   else
3479     msg[msglen++] = 0; /* The apdulen will be filled in by the reader.  */
3480   /* APDU follows:  */
3481   msg[msglen++] = apdu_buf[0]; /* CLA */
3482   msg[msglen++] = apdu_buf[1]; /* INS */
3483   msg[msglen++] = apdu_buf[2]; /* P1 */
3484   msg[msglen++] = apdu_buf[3]; /* P2 */
3485   if (cherry_mode)
3486     msg[msglen++] = 0;
3487   else if (pininfo->fixedlen != 0)
3488     {
3489       msg[msglen++] = n;
3490       memset (&msg[msglen], 0xff, n);
3491       msglen += n;
3492     }
3493   /* An EDC is not required. */
3494   set_msg_len (msg, msglen - 10);
3495
3496   rc = bulk_out (handle, msg, msglen, 0);
3497   if (rc)
3498     return rc;
3499
3500   msg = recv_buffer;
3501   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3502                 RDR_to_PC_DataBlock, seqno, 30000, 0);
3503   if (rc)
3504     return rc;
3505
3506   tpdu = msg + 10;
3507   tpdulen = msglen - 10;
3508
3509   if (handle->apdu_level)
3510     {
3511       if (resp)
3512         {
3513           if (tpdulen > maxresplen)
3514             {
3515               DEBUGOUT_2 ("provided buffer too short for received data "
3516                           "(%u/%u)\n",
3517                           (unsigned int)tpdulen, (unsigned int)maxresplen);
3518               return CCID_DRIVER_ERR_INV_VALUE;
3519             }
3520
3521           memcpy (resp, tpdu, tpdulen);
3522           *nresp = tpdulen;
3523         }
3524       return 0;
3525     }
3526
3527   if (tpdulen < 4)
3528     {
3529       usb_clear_halt (handle->idev, handle->ep_bulk_in);
3530       return CCID_DRIVER_ERR_ABORTED;
3531     }
3532   if (debug_level > 1)
3533     DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3534                 ((msg[11] & 0xc0) == 0x80)? 'R' :
3535                           (msg[11] & 0x80)? 'S' : 'I',
3536                 ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
3537                 ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
3538                 (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
3539
3540   if (!(tpdu[1] & 0x80))
3541     { /* This is an I-block. */
3542       /* Last block sent was successful. */
3543       handle->t1_ns ^= 1;
3544
3545       if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3546         { /* Reponse does not match our sequence number. */
3547           DEBUGOUT ("I-block with wrong seqno received\n");
3548           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3549         }
3550
3551       handle->t1_nr ^= 1;
3552
3553       p = tpdu + 3; /* Skip the prologue field. */
3554       n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3555       /* fixme: verify the checksum. */
3556       if (resp)
3557         {
3558           if (n > maxresplen)
3559             {
3560               DEBUGOUT_2 ("provided buffer too short for received data "
3561                           "(%u/%u)\n",
3562                           (unsigned int)n, (unsigned int)maxresplen);
3563               return CCID_DRIVER_ERR_INV_VALUE;
3564             }
3565
3566           memcpy (resp, p, n);
3567           resp += n;
3568           *nresp += n;
3569           maxresplen -= n;
3570         }
3571
3572       if (!(tpdu[1] & 0x20))
3573         return 0; /* No chaining requested - ready. */
3574
3575       DEBUGOUT ("chaining requested but not supported for Secure operation\n");
3576       return CCID_DRIVER_ERR_CARD_IO_ERROR;
3577     }
3578   else if ((tpdu[1] & 0xc0) == 0x80)
3579     { /* This is a R-block. */
3580       if ( (tpdu[1] & 0x0f))
3581         { /* Error: repeat last block */
3582           DEBUGOUT ("No retries supported for Secure operation\n");
3583           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3584         }
3585       else if (!!(tpdu[1] & 0x10) == handle->t1_ns)
3586         { /* Reponse does not match our sequence number. */
3587           DEBUGOUT ("R-block with wrong seqno received on more bit\n");
3588           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3589         }
3590       else
3591         { /* Send next chunk. */
3592           DEBUGOUT ("chaining not supported on Secure operation\n");
3593           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3594         }
3595     }
3596   else
3597     { /* This is a S-block. */
3598       DEBUGOUT_2 ("T=1: S-block %s received cmd=%d for Secure operation\n",
3599                   (tpdu[1] & 0x20)? "response": "request",
3600                   (tpdu[1] & 0x1f));
3601       return CCID_DRIVER_ERR_CARD_IO_ERROR;
3602     }
3603
3604   return 0;
3605 }
3606
3607
3608
3609
3610 #ifdef TEST
3611
3612
3613 static void
3614 print_error (int err)
3615 {
3616   const char *p;
3617   char buf[50];
3618
3619   switch (err)
3620     {
3621     case 0: p = "success";
3622     case CCID_DRIVER_ERR_OUT_OF_CORE: p = "out of core"; break;
3623     case CCID_DRIVER_ERR_INV_VALUE: p = "invalid value"; break;
3624     case CCID_DRIVER_ERR_NO_DRIVER: p = "no driver"; break;
3625     case CCID_DRIVER_ERR_NOT_SUPPORTED: p = "not supported"; break;
3626     case CCID_DRIVER_ERR_LOCKING_FAILED: p = "locking failed"; break;
3627     case CCID_DRIVER_ERR_BUSY: p = "busy"; break;
3628     case CCID_DRIVER_ERR_NO_CARD: p = "no card"; break;
3629     case CCID_DRIVER_ERR_CARD_INACTIVE: p = "card inactive"; break;
3630     case CCID_DRIVER_ERR_CARD_IO_ERROR: p = "card I/O error"; break;
3631     case CCID_DRIVER_ERR_GENERAL_ERROR: p = "general error"; break;
3632     case CCID_DRIVER_ERR_NO_READER: p = "no reader"; break;
3633     case CCID_DRIVER_ERR_ABORTED: p = "aborted"; break;
3634     default: sprintf (buf, "0x%05x", err); p = buf; break;
3635     }
3636   fprintf (stderr, "operation failed: %s\n", p);
3637 }
3638
3639
3640 static void
3641 print_data (const unsigned char *data, size_t length)
3642 {
3643   if (length >= 2)
3644     {
3645       fprintf (stderr, "operation status: %02X%02X\n",
3646                data[length-2], data[length-1]);
3647       length -= 2;
3648     }
3649   if (length)
3650     {
3651         fputs ("   returned data:", stderr);
3652         for (; length; length--, data++)
3653           fprintf (stderr, " %02X", *data);
3654         putc ('\n', stderr);
3655     }
3656 }
3657
3658 static void
3659 print_result (int rc, const unsigned char *data, size_t length)
3660 {
3661   if (rc)
3662     print_error (rc);
3663   else if (data)
3664     print_data (data, length);
3665 }
3666
3667 int
3668 main (int argc, char **argv)
3669 {
3670   int rc;
3671   ccid_driver_t ccid;
3672   int slotstat;
3673   unsigned char result[512];
3674   size_t resultlen;
3675   int no_pinpad = 0;
3676   int verify_123456 = 0;
3677   int did_verify = 0;
3678   int no_poll = 0;
3679
3680   if (argc)
3681     {
3682       argc--;
3683       argv++;
3684     }
3685
3686   while (argc)
3687     {
3688       if ( !strcmp (*argv, "--list"))
3689         {
3690           char *p;
3691           p = ccid_get_reader_list ();
3692           if (!p)
3693             return 1;
3694           fputs (p, stderr);
3695           free (p);
3696           return 0;
3697         }
3698       else if ( !strcmp (*argv, "--debug"))
3699         {
3700           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
3701           argc--; argv++;
3702         }
3703       else if ( !strcmp (*argv, "--no-poll"))
3704         {
3705           no_poll = 1;
3706           argc--; argv++;
3707         }
3708       else if ( !strcmp (*argv, "--no-pinpad"))
3709         {
3710           no_pinpad = 1;
3711           argc--; argv++;
3712         }
3713       else if ( !strcmp (*argv, "--verify-123456"))
3714         {
3715           verify_123456 = 1;
3716           argc--; argv++;
3717         }
3718       else
3719         break;
3720     }
3721
3722   rc = ccid_open_reader (&ccid, argc? *argv:NULL);
3723   if (rc)
3724     return 1;
3725
3726   if (!no_poll)
3727     ccid_poll (ccid);
3728   fputs ("getting ATR ...\n", stderr);
3729   rc = ccid_get_atr (ccid, NULL, 0, NULL);
3730   if (rc)
3731     {
3732       print_error (rc);
3733       return 1;
3734     }
3735
3736   if (!no_poll)
3737     ccid_poll (ccid);
3738   fputs ("getting slot status ...\n", stderr);
3739   rc = ccid_slot_status (ccid, &slotstat);
3740   if (rc)
3741     {
3742       print_error (rc);
3743       return 1;
3744     }
3745
3746   if (!no_poll)
3747     ccid_poll (ccid);
3748
3749   fputs ("selecting application OpenPGP ....\n", stderr);
3750   {
3751     static unsigned char apdu[] = {
3752       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
3753     rc = ccid_transceive (ccid,
3754                           apdu, sizeof apdu,
3755                           result, sizeof result, &resultlen);
3756     print_result (rc, result, resultlen);
3757   }
3758
3759
3760   if (!no_poll)
3761     ccid_poll (ccid);
3762
3763   fputs ("getting OpenPGP DO 0x65 ....\n", stderr);
3764   {
3765     static unsigned char apdu[] = { 0, 0xCA, 0, 0x65, 254 };
3766     rc = ccid_transceive (ccid, apdu, sizeof apdu,
3767                           result, sizeof result, &resultlen);
3768     print_result (rc, result, resultlen);
3769   }
3770
3771   if (!no_pinpad)
3772     {
3773     }
3774
3775   if (!no_pinpad)
3776     {
3777       static unsigned char apdu[] = { 0, 0x20, 0, 0x81 };
3778
3779
3780       if (ccid_transceive_secure (ccid,
3781                                   apdu, sizeof apdu,
3782                                   1, 0, 0, 0,
3783                                   NULL, 0, NULL))
3784         fputs ("can't verify using a PIN-Pad reader\n", stderr);
3785       else
3786         {
3787           fputs ("verifying CHV1 using the PINPad ....\n", stderr);
3788
3789           rc = ccid_transceive_secure (ccid,
3790                                        apdu, sizeof apdu,
3791                                        1, 0, 0, 0,
3792                                        result, sizeof result, &resultlen);
3793           print_result (rc, result, resultlen);
3794           did_verify = 1;
3795         }
3796     }
3797
3798   if (verify_123456 && !did_verify)
3799     {
3800       fputs ("verifying that CHV1 is 123456....\n", stderr);
3801       {
3802         static unsigned char apdu[] = {0, 0x20, 0, 0x81,
3803                                        6, '1','2','3','4','5','6'};
3804         rc = ccid_transceive (ccid, apdu, sizeof apdu,
3805                               result, sizeof result, &resultlen);
3806         print_result (rc, result, resultlen);
3807       }
3808     }
3809
3810   if (!rc)
3811     {
3812       fputs ("getting OpenPGP DO 0x5E ....\n", stderr);
3813       {
3814         static unsigned char apdu[] = { 0, 0xCA, 0, 0x5E, 254 };
3815         rc = ccid_transceive (ccid, apdu, sizeof apdu,
3816                               result, sizeof result, &resultlen);
3817         print_result (rc, result, resultlen);
3818       }
3819     }
3820
3821   ccid_close_reader (ccid);
3822
3823   return 0;
3824 }
3825
3826 /*
3827  * Local Variables:
3828  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
3829  * End:
3830  */
3831 #endif /*TEST*/
3832 #endif /*HAVE_LIBUSB*/