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