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