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