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