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