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