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