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