tools: Fix error handling for gpg-pair-tool.
[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_SCD_MAIN_HEADER is defined.  */
117 #if defined(GNUPG_SCD_MAIN_HEADER)
118 # include GNUPG_SCD_MAIN_HEADER
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                                 (char*)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                                 (char*)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           scd_kick_the_loop ();
1480         }
1481       else
1482         {
1483           /* Event other than card removal.  */
1484           goto submit_again;
1485         }
1486     }
1487   else if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
1488     handle->powered_off = 1;
1489   else
1490     {
1491     device_removed:
1492       DEBUGOUT ("CCID: device removed\n");
1493       handle->powered_off = 1;
1494       scd_kick_the_loop ();
1495     }
1496 }
1497
1498 static void
1499 ccid_setup_intr  (ccid_driver_t handle)
1500 {
1501   struct libusb_transfer *transfer;
1502   int err;
1503
1504   transfer = libusb_alloc_transfer (0);
1505   handle->transfer = transfer;
1506   libusb_fill_interrupt_transfer (transfer, handle->idev, handle->ep_intr,
1507                                   handle->intr_buf, sizeof (handle->intr_buf),
1508                                   intr_cb, handle, 0);
1509   err = libusb_submit_transfer (transfer);
1510   DEBUGOUT_2 ("CCID submit transfer (%x): %d", handle->ep_intr, err);
1511 }
1512
1513
1514 static void *
1515 ccid_usb_thread (void *arg)
1516 {
1517   libusb_context *ctx = arg;
1518
1519   while (ccid_usb_thread_is_alive)
1520     {
1521 #ifdef USE_NPTH
1522       npth_unprotect ();
1523 #endif
1524       libusb_handle_events_completed (ctx, NULL);
1525 #ifdef USE_NPTH
1526       npth_protect ();
1527 #endif
1528     }
1529
1530   return NULL;
1531 }
1532
1533
1534 static int
1535 ccid_open_usb_reader (const char *spec_reader_name,
1536                       int idx, struct ccid_dev_table *ccid_table,
1537                       ccid_driver_t *handle, char **rdrname_p)
1538 {
1539   libusb_device *dev;
1540   libusb_device_handle *idev = NULL;
1541   char *rid = NULL;
1542   int rc = 0;
1543   int ifc_no, set_no;
1544   struct libusb_device_descriptor desc;
1545   int n;
1546   int bus, addr;
1547   unsigned int bai;
1548
1549   n = ccid_table[idx].n;
1550   ifc_no = ccid_table[idx].interface_number;
1551   set_no = ccid_table[idx].setting_number;
1552
1553   dev = ccid_usb_dev_list[n];
1554   bus = libusb_get_bus_number (dev);
1555   addr = libusb_get_device_address (dev);
1556   bai = (bus << 16) | (addr << 8) | ifc_no;
1557
1558   rc = libusb_open (dev, &idev);
1559   if (rc)
1560     {
1561       DEBUGOUT_1 ("usb_open failed: %s\n", libusb_error_name (rc));
1562       free (*handle);
1563       *handle = NULL;
1564       return rc;
1565     }
1566
1567   if (ccid_usb_thread_is_alive++ == 0)
1568     {
1569       npth_t thread;
1570       npth_attr_t tattr;
1571       int err;
1572
1573       err = npth_attr_init (&tattr);
1574       if (err)
1575         {
1576           DEBUGOUT_1 ("npth_attr_init failed: %s\n", strerror (err));
1577           free (*handle);
1578           *handle = NULL;
1579           return err;
1580         }
1581
1582       npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1583       err = npth_create (&thread, &tattr, ccid_usb_thread, NULL);
1584       if (err)
1585         {
1586           DEBUGOUT_1 ("npth_create failed: %s\n", strerror (err));
1587           free (*handle);
1588           *handle = NULL;
1589           return err;
1590         }
1591
1592       npth_attr_destroy (&tattr);
1593     }
1594
1595   rc = libusb_get_device_descriptor (dev, &desc);
1596   if (rc)
1597     {
1598       DEBUGOUT ("get_device_descripor failed\n");
1599       goto leave;
1600     }
1601
1602   rid = make_reader_id (idev, desc.idVendor, desc.idProduct,
1603                         desc.iSerialNumber);
1604
1605   /* Check to see if reader name matches the spec.  */
1606   if (spec_reader_name
1607       && strncmp (rid, spec_reader_name, strlen (spec_reader_name)))
1608     {
1609       DEBUGOUT ("device not matched\n");
1610       rc = CCID_DRIVER_ERR_NO_READER;
1611       goto leave;
1612     }
1613
1614   (*handle)->id_vendor = desc.idVendor;
1615   (*handle)->id_product = desc.idProduct;
1616   (*handle)->idev = idev;
1617   (*handle)->bai = bai;
1618   (*handle)->ifc_no = ifc_no;
1619   (*handle)->ep_bulk_out = ccid_table[idx].ep_bulk_out;
1620   (*handle)->ep_bulk_in = ccid_table[idx].ep_bulk_in;
1621   (*handle)->ep_intr = ccid_table[idx].ep_intr;
1622
1623   DEBUGOUT_2 ("using CCID reader %d (ID=%s)\n", idx, rid);
1624
1625   if (parse_ccid_descriptor (*handle, desc.bcdDevice,
1626                              ccid_table[idx].ifcdesc_extra,
1627                              ccid_table[idx].ifcdesc_extra_len))
1628     {
1629       DEBUGOUT ("device not supported\n");
1630       rc = CCID_DRIVER_ERR_NO_READER;
1631       goto leave;
1632     }
1633
1634   rc = libusb_claim_interface (idev, ifc_no);
1635   if (rc)
1636     {
1637       DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
1638       rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1639       goto leave;
1640     }
1641
1642   /* Submit SET_INTERFACE control transfer which can reset the device.  */
1643   rc = libusb_set_interface_alt_setting (idev, ifc_no, set_no);
1644   if (rc)
1645     {
1646       DEBUGOUT_1 ("usb_set_interface_alt_setting failed: %d\n", rc);
1647       rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1648       goto leave;
1649     }
1650
1651   rc = ccid_vendor_specific_init (*handle);
1652
1653  leave:
1654   if (rc)
1655     {
1656       --ccid_usb_thread_is_alive;
1657       free (rid);
1658       libusb_close (idev);
1659       free (*handle);
1660       *handle = NULL;
1661     }
1662   else
1663     {
1664       if (rdrname_p)
1665         *rdrname_p = rid;
1666       else
1667         free (rid);
1668     }
1669
1670   return rc;
1671 }
1672
1673 /* Open the reader with the internal number READERNO and return a
1674    pointer to be used as handle in HANDLE.  Returns 0 on success. */
1675 int
1676 ccid_open_reader (const char *spec_reader_name, int idx,
1677                   struct ccid_dev_table *ccid_table,
1678                   ccid_driver_t *handle, char **rdrname_p)
1679 {
1680   *handle = calloc (1, sizeof **handle);
1681   if (!*handle)
1682     {
1683       DEBUGOUT ("out of memory\n");
1684       return CCID_DRIVER_ERR_OUT_OF_CORE;
1685     }
1686
1687   return ccid_open_usb_reader (spec_reader_name, idx, ccid_table,
1688                                handle, rdrname_p);
1689 }
1690
1691
1692 int
1693 ccid_require_get_status (ccid_driver_t handle)
1694 {
1695   /* When a card reader supports interrupt transfer to check the
1696      status of card, it is possible to submit only an interrupt
1697      transfer, and no check is required by application layer.  USB can
1698      detect removal of a card and can detect removal of a reader.
1699   */
1700   if (handle->ep_intr >= 0)
1701     return 0;
1702
1703   /* Libusb actually detects the removal of USB device in use.
1704      However, there is no good API to handle the removal (yet),
1705      cleanly and with good portability.
1706
1707      There is libusb_set_pollfd_notifiers function, but it doesn't
1708      offer libusb_device_handle* data to its callback.  So, when it
1709      watches multiple devices, there is no way to know which device is
1710      removed.
1711
1712      Once, we will have a good programming interface of libusb, we can
1713      list tokens (with no interrupt transfer support, but always with
1714      card inserted) here to return 0, so that scdaemon can submit
1715      minimum packet on wire.
1716   */
1717   return 1;
1718 }
1719
1720
1721 static void
1722 do_close_reader (ccid_driver_t handle)
1723 {
1724   int rc;
1725   unsigned char msg[100];
1726   size_t msglen;
1727   unsigned char seqno;
1728
1729   if (!handle->powered_off)
1730     {
1731       msg[0] = PC_to_RDR_IccPowerOff;
1732       msg[5] = 0; /* slot */
1733       msg[6] = seqno = handle->seqno++;
1734       msg[7] = 0; /* RFU */
1735       msg[8] = 0; /* RFU */
1736       msg[9] = 0; /* RFU */
1737       set_msg_len (msg, 0);
1738       msglen = 10;
1739
1740       rc = bulk_out (handle, msg, msglen, 0);
1741       if (!rc)
1742         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
1743                  seqno, 2000, 0);
1744     }
1745
1746   if (handle->transfer)
1747     {
1748       if (!handle->powered_off)
1749         {
1750           DEBUGOUT ("libusb_cancel_transfer\n");
1751
1752           rc = libusb_cancel_transfer (handle->transfer);
1753           if (rc != LIBUSB_ERROR_NOT_FOUND)
1754             while (!handle->powered_off)
1755               {
1756                 DEBUGOUT ("libusb_handle_events_completed\n");
1757 #ifdef USE_NPTH
1758                 npth_unprotect ();
1759 #endif
1760                 libusb_handle_events_completed (NULL, &handle->powered_off);
1761 #ifdef USE_NPTH
1762                 npth_protect ();
1763 #endif
1764               }
1765         }
1766
1767       libusb_free_transfer (handle->transfer);
1768       handle->transfer = NULL;
1769     }
1770   libusb_release_interface (handle->idev, handle->ifc_no);
1771   --ccid_usb_thread_is_alive;
1772   libusb_close (handle->idev);
1773   handle->idev = NULL;
1774 }
1775
1776
1777 int
1778 ccid_set_progress_cb (ccid_driver_t handle,
1779                       void (*cb)(void *, const char *, int, int, int),
1780                       void *cb_arg)
1781 {
1782   if (!handle)
1783     return CCID_DRIVER_ERR_INV_VALUE;
1784
1785   handle->progress_cb = cb;
1786   handle->progress_cb_arg = cb_arg;
1787   return 0;
1788 }
1789
1790
1791 int
1792 ccid_set_prompt_cb (ccid_driver_t handle,
1793                     void (*cb)(void *, int), void *cb_arg)
1794 {
1795   if (!handle)
1796     return CCID_DRIVER_ERR_INV_VALUE;
1797
1798   handle->prompt_cb = cb;
1799   handle->prompt_cb_arg = cb_arg;
1800   return 0;
1801 }
1802
1803
1804 /* Close the reader HANDLE. */
1805 int
1806 ccid_close_reader (ccid_driver_t handle)
1807 {
1808   if (!handle)
1809     return 0;
1810
1811   do_close_reader (handle);
1812   free (handle);
1813   return 0;
1814 }
1815
1816
1817 /* Return False if a card is present and powered. */
1818 int
1819 ccid_check_card_presence (ccid_driver_t handle)
1820 {
1821   (void)handle;  /* Not yet implemented.  */
1822   return -1;
1823 }
1824
1825
1826 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
1827    Returns 0 on success. */
1828 static int
1829 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen,
1830           int no_debug)
1831 {
1832   int rc;
1833   int transferred;
1834
1835   /* No need to continue and clutter the log with USB write error
1836      messages after we got the first ENODEV.  */
1837   if (handle->enodev_seen)
1838     return CCID_DRIVER_ERR_NO_READER;
1839
1840   if (debug_level && (!no_debug || debug_level >= 3))
1841     {
1842       switch (msglen? msg[0]:0)
1843         {
1844         case PC_to_RDR_IccPowerOn:
1845           print_p2r_iccpoweron (msg, msglen);
1846           break;
1847         case PC_to_RDR_IccPowerOff:
1848           print_p2r_iccpoweroff (msg, msglen);
1849           break;
1850         case PC_to_RDR_GetSlotStatus:
1851           print_p2r_getslotstatus (msg, msglen);
1852           break;
1853         case PC_to_RDR_XfrBlock:
1854           print_p2r_xfrblock (msg, msglen);
1855           break;
1856         case PC_to_RDR_GetParameters:
1857           print_p2r_getparameters (msg, msglen);
1858           break;
1859         case PC_to_RDR_ResetParameters:
1860           print_p2r_resetparameters (msg, msglen);
1861           break;
1862         case PC_to_RDR_SetParameters:
1863           print_p2r_setparameters (msg, msglen);
1864           break;
1865         case PC_to_RDR_Escape:
1866           print_p2r_escape (msg, msglen);
1867           break;
1868         case PC_to_RDR_IccClock:
1869           print_p2r_iccclock (msg, msglen);
1870           break;
1871         case PC_to_RDR_T0APDU:
1872           print_p2r_to0apdu (msg, msglen);
1873           break;
1874         case PC_to_RDR_Secure:
1875           print_p2r_secure (msg, msglen);
1876           break;
1877         case PC_to_RDR_Mechanical:
1878           print_p2r_mechanical (msg, msglen);
1879           break;
1880         case PC_to_RDR_Abort:
1881           print_p2r_abort (msg, msglen);
1882           break;
1883         case PC_to_RDR_SetDataRate:
1884           print_p2r_setdatarate (msg, msglen);
1885           break;
1886         default:
1887           print_p2r_unknown (msg, msglen);
1888           break;
1889         }
1890     }
1891
1892 #ifdef USE_NPTH
1893   npth_unprotect ();
1894 #endif
1895   rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
1896                              (char*)msg, msglen, &transferred,
1897                              5000 /* ms timeout */);
1898 #ifdef USE_NPTH
1899   npth_protect ();
1900 #endif
1901   if (rc == 0 && transferred == msglen)
1902     return 0;
1903
1904   if (rc)
1905     {
1906       DEBUGOUT_1 ("usb_bulk_write error: %s\n", libusb_error_name (rc));
1907       if (rc == LIBUSB_ERROR_NO_DEVICE)
1908         {
1909           handle->enodev_seen = 1;
1910           return CCID_DRIVER_ERR_NO_READER;
1911         }
1912     }
1913
1914   return 0;
1915 }
1916
1917
1918 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
1919    BUFFER and return the actual read number if bytes in NREAD. SEQNO
1920    is the sequence number used to send the request and EXPECTED_TYPE
1921    the type of message we expect. Does checks on the ccid
1922    header. TIMEOUT is the timeout value in ms. NO_DEBUG may be set to
1923    avoid debug messages in case of no error; this can be overridden
1924    with a glibal debug level of at least 3. Returns 0 on success. */
1925 static int
1926 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
1927          size_t *nread, int expected_type, int seqno, int timeout,
1928          int no_debug)
1929 {
1930   int rc;
1931   int msglen;
1932   int notified = 0;
1933
1934   /* Fixme: The next line for the current Valgrind without support
1935      for USB IOCTLs. */
1936   memset (buffer, 0, length);
1937  retry:
1938
1939 #ifdef USE_NPTH
1940   npth_unprotect ();
1941 #endif
1942   rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
1943                              (char*)buffer, length, &msglen, timeout);
1944 #ifdef USE_NPTH
1945   npth_protect ();
1946 #endif
1947   if (rc)
1948     {
1949       DEBUGOUT_1 ("usb_bulk_read error: %s\n", libusb_error_name (rc));
1950       if (rc == LIBUSB_ERROR_NO_DEVICE)
1951         {
1952           handle->enodev_seen = 1;
1953           return CCID_DRIVER_ERR_NO_READER;
1954         }
1955
1956       return CCID_DRIVER_ERR_CARD_IO_ERROR;
1957     }
1958   if (msglen < 0)
1959     return CCID_DRIVER_ERR_INV_VALUE;  /* Faulty libusb.  */
1960   *nread = msglen;
1961
1962   if (msglen < 10)
1963     {
1964       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
1965       abort_cmd (handle, seqno);
1966       return CCID_DRIVER_ERR_INV_VALUE;
1967     }
1968   if (buffer[5] != 0)
1969     {
1970       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
1971       return CCID_DRIVER_ERR_INV_VALUE;
1972     }
1973   if (buffer[6] != seqno)
1974     {
1975       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
1976                   seqno, buffer[6]);
1977       /* Retry until we are synced again.  */
1978       goto retry;
1979     }
1980
1981   /* We need to handle the time extension request before we check that
1982      we got the expected message type.  This is in particular required
1983      for the Cherry keyboard which sends a time extension request for
1984      each key hit.  */
1985   if (!(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
1986     {
1987       /* Card present and active, time extension requested. */
1988       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
1989                   buffer[7], buffer[8]);
1990
1991       /* Gnuk enhancement to prompt user input by ack button */
1992       if (buffer[8] == 0xff && !notified)
1993         {
1994           notified = 1;
1995           handle->prompt_cb (handle->prompt_cb_arg, 1);
1996         }
1997
1998       goto retry;
1999     }
2000
2001   if (notified)
2002     handle->prompt_cb (handle->prompt_cb_arg, 0);
2003
2004   if (buffer[0] != expected_type && buffer[0] != RDR_to_PC_SlotStatus)
2005     {
2006       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
2007       abort_cmd (handle, seqno);
2008       return CCID_DRIVER_ERR_INV_VALUE;
2009     }
2010
2011   if (debug_level && (!no_debug || debug_level >= 3))
2012     {
2013       switch (buffer[0])
2014         {
2015         case RDR_to_PC_DataBlock:
2016           print_r2p_datablock (buffer, msglen);
2017           break;
2018         case RDR_to_PC_SlotStatus:
2019           print_r2p_slotstatus (buffer, msglen);
2020           break;
2021         case RDR_to_PC_Parameters:
2022           print_r2p_parameters (buffer, msglen);
2023           break;
2024         case RDR_to_PC_Escape:
2025           print_r2p_escape (buffer, msglen);
2026           break;
2027         case RDR_to_PC_DataRate:
2028           print_r2p_datarate (buffer, msglen);
2029           break;
2030         default:
2031           print_r2p_unknown (buffer, msglen);
2032           break;
2033         }
2034     }
2035   if (CCID_COMMAND_FAILED (buffer))
2036     print_command_failed (buffer);
2037
2038   /* Check whether a card is at all available.  Note: If you add new
2039      error codes here, check whether they need to be ignored in
2040      send_escape_cmd. */
2041   switch ((buffer[7] & 0x03))
2042     {
2043     case 0: /* no error */ break;
2044     case 1: rc = CCID_DRIVER_ERR_CARD_INACTIVE; break;
2045     case 2: rc = CCID_DRIVER_ERR_NO_CARD; break;
2046     case 3: /* RFU */ break;
2047     }
2048
2049   if (rc)
2050     {
2051       /*
2052        * Communication failure by device side.
2053        * Possibly, it was forcibly suspended and resumed.
2054        *
2055        * Only detect this kind of failure when interrupt transfer is
2056        * not supported.  For card reader with interrupt transfer
2057        * support removal is detected by intr_cb.
2058        */
2059       if (handle->ep_intr < 0)
2060         {
2061           DEBUGOUT ("CCID: card inactive/removed\n");
2062           handle->powered_off = 1;
2063           scd_kick_the_loop ();
2064         }
2065     }
2066
2067   return rc;
2068 }
2069
2070
2071
2072 /* Send an abort sequence and wait until everything settled.  */
2073 static int
2074 abort_cmd (ccid_driver_t handle, int seqno)
2075 {
2076   int rc;
2077   char dummybuf[8];
2078   unsigned char msg[100];
2079   int msglen;
2080
2081   seqno &= 0xff;
2082   DEBUGOUT_1 ("sending abort sequence for seqno %d\n", seqno);
2083   /* Send the abort command to the control pipe.  Note that we don't
2084      need to keep track of sent abort commands because there should
2085      never be another thread using the same slot concurrently.  */
2086 #ifdef USE_NPTH
2087   npth_unprotect ();
2088 #endif
2089   rc = libusb_control_transfer (handle->idev,
2090                                 0x21,/* bmRequestType: host-to-device,
2091                                         class specific, to interface.  */
2092                                 1,   /* ABORT */
2093                                 (seqno << 8 | 0 /* slot */),
2094                                 handle->ifc_no,
2095                                 dummybuf, 0,
2096                                 1000 /* ms timeout */);
2097 #ifdef USE_NPTH
2098   npth_protect ();
2099 #endif
2100   if (rc)
2101     {
2102       DEBUGOUT_1 ("usb_control_msg error: %s\n", libusb_error_name (rc));
2103       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2104     }
2105
2106   /* Now send the abort command to the bulk out pipe using the same
2107      SEQNO and SLOT.  Do this in a loop to so that all seqno are
2108      tried.  */
2109   seqno--;  /* Adjust for next increment.  */
2110   do
2111     {
2112       int transferred;
2113
2114       seqno++;
2115       msg[0] = PC_to_RDR_Abort;
2116       msg[5] = 0; /* slot */
2117       msg[6] = seqno;
2118       msg[7] = 0; /* RFU */
2119       msg[8] = 0; /* RFU */
2120       msg[9] = 0; /* RFU */
2121       msglen = 10;
2122       set_msg_len (msg, 0);
2123
2124 #ifdef USE_NPTH
2125       npth_unprotect ();
2126 #endif
2127       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
2128                                  (char*)msg, msglen, &transferred,
2129                                  5000 /* ms timeout */);
2130 #ifdef USE_NPTH
2131       npth_protect ();
2132 #endif
2133       if (rc == 0 && transferred == msglen)
2134         rc = 0;
2135       else if (rc)
2136         DEBUGOUT_1 ("usb_bulk_write error in abort_cmd: %s\n",
2137                     libusb_error_name (rc));
2138
2139       if (rc)
2140         return rc;
2141
2142 #ifdef USE_NPTH
2143       npth_unprotect ();
2144 #endif
2145       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
2146                                  (char*)msg, sizeof msg, &msglen,
2147                                  5000 /*ms timeout*/);
2148 #ifdef USE_NPTH
2149       npth_protect ();
2150 #endif
2151       if (rc)
2152         {
2153           DEBUGOUT_1 ("usb_bulk_read error in abort_cmd: %s\n",
2154                       libusb_error_name (rc));
2155           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2156         }
2157
2158       if (msglen < 10)
2159         {
2160           DEBUGOUT_1 ("bulk-in msg in abort_cmd too short (%u)\n",
2161                       (unsigned int)msglen);
2162           return CCID_DRIVER_ERR_INV_VALUE;
2163         }
2164       if (msg[5] != 0)
2165         {
2166           DEBUGOUT_1 ("unexpected bulk-in slot (%d) in abort_cmd\n", msg[5]);
2167           return CCID_DRIVER_ERR_INV_VALUE;
2168         }
2169
2170       DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n",
2171                   msg[7], msg[8], msg[9]);
2172       if (CCID_COMMAND_FAILED (msg))
2173         print_command_failed (msg);
2174     }
2175   while (msg[0] != RDR_to_PC_SlotStatus && msg[5] != 0 && msg[6] != seqno);
2176
2177   handle->seqno = ((seqno + 1) & 0xff);
2178   DEBUGOUT ("sending abort sequence succeeded\n");
2179
2180   return 0;
2181 }
2182
2183
2184 /* Note that this function won't return the error codes NO_CARD or
2185    CARD_INACTIVE.  IF RESULT is not NULL, the result from the
2186    operation will get returned in RESULT and its length in RESULTLEN.
2187    If the response is larger than RESULTMAX, an error is returned and
2188    the required buffer length returned in RESULTLEN.  */
2189 static int
2190 send_escape_cmd (ccid_driver_t handle,
2191                  const unsigned char *data, size_t datalen,
2192                  unsigned char *result, size_t resultmax, size_t *resultlen)
2193 {
2194   int rc;
2195   unsigned char msg[100];
2196   size_t msglen;
2197   unsigned char seqno;
2198
2199   if (resultlen)
2200     *resultlen = 0;
2201
2202   if (datalen > sizeof msg - 10)
2203     return CCID_DRIVER_ERR_INV_VALUE; /* Escape data too large.  */
2204
2205   msg[0] = PC_to_RDR_Escape;
2206   msg[5] = 0; /* slot */
2207   msg[6] = seqno = handle->seqno++;
2208   msg[7] = 0; /* RFU */
2209   msg[8] = 0; /* RFU */
2210   msg[9] = 0; /* RFU */
2211   memcpy (msg+10, data, datalen);
2212   msglen = 10 + datalen;
2213   set_msg_len (msg, datalen);
2214
2215   rc = bulk_out (handle, msg, msglen, 0);
2216   if (rc)
2217     return rc;
2218   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Escape,
2219                 seqno, 5000, 0);
2220   if (result)
2221     switch (rc)
2222       {
2223         /* We need to ignore certain errorcode here. */
2224       case 0:
2225       case CCID_DRIVER_ERR_CARD_INACTIVE:
2226       case CCID_DRIVER_ERR_NO_CARD:
2227         {
2228           if (msglen > resultmax)
2229             rc = CCID_DRIVER_ERR_INV_VALUE; /* Response too large. */
2230           else
2231             {
2232               memcpy (result, msg, msglen);
2233               if (resultlen)
2234                 *resultlen = msglen;
2235               rc = 0;
2236             }
2237         }
2238         break;
2239       default:
2240         break;
2241       }
2242
2243   return rc;
2244 }
2245
2246
2247 int
2248 ccid_transceive_escape (ccid_driver_t handle,
2249                         const unsigned char *data, size_t datalen,
2250                         unsigned char *resp, size_t maxresplen, size_t *nresp)
2251 {
2252   return send_escape_cmd (handle, data, datalen, resp, maxresplen, nresp);
2253 }
2254
2255
2256
2257 /* experimental */
2258 int
2259 ccid_poll (ccid_driver_t handle)
2260 {
2261   int rc;
2262   unsigned char msg[10];
2263   int msglen;
2264   int i, j;
2265
2266   rc = libusb_interrupt_transfer (handle->idev, handle->ep_intr,
2267                                   (char*)msg, sizeof msg, &msglen,
2268                                   0 /* ms timeout */ );
2269   if (rc == LIBUSB_ERROR_TIMEOUT)
2270     return 0;
2271
2272   if (rc)
2273     {
2274       DEBUGOUT_1 ("usb_intr_read error: %s\n", libusb_error_name (rc));
2275       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2276     }
2277
2278   if (msglen < 1)
2279     {
2280       DEBUGOUT ("intr-in msg too short\n");
2281       return CCID_DRIVER_ERR_INV_VALUE;
2282     }
2283
2284   if (msg[0] == RDR_to_PC_NotifySlotChange)
2285     {
2286       DEBUGOUT ("notify slot change:");
2287       for (i=1; i < msglen; i++)
2288         for (j=0; j < 4; j++)
2289           DEBUGOUT_CONT_3 (" %d:%c%c",
2290                            (i-1)*4+j,
2291                            (msg[i] & (1<<(j*2)))? 'p':'-',
2292                            (msg[i] & (2<<(j*2)))? '*':' ');
2293       DEBUGOUT_LF ();
2294     }
2295   else if (msg[0] == RDR_to_PC_HardwareError)
2296     {
2297       DEBUGOUT ("hardware error occurred\n");
2298     }
2299   else
2300     {
2301       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
2302     }
2303
2304   return 0;
2305 }
2306
2307
2308 /* Note that this function won't return the error codes NO_CARD or
2309    CARD_INACTIVE */
2310 int
2311 ccid_slot_status (ccid_driver_t handle, int *statusbits, int on_wire)
2312 {
2313   int rc;
2314   unsigned char msg[100];
2315   size_t msglen;
2316   unsigned char seqno;
2317   int retries = 0;
2318
2319   if (handle->powered_off)
2320     return CCID_DRIVER_ERR_NO_READER;
2321
2322   /* If the card (with its lower-level driver) doesn't require
2323      GET_STATUS on wire (because it supports INTERRUPT transfer for
2324      status change, or it's a token which has a card always inserted),
2325      no need to send on wire.  */
2326   if (!on_wire && !ccid_require_get_status (handle))
2327     {
2328       /* Setup interrupt transfer at the initial call of slot_status
2329          with ON_WIRE == 0 */
2330       if (handle->transfer == NULL && handle->ep_intr >= 0)
2331         ccid_setup_intr (handle);
2332
2333       *statusbits = 0;
2334       return 0;
2335     }
2336
2337  retry:
2338   msg[0] = PC_to_RDR_GetSlotStatus;
2339   msg[5] = 0; /* slot */
2340   msg[6] = seqno = handle->seqno++;
2341   msg[7] = 0; /* RFU */
2342   msg[8] = 0; /* RFU */
2343   msg[9] = 0; /* RFU */
2344   set_msg_len (msg, 0);
2345
2346   rc = bulk_out (handle, msg, 10, 1);
2347   if (rc)
2348     return rc;
2349   /* Note that we set the NO_DEBUG flag here, so that the logs won't
2350      get cluttered up by a ticker function checking for the slot
2351      status and debugging enabled. */
2352   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
2353                 seqno, retries? 1000 : 200, 1);
2354   if (rc == CCID_DRIVER_ERR_CARD_IO_ERROR && retries < 3)
2355     {
2356       if (!retries)
2357         {
2358           DEBUGOUT ("USB: CALLING USB_CLEAR_HALT\n");
2359 #ifdef USE_NPTH
2360           npth_unprotect ();
2361 #endif
2362           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
2363           libusb_clear_halt (handle->idev, handle->ep_bulk_out);
2364 #ifdef USE_NPTH
2365           npth_protect ();
2366 #endif
2367         }
2368       else
2369           DEBUGOUT ("USB: RETRYING bulk_in AGAIN\n");
2370       retries++;
2371       goto retry;
2372     }
2373   if (rc && rc != CCID_DRIVER_ERR_NO_CARD && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
2374     return rc;
2375   *statusbits = (msg[7] & 3);
2376
2377   return 0;
2378 }
2379
2380
2381 /* Parse ATR string (of ATRLEN) and update parameters at PARAM.
2382    Calling this routine, it should prepare default values at PARAM
2383    beforehand.  This routine assumes that card is accessed by T=1
2384    protocol.  It doesn't analyze historical bytes at all.
2385
2386    Returns < 0 value on error:
2387      -1 for parse error or integrity check error
2388      -2 for card doesn't support T=1 protocol
2389      -3 for parameters are nod explicitly defined by ATR
2390      -4 for this driver doesn't support CRC
2391
2392    Returns >= 0 on success:
2393       0 for card is negotiable mode
2394       1 for card is specific mode (and not negotiable)
2395  */
2396 static int
2397 update_param_by_atr (unsigned char *param, unsigned char *atr, size_t atrlen)
2398 {
2399   int i = -1;
2400   int t, y, chk;
2401   int historical_bytes_num, negotiable = 1;
2402
2403 #define NEXTBYTE() do { i++; if (atrlen <= i) return -1; } while (0)
2404
2405   NEXTBYTE ();
2406
2407   if (atr[i] == 0x3F)
2408     param[1] |= 0x02;           /* Convention is inverse.  */
2409   NEXTBYTE ();
2410
2411   y = (atr[i] >> 4);
2412   historical_bytes_num = atr[i] & 0x0f;
2413   NEXTBYTE ();
2414
2415   if ((y & 1))
2416     {
2417       param[0] = atr[i];        /* TA1 - Fi & Di */
2418       NEXTBYTE ();
2419     }
2420
2421   if ((y & 2))
2422     NEXTBYTE ();                /* TB1 - ignore */
2423
2424   if ((y & 4))
2425     {
2426       param[2] = atr[i];        /* TC1 - Guard Time */
2427       NEXTBYTE ();
2428     }
2429
2430   if ((y & 8))
2431     {
2432       y = (atr[i] >> 4);        /* TD1 */
2433       t = atr[i] & 0x0f;
2434       NEXTBYTE ();
2435
2436       if ((y & 1))
2437         {                       /* TA2 - PPS mode */
2438           if ((atr[i] & 0x0f) != 1)
2439             return -2;          /* Wrong card protocol (!= 1).  */
2440
2441           if ((atr[i] & 0x10) != 0x10)
2442             return -3; /* Transmission parameters are implicitly defined. */
2443
2444           negotiable = 0;       /* TA2 means specific mode.  */
2445           NEXTBYTE ();
2446         }
2447
2448       if ((y & 2))
2449         NEXTBYTE ();            /* TB2 - ignore */
2450
2451       if ((y & 4))
2452         NEXTBYTE ();            /* TC2 - ignore */
2453
2454       if ((y & 8))
2455         {
2456           y = (atr[i] >> 4);    /* TD2 */
2457           t = atr[i] & 0x0f;
2458           NEXTBYTE ();
2459         }
2460       else
2461         y = 0;
2462
2463       while (y)
2464         {
2465           if ((y & 1))
2466             {                   /* TAx */
2467               if (t == 1)
2468                 param[5] = atr[i]; /* IFSC */
2469               else if (t == 15)
2470                 /* XXX: check voltage? */
2471                 param[4] = (atr[i] >> 6); /* ClockStop */
2472
2473               NEXTBYTE ();
2474             }
2475
2476           if ((y & 2))
2477             {
2478               if (t == 1)
2479                 param[3] = atr[i]; /* TBx - BWI & CWI */
2480               NEXTBYTE ();
2481             }
2482
2483           if ((y & 4))
2484             {
2485               if (t == 1)
2486                 param[1] |= (atr[i] & 0x01); /* TCx - LRC/CRC */
2487               NEXTBYTE ();
2488
2489               if (param[1] & 0x01)
2490                 return -4;      /* CRC not supported yet.  */
2491             }
2492
2493           if ((y & 8))
2494             {
2495               y = (atr[i] >> 4); /* TDx */
2496               t = atr[i] & 0x0f;
2497               NEXTBYTE ();
2498             }
2499           else
2500             y = 0;
2501         }
2502     }
2503
2504   i += historical_bytes_num - 1;
2505   NEXTBYTE ();
2506   if (atrlen != i+1)
2507     return -1;
2508
2509 #undef NEXTBYTE
2510
2511   chk = 0;
2512   do
2513     {
2514       chk ^= atr[i];
2515       i--;
2516     }
2517   while (i > 0);
2518
2519   if (chk != 0)
2520     return -1;
2521
2522   return negotiable;
2523 }
2524
2525
2526 /* Return the ATR of the card.  This is not a cached value and thus an
2527    actual reset is done.  */
2528 int
2529 ccid_get_atr (ccid_driver_t handle,
2530               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
2531 {
2532   int rc;
2533   int statusbits;
2534   unsigned char msg[100];
2535   unsigned char *tpdu;
2536   size_t msglen, tpdulen;
2537   unsigned char seqno;
2538   int use_crc = 0;
2539   unsigned int edc;
2540   int tried_iso = 0;
2541   int got_param;
2542   unsigned char param[7] = { /* For Protocol T=1 */
2543     0x11, /* bmFindexDindex */
2544     0x10, /* bmTCCKST1 */
2545     0x00, /* bGuardTimeT1 */
2546     0x4d, /* bmWaitingIntegersT1 */
2547     0x00, /* bClockStop */
2548     0x20, /* bIFSC */
2549     0x00  /* bNadValue */
2550   };
2551
2552   /* First check whether a card is available.  */
2553   rc = ccid_slot_status (handle, &statusbits, 1);
2554   if (rc)
2555     return rc;
2556   if (statusbits == 2)
2557     return CCID_DRIVER_ERR_NO_CARD;
2558
2559   /*
2560    * In the first invocation of ccid_slot_status, card reader may
2561    * return CCID_DRIVER_ERR_CARD_INACTIVE and handle->powered_off may
2562    * become 1.  Because inactive card is no problem (we are turning it
2563    * ON here), clear the flag.
2564    */
2565   handle->powered_off = 0;
2566
2567   /* For an inactive and also for an active card, issue the PowerOn
2568      command to get the ATR.  */
2569  again:
2570   msg[0] = PC_to_RDR_IccPowerOn;
2571   msg[5] = 0; /* slot */
2572   msg[6] = seqno = handle->seqno++;
2573   /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
2574   msg[7] = handle->auto_voltage ? 0 : 1;
2575   msg[8] = 0; /* RFU */
2576   msg[9] = 0; /* RFU */
2577   set_msg_len (msg, 0);
2578   msglen = 10;
2579
2580   rc = bulk_out (handle, msg, msglen, 0);
2581   if (rc)
2582     return rc;
2583   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2584                 seqno, 5000, 0);
2585   if (rc)
2586     return rc;
2587   if (!tried_iso && CCID_COMMAND_FAILED (msg) && CCID_ERROR_CODE (msg) == 0xbb
2588       && ((handle->id_vendor == VENDOR_CHERRY
2589            && handle->id_product == 0x0005)
2590           || (handle->id_vendor == VENDOR_GEMPC
2591               && handle->id_product == 0x4433)
2592           ))
2593     {
2594       tried_iso = 1;
2595       /* Try switching to ISO mode. */
2596       if (!send_escape_cmd (handle, (const unsigned char*)"\xF1\x01", 2,
2597                             NULL, 0, NULL))
2598         goto again;
2599     }
2600   else if (CCID_COMMAND_FAILED (msg))
2601     return CCID_DRIVER_ERR_CARD_IO_ERROR;
2602
2603
2604   handle->powered_off = 0;
2605
2606   if (atr)
2607     {
2608       size_t n = msglen - 10;
2609
2610       if (n > maxatrlen)
2611         n = maxatrlen;
2612       memcpy (atr, msg+10, n);
2613       *atrlen = n;
2614     }
2615
2616   param[6] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2617   rc = update_param_by_atr (param, msg+10, msglen - 10);
2618   if (rc < 0)
2619     {
2620       DEBUGOUT_1 ("update_param_by_atr failed: %d\n", rc);
2621       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2622     }
2623
2624   got_param = 0;
2625
2626   if (handle->auto_param)
2627     {
2628       msg[0] = PC_to_RDR_GetParameters;
2629       msg[5] = 0; /* slot */
2630       msg[6] = seqno = handle->seqno++;
2631       msg[7] = 0; /* RFU */
2632       msg[8] = 0; /* RFU */
2633       msg[9] = 0; /* RFU */
2634       set_msg_len (msg, 0);
2635       msglen = 10;
2636       rc = bulk_out (handle, msg, msglen, 0);
2637       if (!rc)
2638         rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2639                       seqno, 2000, 0);
2640       if (rc)
2641         DEBUGOUT ("GetParameters failed\n");
2642       else if (msglen == 17 && msg[9] == 1)
2643         got_param = 1;
2644     }
2645   else if (handle->auto_pps)
2646     ;
2647   else if (rc == 1)             /* It's negotiable, send PPS.  */
2648     {
2649       msg[0] = PC_to_RDR_XfrBlock;
2650       msg[5] = 0; /* slot */
2651       msg[6] = seqno = handle->seqno++;
2652       msg[7] = 0;
2653       msg[8] = 0;
2654       msg[9] = 0;
2655       msg[10] = 0xff;           /* PPSS */
2656       msg[11] = 0x11;           /* PPS0: PPS1, Protocol T=1 */
2657       msg[12] = param[0];       /* PPS1: Fi / Di */
2658       msg[13] = 0xff ^ 0x11 ^ param[0]; /* PCK */
2659       set_msg_len (msg, 4);
2660       msglen = 10 + 4;
2661
2662       rc = bulk_out (handle, msg, msglen, 0);
2663       if (rc)
2664         return rc;
2665
2666       rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
2667                     seqno, 5000, 0);
2668       if (rc)
2669         return rc;
2670
2671       if (msglen != 10 + 4)
2672         {
2673           DEBUGOUT_1 ("Setting PPS failed: %zu\n", msglen);
2674           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2675         }
2676
2677       if (msg[10] != 0xff || msg[11] != 0x11 || msg[12] != param[0])
2678         {
2679           DEBUGOUT_1 ("Setting PPS failed: 0x%02x\n", param[0]);
2680           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2681         }
2682     }
2683
2684   /* Setup parameters to select T=1. */
2685   msg[0] = PC_to_RDR_SetParameters;
2686   msg[5] = 0; /* slot */
2687   msg[6] = seqno = handle->seqno++;
2688   msg[7] = 1; /* Select T=1. */
2689   msg[8] = 0; /* RFU */
2690   msg[9] = 0; /* RFU */
2691
2692   if (!got_param)
2693     memcpy (&msg[10], param, 7);
2694   set_msg_len (msg, 7);
2695   msglen = 10 + 7;
2696
2697   rc = bulk_out (handle, msg, msglen, 0);
2698   if (rc)
2699     return rc;
2700   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
2701                 seqno, 5000, 0);
2702   if (rc)
2703     DEBUGOUT ("SetParameters failed (ignored)\n");
2704
2705   if (!rc && msglen > 15 && msg[15] >= 16 && msg[15] <= 254 )
2706     handle->ifsc = msg[15];
2707   else
2708     handle->ifsc = 128; /* Something went wrong, assume 128 bytes.  */
2709
2710   if (handle->nonnull_nad && msglen > 16 && msg[16] == 0)
2711     {
2712       DEBUGOUT ("Use Null-NAD, clearing handle->nonnull_nad.\n");
2713       handle->nonnull_nad = 0;
2714     }
2715
2716   handle->t1_ns = 0;
2717   handle->t1_nr = 0;
2718
2719   /* Send an S-Block with our maximum IFSD to the CCID.  */
2720   if (!handle->apdu_level && !handle->auto_ifsd)
2721     {
2722       tpdu = msg+10;
2723       /* NAD: DAD=1, SAD=0 */
2724       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2725       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
2726       tpdu[2] = 1;
2727       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32;
2728       tpdulen = 4;
2729       edc = compute_edc (tpdu, tpdulen, use_crc);
2730       if (use_crc)
2731         tpdu[tpdulen++] = (edc >> 8);
2732       tpdu[tpdulen++] = edc;
2733
2734       msg[0] = PC_to_RDR_XfrBlock;
2735       msg[5] = 0; /* slot */
2736       msg[6] = seqno = handle->seqno++;
2737       msg[7] = 0;
2738       msg[8] = 0; /* RFU */
2739       msg[9] = 0; /* RFU */
2740       set_msg_len (msg, tpdulen);
2741       msglen = 10 + tpdulen;
2742
2743       if (debug_level > 1)
2744         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
2745                       ((msg[11] & 0xc0) == 0x80)? 'R' :
2746                                 (msg[11] & 0x80)? 'S' : 'I',
2747                       ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2748                                        : !!(msg[11] & 0x40)),
2749                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2750
2751       rc = bulk_out (handle, msg, msglen, 0);
2752       if (rc)
2753         return rc;
2754
2755
2756       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2757                     RDR_to_PC_DataBlock, seqno, 5000, 0);
2758       if (rc)
2759         return rc;
2760
2761       tpdu = msg + 10;
2762       tpdulen = msglen - 10;
2763
2764       if (tpdulen < 4)
2765         return CCID_DRIVER_ERR_ABORTED;
2766
2767       if (debug_level > 1)
2768         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
2769                     ((msg[11] & 0xc0) == 0x80)? 'R' :
2770                               (msg[11] & 0x80)? 'S' : 'I',
2771                     ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2772                                      : !!(msg[11] & 0x40)),
2773                     ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
2774                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2775
2776       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
2777         {
2778           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
2779           return -1;
2780         }
2781       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
2782     }
2783
2784   return 0;
2785 }
2786
2787
2788 \f
2789
2790 static unsigned int
2791 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
2792 {
2793   if (use_crc)
2794     {
2795       return 0x42; /* Not yet implemented. */
2796     }
2797   else
2798     {
2799       unsigned char crc = 0;
2800
2801       for (; datalen; datalen--)
2802         crc ^= *data++;
2803       return crc;
2804     }
2805 }
2806
2807
2808 /* Return true if APDU is an extended length one.  */
2809 static int
2810 is_exlen_apdu (const unsigned char *apdu, size_t apdulen)
2811 {
2812   if (apdulen < 7 || apdu[4])
2813     return 0;  /* Too short or no Z byte.  */
2814   return 1;
2815 }
2816
2817
2818 /* Helper for ccid_transceive used for APDU level exchanges.  */
2819 static int
2820 ccid_transceive_apdu_level (ccid_driver_t handle,
2821                             const unsigned char *apdu_buf, size_t apdu_len,
2822                             unsigned char *resp, size_t maxresplen,
2823                             size_t *nresp)
2824 {
2825   int rc;
2826   unsigned char msg[CCID_MAX_BUF];
2827   const unsigned char *apdu_p;
2828   size_t apdu_part_len;
2829   size_t msglen;
2830   unsigned char seqno;
2831   int bwi = 4;
2832   unsigned char chain = 0;
2833
2834   if (apdu_len == 0 || apdu_len > sizeof (msg) - 10)
2835     return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
2836
2837   apdu_p = apdu_buf;
2838   while (1)
2839     {
2840       apdu_part_len = apdu_len;
2841       if (apdu_part_len > handle->max_ccid_msglen - 10)
2842         {
2843           apdu_part_len = handle->max_ccid_msglen - 10;
2844           chain |= 0x01;
2845         }
2846
2847       msg[0] = PC_to_RDR_XfrBlock;
2848       msg[5] = 0; /* slot */
2849       msg[6] = seqno = handle->seqno++;
2850       msg[7] = bwi;
2851       msg[8] = chain;
2852       msg[9] = 0;
2853       memcpy (msg+10, apdu_p, apdu_part_len);
2854       set_msg_len (msg, apdu_part_len);
2855       msglen = 10 + apdu_part_len;
2856
2857       rc = bulk_out (handle, msg, msglen, 0);
2858       if (rc)
2859         return rc;
2860
2861       apdu_p += apdu_part_len;
2862       apdu_len -= apdu_part_len;
2863
2864       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2865                     RDR_to_PC_DataBlock, seqno, CCID_CMD_TIMEOUT, 0);
2866       if (rc)
2867         return rc;
2868
2869       if (!(chain & 0x01))
2870         break;
2871
2872       chain = 0x02;
2873     }
2874
2875   apdu_len = 0;
2876   while (1)
2877     {
2878       apdu_part_len = msglen - 10;
2879       if (resp && apdu_len + apdu_part_len <= maxresplen)
2880         memcpy (resp + apdu_len, msg+10, apdu_part_len);
2881       apdu_len += apdu_part_len;
2882
2883       if (!(msg[9] & 0x01))
2884         break;
2885
2886       msg[0] = PC_to_RDR_XfrBlock;
2887       msg[5] = 0; /* slot */
2888       msg[6] = seqno = handle->seqno++;
2889       msg[7] = bwi;
2890       msg[8] = 0x10;                /* Request next data block */
2891       msg[9] = 0;
2892       set_msg_len (msg, 0);
2893       msglen = 10;
2894
2895       rc = bulk_out (handle, msg, msglen, 0);
2896       if (rc)
2897         return rc;
2898
2899       rc = bulk_in (handle, msg, sizeof msg, &msglen,
2900                     RDR_to_PC_DataBlock, seqno, CCID_CMD_TIMEOUT, 0);
2901       if (rc)
2902         return rc;
2903     }
2904
2905   if (resp)
2906     {
2907       if (apdu_len > maxresplen)
2908         {
2909           DEBUGOUT_2 ("provided buffer too short for received data "
2910                       "(%u/%u)\n",
2911                       (unsigned int)apdu_len, (unsigned int)maxresplen);
2912           return CCID_DRIVER_ERR_INV_VALUE;
2913         }
2914
2915       *nresp = apdu_len;
2916     }
2917
2918   return 0;
2919 }
2920
2921
2922
2923 /*
2924   Protocol T=1 overview
2925
2926   Block Structure:
2927            Prologue Field:
2928    1 byte     Node Address (NAD)
2929    1 byte     Protocol Control Byte (PCB)
2930    1 byte     Length (LEN)
2931            Information Field:
2932    0-254 byte APDU or Control Information (INF)
2933            Epilogue Field:
2934    1 byte     Error Detection Code (EDC)
2935
2936   NAD:
2937    bit 7     unused
2938    bit 4..6  Destination Node Address (DAD)
2939    bit 3     unused
2940    bit 2..0  Source Node Address (SAD)
2941
2942    If node addresses are not used, SAD and DAD should be set to 0 on
2943    the first block sent to the card.  If they are used they should
2944    have different values (0 for one is okay); that first block sets up
2945    the addresses of the nodes.
2946
2947   PCB:
2948    Information Block (I-Block):
2949       bit 7    0
2950       bit 6    Sequence number (yep, that is modulo 2)
2951       bit 5    Chaining flag
2952       bit 4..0 reserved
2953    Received-Ready Block (R-Block):
2954       bit 7    1
2955       bit 6    0
2956       bit 5    0
2957       bit 4    Sequence number
2958       bit 3..0  0 = no error
2959                 1 = EDC or parity error
2960                 2 = other error
2961                 other values are reserved
2962    Supervisory Block (S-Block):
2963       bit 7    1
2964       bit 6    1
2965       bit 5    clear=request,set=response
2966       bit 4..0  0 = resyncronisation request
2967                 1 = information field size request
2968                 2 = abort request
2969                 3 = extension of BWT request
2970                 4 = VPP error
2971                 other values are reserved
2972
2973 */
2974
2975 int
2976 ccid_transceive (ccid_driver_t handle,
2977                  const unsigned char *apdu_buf, size_t apdu_buflen,
2978                  unsigned char *resp, size_t maxresplen, size_t *nresp)
2979 {
2980   int rc;
2981   /* The size of the buffer used to be 10+259.  For the via_escape
2982      hack we need one extra byte, thus 11+259.  */
2983   unsigned char send_buffer[11+259], recv_buffer[11+259];
2984   const unsigned char *apdu;
2985   size_t apdulen;
2986   unsigned char *msg, *tpdu, *p;
2987   size_t msglen, tpdulen, last_tpdulen, n;
2988   unsigned char seqno;
2989   unsigned int edc;
2990   int use_crc = 0;
2991   int hdrlen, pcboff;
2992   size_t dummy_nresp;
2993   int via_escape = 0;
2994   int next_chunk = 1;
2995   int sending = 1;
2996   int retries = 0;
2997   int resyncing = 0;
2998   int nad_byte;
2999   int wait_more = 0;
3000
3001   if (!nresp)
3002     nresp = &dummy_nresp;
3003   *nresp = 0;
3004
3005   /* Smarter readers allow sending APDUs directly; divert here. */
3006   if (handle->apdu_level)
3007     {
3008       /* We employ a hack for Omnikey readers which are able to send
3009          TPDUs using an escape sequence.  There is no documentation
3010          but the Windows driver does it this way.  Tested using a
3011          CM6121.  This method works also for the Cherry XX44
3012          keyboards; however there are problems with the
3013          ccid_transceive_secure which leads to a loss of sync on the
3014          CCID level.  If Cherry wants to make their keyboard work
3015          again, they should hand over some docs. */
3016       if ((handle->id_vendor == VENDOR_OMNIKEY)
3017           && handle->apdu_level < 2
3018           && is_exlen_apdu (apdu_buf, apdu_buflen))
3019         via_escape = 1;
3020       else
3021         return ccid_transceive_apdu_level (handle, apdu_buf, apdu_buflen,
3022                                            resp, maxresplen, nresp);
3023     }
3024
3025   /* The other readers we support require sending TPDUs.  */
3026
3027   tpdulen = 0; /* Avoid compiler warning about no initialization. */
3028   msg = send_buffer;
3029   hdrlen = via_escape? 11 : 10;
3030
3031   /* NAD: DAD=1, SAD=0 */
3032   nad_byte = handle->nonnull_nad? ((1 << 4) | 0): 0;
3033   if (via_escape)
3034     nad_byte = 0;
3035
3036   last_tpdulen = 0;  /* Avoid gcc warning (controlled by RESYNCING). */
3037   for (;;)
3038     {
3039       if (next_chunk)
3040         {
3041           next_chunk = 0;
3042
3043           apdu = apdu_buf;
3044           apdulen = apdu_buflen;
3045           assert (apdulen);
3046
3047           /* Construct an I-Block. */
3048           tpdu = msg + hdrlen;
3049           tpdu[0] = nad_byte;
3050           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
3051           if (apdulen > handle->ifsc )
3052             {
3053               apdulen = handle->ifsc;
3054               apdu_buf += handle->ifsc;
3055               apdu_buflen -= handle->ifsc;
3056               tpdu[1] |= (1 << 5); /* Set more bit. */
3057             }
3058           tpdu[2] = apdulen;
3059           memcpy (tpdu+3, apdu, apdulen);
3060           tpdulen = 3 + apdulen;
3061           edc = compute_edc (tpdu, tpdulen, use_crc);
3062           if (use_crc)
3063             tpdu[tpdulen++] = (edc >> 8);
3064           tpdu[tpdulen++] = edc;
3065         }
3066
3067       if (via_escape)
3068         {
3069           msg[0] = PC_to_RDR_Escape;
3070           msg[5] = 0; /* slot */
3071           msg[6] = seqno = handle->seqno++;
3072           msg[7] = 0; /* RFU */
3073           msg[8] = 0; /* RFU */
3074           msg[9] = 0; /* RFU */
3075           msg[10] = 0x1a; /* Omnikey command to send a TPDU.  */
3076           set_msg_len (msg, 1 + tpdulen);
3077         }
3078       else
3079         {
3080           msg[0] = PC_to_RDR_XfrBlock;
3081           msg[5] = 0; /* slot */
3082           msg[6] = seqno = handle->seqno++;
3083           msg[7] = (wait_more ? wait_more : 1); /* bBWI */
3084           msg[8] = 0; /* RFU */
3085           msg[9] = 0; /* RFU */
3086           set_msg_len (msg, tpdulen);
3087         }
3088       msglen = hdrlen + tpdulen;
3089       if (!resyncing)
3090         last_tpdulen = tpdulen;
3091       pcboff = hdrlen+1;
3092
3093       if (debug_level > 1)
3094         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
3095                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3096                     (msg[pcboff] & 0x80)? 'S' : 'I',
3097                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3098                      : !!(msg[pcboff] & 0x40)),
3099                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3100                      " [more]":""));
3101
3102       rc = bulk_out (handle, msg, msglen, 0);
3103       if (rc)
3104         return rc;
3105
3106       msg = recv_buffer;
3107       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3108                     via_escape? RDR_to_PC_Escape : RDR_to_PC_DataBlock, seqno,
3109                     (wait_more ? wait_more : 1) * CCID_CMD_TIMEOUT, 0);
3110       if (rc)
3111         return rc;
3112
3113       tpdu = msg + hdrlen;
3114       tpdulen = msglen - hdrlen;
3115       resyncing = 0;
3116
3117       if (tpdulen < 4)
3118         {
3119 #ifdef USE_NPTH
3120           npth_unprotect ();
3121 #endif
3122           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
3123 #ifdef USE_NPTH
3124           npth_protect ();
3125 #endif
3126           return CCID_DRIVER_ERR_ABORTED;
3127         }
3128
3129       if (debug_level > 1)
3130         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3131                     ((msg[pcboff] & 0xc0) == 0x80)? 'R' :
3132                               (msg[pcboff] & 0x80)? 'S' : 'I',
3133                     ((msg[pcboff] & 0x80)? !!(msg[pcboff]& 0x10)
3134                      : !!(msg[pcboff] & 0x40)),
3135                     ((msg[pcboff] & 0xc0) == 0x80)? (msg[pcboff] & 0x0f) : 0,
3136                     (!(msg[pcboff] & 0x80) && (msg[pcboff] & 0x20)?
3137                      " [more]":""));
3138
3139       wait_more = 0;
3140       if (!(tpdu[1] & 0x80))
3141         { /* This is an I-block. */
3142           retries = 0;
3143           if (sending)
3144             { /* last block sent was successful. */
3145               handle->t1_ns ^= 1;
3146               sending = 0;
3147             }
3148
3149           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3150             { /* Response does not match our sequence number. */
3151               msg = send_buffer;
3152               tpdu = msg + hdrlen;
3153               tpdu[0] = nad_byte;
3154               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
3155               tpdu[2] = 0;
3156               tpdulen = 3;
3157               edc = compute_edc (tpdu, tpdulen, use_crc);
3158               if (use_crc)
3159                 tpdu[tpdulen++] = (edc >> 8);
3160               tpdu[tpdulen++] = edc;
3161
3162               continue;
3163             }
3164
3165           handle->t1_nr ^= 1;
3166
3167           p = tpdu + 3; /* Skip the prologue field. */
3168           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3169           /* fixme: verify the checksum. */
3170           if (resp)
3171             {
3172               if (n > maxresplen)
3173                 {
3174                   DEBUGOUT_2 ("provided buffer too short for received data "
3175                               "(%u/%u)\n",
3176                               (unsigned int)n, (unsigned int)maxresplen);
3177                   return CCID_DRIVER_ERR_INV_VALUE;
3178                 }
3179
3180               memcpy (resp, p, n);
3181               resp += n;
3182               *nresp += n;
3183               maxresplen -= n;
3184             }
3185
3186           if (!(tpdu[1] & 0x20))
3187             return 0; /* No chaining requested - ready. */
3188
3189           msg = send_buffer;
3190           tpdu = msg + hdrlen;
3191           tpdu[0] = nad_byte;
3192           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
3193           tpdu[2] = 0;
3194           tpdulen = 3;
3195           edc = compute_edc (tpdu, tpdulen, use_crc);
3196           if (use_crc)
3197             tpdu[tpdulen++] = (edc >> 8);
3198           tpdu[tpdulen++] = edc;
3199         }
3200       else if ((tpdu[1] & 0xc0) == 0x80)
3201         { /* This is a R-block. */
3202           if ( (tpdu[1] & 0x0f))
3203             {
3204               retries++;
3205               if (via_escape && retries == 1 && (msg[pcboff] & 0x0f))
3206                 {
3207                   /* Error probably due to switching to TPDU.  Send a
3208                      resync request.  We use the recv_buffer so that
3209                      we don't corrupt the send_buffer.  */
3210                   msg = recv_buffer;
3211                   tpdu = msg + hdrlen;
3212                   tpdu[0] = nad_byte;
3213                   tpdu[1] = 0xc0; /* S-block resync request. */
3214                   tpdu[2] = 0;
3215                   tpdulen = 3;
3216                   edc = compute_edc (tpdu, tpdulen, use_crc);
3217                   if (use_crc)
3218                     tpdu[tpdulen++] = (edc >> 8);
3219                   tpdu[tpdulen++] = edc;
3220                   resyncing = 1;
3221                   DEBUGOUT ("T=1: requesting resync\n");
3222                 }
3223               else if (retries > 3)
3224                 {
3225                   DEBUGOUT ("T=1: 3 failed retries\n");
3226                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
3227                 }
3228               else
3229                 {
3230                   /* Error: repeat last block */
3231                   msg = send_buffer;
3232                   tpdulen = last_tpdulen;
3233                 }
3234             }
3235           else if (sending && !!(tpdu[1] & 0x10) == handle->t1_ns)
3236             { /* Response does not match our sequence number. */
3237               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
3238               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3239             }
3240           else if (sending)
3241             { /* Send next chunk. */
3242               retries = 0;
3243               msg = send_buffer;
3244               next_chunk = 1;
3245               handle->t1_ns ^= 1;
3246             }
3247           else
3248             {
3249               DEBUGOUT ("unexpected ACK R-block received\n");
3250               return CCID_DRIVER_ERR_CARD_IO_ERROR;
3251             }
3252         }
3253       else
3254         { /* This is a S-block. */
3255           retries = 0;
3256           DEBUGOUT_2 ("T=1: S-block %s received cmd=%d\n",
3257                       (tpdu[1] & 0x20)? "response": "request",
3258                       (tpdu[1] & 0x1f));
3259           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 1 && tpdu[2] == 1)
3260             {
3261               /* Information field size request.  */
3262               unsigned char ifsc = tpdu[3];
3263
3264               if (ifsc < 16 || ifsc > 254)
3265                 return CCID_DRIVER_ERR_CARD_IO_ERROR;
3266
3267               msg = send_buffer;
3268               tpdu = msg + hdrlen;
3269               tpdu[0] = nad_byte;
3270               tpdu[1] = (0xc0 | 0x20 | 1); /* S-block response */
3271               tpdu[2] = 1;
3272               tpdu[3] = ifsc;
3273               tpdulen = 4;
3274               edc = compute_edc (tpdu, tpdulen, use_crc);
3275               if (use_crc)
3276                 tpdu[tpdulen++] = (edc >> 8);
3277               tpdu[tpdulen++] = edc;
3278               DEBUGOUT_1 ("T=1: requesting an ifsc=%d\n", ifsc);
3279             }
3280           else if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
3281             {
3282               /* Wait time extension request. */
3283               unsigned char bwi = tpdu[3];
3284
3285               wait_more = bwi;
3286
3287               msg = send_buffer;
3288               tpdu = msg + hdrlen;
3289               tpdu[0] = nad_byte;
3290               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
3291               tpdu[2] = 1;
3292               tpdu[3] = bwi;
3293               tpdulen = 4;
3294               edc = compute_edc (tpdu, tpdulen, use_crc);
3295               if (use_crc)
3296                 tpdu[tpdulen++] = (edc >> 8);
3297               tpdu[tpdulen++] = edc;
3298               DEBUGOUT_1 ("T=1: waittime extension of bwi=%d\n", bwi);
3299               print_progress (handle);
3300             }
3301           else if ( (tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 0 && !tpdu[2])
3302             {
3303               DEBUGOUT ("T=1: resync ack from reader\n");
3304               /* Repeat previous block.  */
3305               msg = send_buffer;
3306               tpdulen = last_tpdulen;
3307             }
3308           else
3309             return CCID_DRIVER_ERR_CARD_IO_ERROR;
3310         }
3311     } /* end T=1 protocol loop. */
3312
3313   return 0;
3314 }
3315
3316
3317 /* Send the CCID Secure command to the reader.  APDU_BUF should
3318    contain the APDU template.  PIN_MODE defines how the pin gets
3319    formatted:
3320
3321      1 := The PIN is ASCII encoded and of variable length.  The
3322           length of the PIN entered will be put into Lc by the reader.
3323           The APDU should me made up of 4 bytes without Lc.
3324
3325    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
3326    may be used t enable reasonable defaults.
3327
3328    When called with RESP and NRESP set to NULL, the function will
3329    merely check whether the reader supports the secure command for the
3330    given APDU and PIN_MODE. */
3331 int
3332 ccid_transceive_secure (ccid_driver_t handle,
3333                         const unsigned char *apdu_buf, size_t apdu_buflen,
3334                         pininfo_t *pininfo,
3335                         unsigned char *resp, size_t maxresplen, size_t *nresp)
3336 {
3337   int rc;
3338   unsigned char send_buffer[10+259], recv_buffer[10+259];
3339   unsigned char *msg, *tpdu, *p;
3340   size_t msglen, tpdulen, n;
3341   unsigned char seqno;
3342   size_t dummy_nresp;
3343   int testmode;
3344   int cherry_mode = 0;
3345   int add_zero = 0;
3346   int enable_varlen = 0;
3347
3348   testmode = !resp && !nresp;
3349
3350   if (!nresp)
3351     nresp = &dummy_nresp;
3352   *nresp = 0;
3353
3354   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
3355     ;
3356   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
3357     ;
3358   else
3359     return CCID_DRIVER_ERR_NO_PINPAD;
3360
3361   if (!pininfo->minlen)
3362     pininfo->minlen = 1;
3363   if (!pininfo->maxlen)
3364     pininfo->maxlen = 15;
3365
3366   /* Note that the 25 is the maximum value the SPR532 allows.  */
3367   if (pininfo->minlen < 1 || pininfo->minlen > 25
3368       || pininfo->maxlen < 1 || pininfo->maxlen > 25
3369       || pininfo->minlen > pininfo->maxlen)
3370     return CCID_DRIVER_ERR_INV_VALUE;
3371
3372   /* We have only tested a few readers so better don't risk anything
3373      and do not allow the use with other readers. */
3374   switch (handle->id_vendor)
3375     {
3376     case VENDOR_SCM:  /* Tested with SPR 532. */
3377     case VENDOR_KAAN: /* Tested with KAAN Advanced (1.02). */
3378     case VENDOR_FSIJ: /* Tested with Gnuk (0.21). */
3379       pininfo->maxlen = 25;
3380       enable_varlen = 1;
3381       break;
3382     case VENDOR_REINER:/* Tested with cyberJack go */
3383     case VENDOR_VASCO: /* Tested with DIGIPASS 920 */
3384       enable_varlen = 1;
3385       break;
3386     case VENDOR_CHERRY:
3387       pininfo->maxlen = 15;
3388       enable_varlen = 1;
3389       /* The CHERRY XX44 keyboard echos an asterisk for each entered
3390          character on the keyboard channel.  We use a special variant
3391          of PC_to_RDR_Secure which directs these characters to the
3392          smart card's bulk-in channel.  We also need to append a zero
3393          Lc byte to the APDU.  It seems that it will be replaced with
3394          the actual length instead of being appended before the APDU
3395          is send to the card. */
3396       add_zero = 1;
3397       if (handle->id_product != CHERRY_ST2000)
3398         cherry_mode = 1;
3399       break;
3400     case VENDOR_NXP:
3401       if (handle->id_product == CRYPTOUCAN){
3402         pininfo->maxlen = 25;
3403         enable_varlen = 1;
3404       }
3405       break;
3406     default:
3407       if ((handle->id_vendor == VENDOR_GEMPC &&
3408            handle->id_product == GEMPC_PINPAD)
3409           || (handle->id_vendor == VENDOR_VEGA &&
3410               handle->id_product == VEGA_ALPHA))
3411         {
3412           enable_varlen = 0;
3413           pininfo->minlen = 4;
3414           pininfo->maxlen = 8;
3415           break;
3416         }
3417      return CCID_DRIVER_ERR_NOT_SUPPORTED;
3418     }
3419
3420   if (enable_varlen)
3421     pininfo->fixedlen = 0;
3422
3423   if (testmode)
3424     return 0; /* Success */
3425
3426   if (pininfo->fixedlen < 0 || pininfo->fixedlen >= 16)
3427     return CCID_DRIVER_ERR_NOT_SUPPORTED;
3428
3429   msg = send_buffer;
3430   if (handle->id_vendor == VENDOR_SCM)
3431     {
3432       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
3433       rc = send_escape_cmd (handle, (const unsigned char*)"\x80\x02\x00", 3,
3434                             NULL, 0, NULL);
3435       if (rc)
3436         return rc;
3437     }
3438
3439   msg[0] = cherry_mode? 0x89 : PC_to_RDR_Secure;
3440   msg[5] = 0; /* slot */
3441   msg[6] = seqno = handle->seqno++;
3442   msg[7] = 0; /* bBWI */
3443   msg[8] = 0; /* RFU */
3444   msg[9] = 0; /* RFU */
3445   msg[10] = apdu_buf[1] == 0x20 ? 0 : 1;
3446                /* Perform PIN verification or PIN modification. */
3447   msg[11] = 0; /* Timeout in seconds. */
3448   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
3449   if (handle->id_vendor == VENDOR_SCM)
3450     {
3451       /* For the SPR532 the next 2 bytes need to be zero.  We do this
3452          for all SCM products.  Kudos to Martin Paljak for this
3453          hint.  */
3454       msg[13] = msg[14] = 0;
3455     }
3456   else
3457     {
3458       msg[13] = pininfo->fixedlen; /* bmPINBlockString:
3459                                       0 bits of pin length to insert.
3460                                       PIN block size by fixedlen.  */
3461       msg[14] = 0x00; /* bmPINLengthFormat:
3462                          Units are bytes, position is 0. */
3463     }
3464
3465   msglen = 15;
3466   if (apdu_buf[1] == 0x24)
3467     {
3468       msg[msglen++] = 0;    /* bInsertionOffsetOld */
3469       msg[msglen++] = pininfo->fixedlen;    /* bInsertionOffsetNew */
3470     }
3471
3472   /* The following is a little endian word. */
3473   msg[msglen++] = pininfo->maxlen;   /* wPINMaxExtraDigit-Maximum.  */
3474   msg[msglen++] = pininfo->minlen;   /* wPINMaxExtraDigit-Minimum.  */
3475
3476   if (apdu_buf[1] == 0x24)
3477     msg[msglen++] = apdu_buf[2] == 0 ? 0x03 : 0x01;
3478               /* bConfirmPIN
3479                *    0x00: new PIN once
3480                *    0x01: new PIN twice (confirmation)
3481                *    0x02: old PIN and new PIN once
3482                *    0x03: old PIN and new PIN twice (confirmation)
3483                */
3484
3485   msg[msglen] = 0x02; /* bEntryValidationCondition:
3486                          Validation key pressed */
3487   if (pininfo->minlen && pininfo->maxlen && pininfo->minlen == pininfo->maxlen)
3488     msg[msglen] |= 0x01; /* Max size reached.  */
3489   msglen++;
3490
3491   if (apdu_buf[1] == 0x20)
3492     msg[msglen++] = 0x01; /* bNumberMessage. */
3493   else
3494     msg[msglen++] = 0x03; /* bNumberMessage. */
3495
3496   msg[msglen++] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
3497   msg[msglen++] = 0x04; /* wLangId-High. */
3498
3499   if (apdu_buf[1] == 0x20)
3500     msg[msglen++] = 0;    /* bMsgIndex. */
3501   else
3502     {
3503       msg[msglen++] = 0;    /* bMsgIndex1. */
3504       msg[msglen++] = 1;    /* bMsgIndex2. */
3505       msg[msglen++] = 2;    /* bMsgIndex3. */
3506     }
3507
3508   /* Calculate Lc.  */
3509   n = pininfo->fixedlen;
3510   if (apdu_buf[1] == 0x24)
3511     n += pininfo->fixedlen;
3512
3513   /* bTeoProlog follows: */
3514   msg[msglen++] = handle->nonnull_nad? ((1 << 4) | 0): 0;
3515   msg[msglen++] = ((handle->t1_ns & 1) << 6); /* I-block */
3516   if (n)
3517     msg[msglen++] = n + 5; /* apdulen should be filled for fixed length.  */
3518   else
3519     msg[msglen++] = 0; /* The apdulen will be filled in by the reader.  */
3520   /* APDU follows:  */
3521   msg[msglen++] = apdu_buf[0]; /* CLA */
3522   msg[msglen++] = apdu_buf[1]; /* INS */
3523   msg[msglen++] = apdu_buf[2]; /* P1 */
3524   msg[msglen++] = apdu_buf[3]; /* P2 */
3525   if (add_zero)
3526     msg[msglen++] = 0;
3527   else if (pininfo->fixedlen != 0)
3528     {
3529       msg[msglen++] = n;
3530       memset (&msg[msglen], 0xff, n);
3531       msglen += n;
3532     }
3533   /* An EDC is not required. */
3534   set_msg_len (msg, msglen - 10);
3535
3536   rc = bulk_out (handle, msg, msglen, 0);
3537   if (rc)
3538     return rc;
3539
3540   msg = recv_buffer;
3541   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
3542                 RDR_to_PC_DataBlock, seqno, 30000, 0);
3543   if (rc)
3544     return rc;
3545
3546   tpdu = msg + 10;
3547   tpdulen = msglen - 10;
3548
3549   if (handle->apdu_level)
3550     {
3551       if (resp)
3552         {
3553           if (tpdulen > maxresplen)
3554             {
3555               DEBUGOUT_2 ("provided buffer too short for received data "
3556                           "(%u/%u)\n",
3557                           (unsigned int)tpdulen, (unsigned int)maxresplen);
3558               return CCID_DRIVER_ERR_INV_VALUE;
3559             }
3560
3561           memcpy (resp, tpdu, tpdulen);
3562           *nresp = tpdulen;
3563         }
3564       return 0;
3565     }
3566
3567   if (tpdulen < 4)
3568     {
3569 #ifdef USE_NPTH
3570       npth_unprotect ();
3571 #endif
3572       libusb_clear_halt (handle->idev, handle->ep_bulk_in);
3573 #ifdef USE_NPTH
3574       npth_protect ();
3575 #endif
3576       return CCID_DRIVER_ERR_ABORTED;
3577     }
3578   if (debug_level > 1)
3579     DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
3580                 ((msg[11] & 0xc0) == 0x80)? 'R' :
3581                           (msg[11] & 0x80)? 'S' : 'I',
3582                 ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
3583                 ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
3584                 (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
3585
3586   if (!(tpdu[1] & 0x80))
3587     { /* This is an I-block. */
3588       /* Last block sent was successful. */
3589       handle->t1_ns ^= 1;
3590
3591       if (!!(tpdu[1] & 0x40) != handle->t1_nr)
3592         { /* Response does not match our sequence number. */
3593           DEBUGOUT ("I-block with wrong seqno received\n");
3594           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3595         }
3596
3597       handle->t1_nr ^= 1;
3598
3599       p = tpdu + 3; /* Skip the prologue field. */
3600       n = tpdulen - 3 - 1; /* Strip the epilogue field. */
3601       /* fixme: verify the checksum. */
3602       if (resp)
3603         {
3604           if (n > maxresplen)
3605             {
3606               DEBUGOUT_2 ("provided buffer too short for received data "
3607                           "(%u/%u)\n",
3608                           (unsigned int)n, (unsigned int)maxresplen);
3609               return CCID_DRIVER_ERR_INV_VALUE;
3610             }
3611
3612           memcpy (resp, p, n);
3613           *nresp += n;
3614         }
3615
3616       if (!(tpdu[1] & 0x20))
3617         return 0; /* No chaining requested - ready. */
3618
3619       DEBUGOUT ("chaining requested but not supported for Secure operation\n");
3620       return CCID_DRIVER_ERR_CARD_IO_ERROR;
3621     }
3622   else if ((tpdu[1] & 0xc0) == 0x80)
3623     { /* This is a R-block. */
3624       if ( (tpdu[1] & 0x0f))
3625         { /* Error: repeat last block */
3626           DEBUGOUT ("No retries supported for Secure operation\n");
3627           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3628         }
3629       else if (!!(tpdu[1] & 0x10) == handle->t1_ns)
3630         { /* Response does not match our sequence number. */
3631           DEBUGOUT ("R-block with wrong seqno received on more bit\n");
3632           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3633         }
3634       else
3635         { /* Send next chunk. */
3636           DEBUGOUT ("chaining not supported on Secure operation\n");
3637           return CCID_DRIVER_ERR_CARD_IO_ERROR;
3638         }
3639     }
3640   else
3641     { /* This is a S-block. */
3642       DEBUGOUT_2 ("T=1: S-block %s received cmd=%d for Secure operation\n",
3643                   (tpdu[1] & 0x20)? "response": "request",
3644                   (tpdu[1] & 0x1f));
3645       return CCID_DRIVER_ERR_CARD_IO_ERROR;
3646     }
3647
3648   return 0;
3649 }
3650
3651
3652
3653
3654 #ifdef TEST
3655
3656
3657 static void
3658 print_error (int err)
3659 {
3660   const char *p;
3661   char buf[50];
3662
3663   switch (err)
3664     {
3665     case 0: p = "success";
3666     case CCID_DRIVER_ERR_OUT_OF_CORE: p = "out of core"; break;
3667     case CCID_DRIVER_ERR_INV_VALUE: p = "invalid value"; break;
3668     case CCID_DRIVER_ERR_NO_DRIVER: p = "no driver"; break;
3669     case CCID_DRIVER_ERR_NOT_SUPPORTED: p = "not supported"; break;
3670     case CCID_DRIVER_ERR_LOCKING_FAILED: p = "locking failed"; break;
3671     case CCID_DRIVER_ERR_BUSY: p = "busy"; break;
3672     case CCID_DRIVER_ERR_NO_CARD: p = "no card"; break;
3673     case CCID_DRIVER_ERR_CARD_INACTIVE: p = "card inactive"; break;
3674     case CCID_DRIVER_ERR_CARD_IO_ERROR: p = "card I/O error"; break;
3675     case CCID_DRIVER_ERR_GENERAL_ERROR: p = "general error"; break;
3676     case CCID_DRIVER_ERR_NO_READER: p = "no reader"; break;
3677     case CCID_DRIVER_ERR_ABORTED: p = "aborted"; break;
3678     default: sprintf (buf, "0x%05x", err); p = buf; break;
3679     }
3680   fprintf (stderr, "operation failed: %s\n", p);
3681 }
3682
3683
3684 static void
3685 print_data (const unsigned char *data, size_t length)
3686 {
3687   if (length >= 2)
3688     {
3689       fprintf (stderr, "operation status: %02X%02X\n",
3690                data[length-2], data[length-1]);
3691       length -= 2;
3692     }
3693   if (length)
3694     {
3695         fputs ("   returned data:", stderr);
3696         for (; length; length--, data++)
3697           fprintf (stderr, " %02X", *data);
3698         putc ('\n', stderr);
3699     }
3700 }
3701
3702 static void
3703 print_result (int rc, const unsigned char *data, size_t length)
3704 {
3705   if (rc)
3706     print_error (rc);
3707   else if (data)
3708     print_data (data, length);
3709 }
3710
3711 int
3712 main (int argc, char **argv)
3713 {
3714   int rc;
3715   ccid_driver_t ccid;
3716   int slotstat;
3717   unsigned char result[512];
3718   size_t resultlen;
3719   int no_pinpad = 0;
3720   int verify_123456 = 0;
3721   int did_verify = 0;
3722   int no_poll = 0;
3723
3724   if (argc)
3725     {
3726       argc--;
3727       argv++;
3728     }
3729
3730   while (argc)
3731     {
3732       if ( !strcmp (*argv, "--list"))
3733         {
3734           char *p;
3735           p = ccid_get_reader_list ();
3736           if (!p)
3737             return 1;
3738           fputs (p, stderr);
3739           free (p);
3740           return 0;
3741         }
3742       else if ( !strcmp (*argv, "--debug"))
3743         {
3744           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
3745           argc--; argv++;
3746         }
3747       else if ( !strcmp (*argv, "--no-poll"))
3748         {
3749           no_poll = 1;
3750           argc--; argv++;
3751         }
3752       else if ( !strcmp (*argv, "--no-pinpad"))
3753         {
3754           no_pinpad = 1;
3755           argc--; argv++;
3756         }
3757       else if ( !strcmp (*argv, "--verify-123456"))
3758         {
3759           verify_123456 = 1;
3760           argc--; argv++;
3761         }
3762       else
3763         break;
3764     }
3765
3766   rc = ccid_open_reader (&ccid, argc? *argv:NULL, NULL);
3767   if (rc)
3768     return 1;
3769
3770   if (!no_poll)
3771     ccid_poll (ccid);
3772   fputs ("getting ATR ...\n", stderr);
3773   rc = ccid_get_atr (ccid, NULL, 0, NULL);
3774   if (rc)
3775     {
3776       print_error (rc);
3777       return 1;
3778     }
3779
3780   if (!no_poll)
3781     ccid_poll (ccid);
3782   fputs ("getting slot status ...\n", stderr);
3783   rc = ccid_slot_status (ccid, &slotstat, 1);
3784   if (rc)
3785     {
3786       print_error (rc);
3787       return 1;
3788     }
3789
3790   if (!no_poll)
3791     ccid_poll (ccid);
3792
3793   fputs ("selecting application OpenPGP ....\n", stderr);
3794   {
3795     static unsigned char apdu[] = {
3796       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
3797     rc = ccid_transceive (ccid,
3798                           apdu, sizeof apdu,
3799                           result, sizeof result, &resultlen);
3800     print_result (rc, result, resultlen);
3801   }
3802
3803
3804   if (!no_poll)
3805     ccid_poll (ccid);
3806
3807   fputs ("getting OpenPGP DO 0x65 ....\n", stderr);
3808   {
3809     static unsigned char apdu[] = { 0, 0xCA, 0, 0x65, 254 };
3810     rc = ccid_transceive (ccid, apdu, sizeof apdu,
3811                           result, sizeof result, &resultlen);
3812     print_result (rc, result, resultlen);
3813   }
3814
3815   if (!no_pinpad)
3816     {
3817     }
3818
3819   if (!no_pinpad)
3820     {
3821       static unsigned char apdu[] = { 0, 0x20, 0, 0x81 };
3822
3823
3824       if (ccid_transceive_secure (ccid,
3825                                   apdu, sizeof apdu,
3826                                   1, 0, 0, 0,
3827                                   NULL, 0, NULL))
3828         fputs ("can't verify using a PIN-Pad reader\n", stderr);
3829       else
3830         {
3831           fputs ("verifying CHV1 using the PINPad ....\n", stderr);
3832
3833           rc = ccid_transceive_secure (ccid,
3834                                        apdu, sizeof apdu,
3835                                        1, 0, 0, 0,
3836                                        result, sizeof result, &resultlen);
3837           print_result (rc, result, resultlen);
3838           did_verify = 1;
3839         }
3840     }
3841
3842   if (verify_123456 && !did_verify)
3843     {
3844       fputs ("verifying that CHV1 is 123456....\n", stderr);
3845       {
3846         static unsigned char apdu[] = {0, 0x20, 0, 0x81,
3847                                        6, '1','2','3','4','5','6'};
3848         rc = ccid_transceive (ccid, apdu, sizeof apdu,
3849                               result, sizeof result, &resultlen);
3850         print_result (rc, result, resultlen);
3851       }
3852     }
3853
3854   if (!rc)
3855     {
3856       fputs ("getting OpenPGP DO 0x5E ....\n", stderr);
3857       {
3858         static unsigned char apdu[] = { 0, 0xCA, 0, 0x5E, 254 };
3859         rc = ccid_transceive (ccid, apdu, sizeof apdu,
3860                               result, sizeof result, &resultlen);
3861         print_result (rc, result, resultlen);
3862       }
3863     }
3864
3865   ccid_close_reader (ccid);
3866
3867   return 0;
3868 }
3869
3870 /*
3871  * Local Variables:
3872  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
3873  * End:
3874  */
3875 #endif /*TEST*/
3876 #endif /*HAVE_LIBUSB*/