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