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