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