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