(ccid_open_reader): Store the vendor ID.
[gnupg.git] / scd / ccid-driver.c
1 /* ccid-driver.c - USB ChipCardInterfaceDevices driver
2  *      Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3  *      Written by Werner Koch.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  *
21  * ALTERNATIVELY, this file may be distributed under the terms of the
22  * following license, in which case the provisions of this license are
23  * required INSTEAD OF the GNU General Public License. If you wish to
24  * allow use of your version of this file only under the terms of the
25  * GNU General Public License, and not to allow others to use your
26  * version of this file under the terms of the following license,
27  * indicate your decision by deleting this paragraph and the license
28  * below.
29  *
30  * Redistribution and use in source and binary forms, with or without
31  * modification, are permitted provided that the following conditions
32  * are met:
33  * 1. Redistributions of source code must retain the above copyright
34  *    notice, and the entire permission notice in its entirety,
35  *    including the disclaimer of warranties.
36  * 2. Redistributions in binary form must reproduce the above copyright
37  *    notice, this list of conditions and the following disclaimer in the
38  *    documentation and/or other materials provided with the distribution.
39  * 3. The name of the author may not be used to endorse or promote
40  *    products derived from this software without specific prior
41  *    written permission.
42  *
43  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
44  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
45  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
46  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
47  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
48  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
49  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
51  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
52  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
53  * OF THE POSSIBILITY OF SUCH DAMAGE.
54  */
55
56
57 /* CCID (ChipCardInterfaceDevices) is a specification for accessing
58    smartcard via a reader connected to the USB.  
59
60    This is a limited driver allowing to use some CCID drivers directly
61    without any other specila drivers. This is a fallback driver to be
62    used when nothing else works or the system should be kept minimal
63    for security reasons.  It makes use of the libusb library to gain
64    portable access to USB.
65
66    This driver has been tested with the SCM SCR335 and SPR532
67    smartcard readers and requires that a reader implements the TPDU
68    level exchange and does fully automatic initialization.
69 */
70
71 #ifdef HAVE_CONFIG_H
72 # include <config.h>
73 #endif
74
75 #if defined(HAVE_LIBUSB) || defined(TEST)
76
77 #include <errno.h>
78 #include <stdio.h>
79 #include <stdlib.h>
80 #include <string.h>
81 #include <assert.h>
82
83 #include <usb.h>
84
85 #include "ccid-driver.h"
86
87 #define DRVNAME "ccid-driver: "
88
89
90 /* Depending on how this source is used we either define our error
91    output to go to stderr or to the jnlib based logging functions.  We
92    use the latter when GNUPG_MAJOR_VERSION is defines or when both,
93    GNUPG_SCD_MAIN_HEADER and HAVE_JNLIB_LOGGING are defined.
94 */
95 #if defined(GNUPG_MAJOR_VERSION) \
96     || (defined(GNUPG_SCD_MAIN_HEADER) && defined(HAVE_JNLIB_LOGGING))
97
98 #if defined(GNUPG_SCD_MAIN_HEADER)
99 #  include GNUPG_SCD_MAIN_HEADER
100 #elif GNUPG_MAJOR_VERSION == 1 /* GnuPG Version is < 1.9. */
101 #  include "options.h"
102 #  include "util.h"
103 #  include "memory.h"
104 #  include "cardglue.h"
105 # else /* This is the modularized GnuPG 1.9 or later. */
106 #  include "scdaemon.h"
107 #endif
108
109 /* Define to print information pertaining the T=1 protocol. */
110 #undef DEBUG_T1 
111
112
113 # define DEBUGOUT(t)         do { if (debug_level) \
114                                   log_debug (DRVNAME t); } while (0)
115 # define DEBUGOUT_1(t,a)     do { if (debug_level) \
116                                   log_debug (DRVNAME t,(a)); } while (0)
117 # define DEBUGOUT_2(t,a,b)   do { if (debug_level) \
118                                   log_debug (DRVNAME t,(a),(b)); } while (0)
119 # define DEBUGOUT_3(t,a,b,c) do { if (debug_level) \
120                                   log_debug (DRVNAME t,(a),(b),(c));} while (0)
121 # define DEBUGOUT_CONT(t)    do { if (debug_level) \
122                                   log_printf (t); } while (0)
123 # define DEBUGOUT_CONT_1(t,a)  do { if (debug_level) \
124                                   log_printf (t,(a)); } while (0)
125 # define DEBUGOUT_CONT_2(t,a,b)   do { if (debug_level) \
126                                   log_printf (t,(a),(b)); } while (0)
127 # define DEBUGOUT_CONT_3(t,a,b,c) do { if (debug_level) \
128                                   log_printf (t,(a),(b),(c)); } while (0)
129 # define DEBUGOUT_LF()       do { if (debug_level) \
130                                   log_printf ("\n"); } while (0)
131
132 #else /* Other usage of this source - don't use gnupg specifics. */
133
134 # define DEBUGOUT(t)          do { if (debug_level) \
135                      fprintf (stderr, DRVNAME t); } while (0)
136 # define DEBUGOUT_1(t,a)      do { if (debug_level) \
137                      fprintf (stderr, DRVNAME t, (a)); } while (0)
138 # define DEBUGOUT_2(t,a,b)    do { if (debug_level) \
139                      fprintf (stderr, DRVNAME t, (a), (b)); } while (0)
140 # define DEBUGOUT_3(t,a,b,c)  do { if (debug_level) \
141                      fprintf (stderr, DRVNAME t, (a), (b), (c)); } while (0)
142 # define DEBUGOUT_CONT(t)     do { if (debug_level) \
143                      fprintf (stderr, t); } while (0)
144 # define DEBUGOUT_CONT_1(t,a) do { if (debug_level) \
145                      fprintf (stderr, t, (a)); } while (0)
146 # define DEBUGOUT_CONT_2(t,a,b) do { if (debug_level) \
147                      fprintf (stderr, t, (a), (b)); } while (0)
148 # define DEBUGOUT_CONT_3(t,a,b,c) do { if (debug_level) \
149                      fprintf (stderr, t, (a), (b), (c)); } while (0)
150 # define DEBUGOUT_LF()        do { if (debug_level) \
151                      putc ('\n', stderr); } while (0)
152
153 #endif /* This source not used by scdaemon. */
154
155
156
157 enum {
158   RDR_to_PC_NotifySlotChange= 0x50,
159   RDR_to_PC_HardwareError   = 0x51,
160
161   PC_to_RDR_SetParameters   = 0x61,
162   PC_to_RDR_IccPowerOn      = 0x62,
163   PC_to_RDR_IccPowerOff     = 0x63,
164   PC_to_RDR_GetSlotStatus   = 0x65,
165   PC_to_RDR_Secure          = 0x69,
166   PC_to_RDR_T0APDU          = 0x6a,
167   PC_to_RDR_Escape          = 0x6b,
168   PC_to_RDR_GetParameters   = 0x6c,
169   PC_to_RDR_ResetParameters = 0x6d,
170   PC_to_RDR_IccClock        = 0x6e,
171   PC_to_RDR_XfrBlock        = 0x6f,
172   PC_to_RDR_Mechanical      = 0x71,
173   PC_to_RDR_Abort           = 0x72,
174   PC_to_RDR_SetDataRate     = 0x73,
175
176   RDR_to_PC_DataBlock       = 0x80,
177   RDR_to_PC_SlotStatus      = 0x81,
178   RDR_to_PC_Parameters      = 0x82,
179   RDR_to_PC_Escape          = 0x83,
180   RDR_to_PC_DataRate        = 0x84
181 };
182
183
184 /* We need to know the vendor to do some hacks. */
185 enum {
186   VENDOR_SCM = 0x04e6
187 };
188
189
190 /* Store information on the driver's state.  A pointer to such a
191    structure is used as handle for most functions. */
192 struct ccid_driver_s 
193 {
194   usb_dev_handle *idev;
195   char *rid;
196   unsigned short id_vendor;
197   unsigned short id_product;
198   unsigned short bcd_device;
199   int seqno;
200   unsigned char t1_ns;
201   unsigned char t1_nr;
202   int nonnull_nad;
203   int auto_ifsd;
204   int max_ifsd;
205   int ifsd;
206   int powered_off;
207   int has_pinpad;
208 };
209
210
211 static int initialized_usb; /* Tracks whether USB has been initialized. */
212 static int debug_level;     /* Flag to control the debug output.  */
213
214
215 static unsigned int compute_edc (const unsigned char *data, size_t datalen,
216                                  int use_crc);
217 static int bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen);
218 static int bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
219                     size_t *nread, int expected_type, int seqno);
220
221 /* Convert a little endian stored 4 byte value into an unsigned
222    integer. */
223 static unsigned int 
224 convert_le_u32 (const unsigned char *buf)
225 {
226   return buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24); 
227 }
228
229 static void
230 set_msg_len (unsigned char *msg, unsigned int length)
231 {
232   msg[1] = length;
233   msg[2] = length >> 8;
234   msg[3] = length >> 16;
235   msg[4] = length >> 24;
236 }
237
238
239
240
241 /* Parse a CCID descriptor, optionally print all available features
242    and test whether this reader is usable by this driver.  Returns 0
243    if it is usable.
244
245    Note, that this code is based on the one in lsusb.c of the
246    usb-utils package, I wrote on 2003-09-01. -wk. */
247 static int
248 parse_ccid_descriptor (ccid_driver_t handle,
249                        const unsigned char *buf, size_t buflen)
250 {
251   unsigned int i;
252   unsigned int us;
253   int have_t1 = 0, have_tpdu=0, have_auto_conf = 0;
254
255
256   handle->nonnull_nad = 0;
257   handle->auto_ifsd = 0;
258   handle->max_ifsd = 32;
259   handle->ifsd = 0;
260   handle->has_pinpad = 0;
261   DEBUGOUT_3 ("idVendor: %04X  idProduct: %04X  bcdDevice: %04X\n",
262               handle->id_vendor, handle->id_product, handle->bcd_device);
263   if (buflen < 54 || buf[0] < 54)
264     {
265       DEBUGOUT ("CCID device descriptor is too short\n");
266       return -1;
267     }
268
269   DEBUGOUT   ("ChipCard Interface Descriptor:\n");
270   DEBUGOUT_1 ("  bLength             %5u\n", buf[0]);
271   DEBUGOUT_1 ("  bDescriptorType     %5u\n", buf[1]);
272   DEBUGOUT_2 ("  bcdCCID             %2x.%02x", buf[3], buf[2]);
273     if (buf[3] != 1 || buf[2] != 0) 
274       DEBUGOUT_CONT("  (Warning: Only accurate for version 1.0)");
275   DEBUGOUT_LF ();
276
277   DEBUGOUT_1 ("  nMaxSlotIndex       %5u\n", buf[4]);
278   DEBUGOUT_2 ("  bVoltageSupport     %5u  %s\n",
279               buf[5], (buf[5] == 1? "5.0V" : buf[5] == 2? "3.0V"
280                        : buf[5] == 3? "1.8V":"?"));
281
282   us = convert_le_u32 (buf+6);
283   DEBUGOUT_1 ("  dwProtocols         %5u ", us);
284   if ((us & 1))
285     DEBUGOUT_CONT (" T=0");
286   if ((us & 2))
287     {
288       DEBUGOUT_CONT (" T=1");
289       have_t1 = 1;
290     }
291   if ((us & ~3))
292     DEBUGOUT_CONT (" (Invalid values detected)");
293   DEBUGOUT_LF ();
294
295   us = convert_le_u32(buf+10);
296   DEBUGOUT_1 ("  dwDefaultClock      %5u\n", us);
297   us = convert_le_u32(buf+14);
298   DEBUGOUT_1 ("  dwMaxiumumClock     %5u\n", us);
299   DEBUGOUT_1 ("  bNumClockSupported  %5u\n", buf[18]);
300   us = convert_le_u32(buf+19);
301   DEBUGOUT_1 ("  dwDataRate        %7u bps\n", us);
302   us = convert_le_u32(buf+23);
303   DEBUGOUT_1 ("  dwMaxDataRate     %7u bps\n", us);
304   DEBUGOUT_1 ("  bNumDataRatesSupp.  %5u\n", buf[27]);
305         
306   us = convert_le_u32(buf+28);
307   DEBUGOUT_1 ("  dwMaxIFSD           %5u\n", us);
308   handle->max_ifsd = us;
309
310   us = convert_le_u32(buf+32);
311   DEBUGOUT_1 ("  dwSyncProtocols  %08X ", us);
312   if ((us&1))
313     DEBUGOUT_CONT ( " 2-wire");
314   if ((us&2))
315     DEBUGOUT_CONT ( " 3-wire");
316   if ((us&4))
317     DEBUGOUT_CONT ( " I2C");
318   DEBUGOUT_LF ();
319
320   us = convert_le_u32(buf+36);
321   DEBUGOUT_1 ("  dwMechanical     %08X ", us);
322   if ((us & 1))
323     DEBUGOUT_CONT (" accept");
324   if ((us & 2))
325     DEBUGOUT_CONT (" eject");
326   if ((us & 4))
327     DEBUGOUT_CONT (" capture");
328   if ((us & 8))
329     DEBUGOUT_CONT (" lock");
330   DEBUGOUT_LF ();
331
332   us = convert_le_u32(buf+40);
333   DEBUGOUT_1 ("  dwFeatures       %08X\n", us);
334   if ((us & 0x0002))
335     {
336       DEBUGOUT ("    Auto configuration based on ATR\n");
337       have_auto_conf = 1;
338     }
339   if ((us & 0x0004))
340     DEBUGOUT ("    Auto activation on insert\n");
341   if ((us & 0x0008))
342     DEBUGOUT ("    Auto voltage selection\n");
343   if ((us & 0x0010))
344     DEBUGOUT ("    Auto clock change\n");
345   if ((us & 0x0020))
346     DEBUGOUT ("    Auto baud rate change\n");
347   if ((us & 0x0040))
348     DEBUGOUT ("    Auto parameter negotation made by CCID\n");
349   else if ((us & 0x0080))
350     DEBUGOUT ("    Auto PPS made by CCID\n");
351   else if ((us & (0x0040 | 0x0080)))
352     DEBUGOUT ("    WARNING: conflicting negotation features\n");
353
354   if ((us & 0x0100))
355     DEBUGOUT ("    CCID can set ICC in clock stop mode\n");
356   if ((us & 0x0200))
357     {
358       DEBUGOUT ("    NAD value other than 0x00 accepted\n");
359       handle->nonnull_nad = 1;
360     }
361   if ((us & 0x0400))
362     {
363       DEBUGOUT ("    Auto IFSD exchange\n");
364       handle->auto_ifsd = 1;
365     }
366
367   if ((us & 0x00010000))
368     {
369       DEBUGOUT ("    TPDU level exchange\n");
370       have_tpdu = 1;
371     } 
372   else if ((us & 0x00020000))
373     DEBUGOUT ("    Short APDU level exchange\n");
374   else if ((us & 0x00040000))
375     DEBUGOUT ("    Short and extended APDU level exchange\n");
376   else if ((us & 0x00070000))
377     DEBUGOUT ("    WARNING: conflicting exchange levels\n");
378
379   us = convert_le_u32(buf+44);
380   DEBUGOUT_1 ("  dwMaxCCIDMsgLen     %5u\n", us);
381
382   DEBUGOUT (  "  bClassGetResponse    ");
383   if (buf[48] == 0xff)
384     DEBUGOUT_CONT ("echo\n");
385   else
386     DEBUGOUT_CONT_1 ("  %02X\n", buf[48]);
387
388   DEBUGOUT (  "  bClassEnvelope       ");
389   if (buf[49] == 0xff)
390     DEBUGOUT_CONT ("echo\n");
391   else
392     DEBUGOUT_1 ("  %02X\n", buf[48]);
393
394   DEBUGOUT (  "  wlcdLayout           ");
395   if (!buf[50] && !buf[51])
396     DEBUGOUT_CONT ("none\n");
397   else
398     DEBUGOUT_CONT_2 ("%u cols %u lines\n", buf[50], buf[51]);
399         
400   DEBUGOUT_1 ("  bPINSupport         %5u ", buf[52]);
401   if ((buf[52] & 1))
402     {
403       DEBUGOUT_CONT ( " verification");
404       handle->has_pinpad |= 1;
405     }
406   if ((buf[52] & 2))
407     {
408       DEBUGOUT_CONT ( " modification");
409       handle->has_pinpad |= 2;
410     }
411   DEBUGOUT_LF ();
412         
413   DEBUGOUT_1 ("  bMaxCCIDBusySlots   %5u\n", buf[53]);
414
415   if (buf[0] > 54) {
416     DEBUGOUT ("  junk             ");
417     for (i=54; i < buf[0]-54; i++)
418       DEBUGOUT_CONT_1 (" %02X", buf[i]);
419     DEBUGOUT_LF ();
420   }
421
422   if (!have_t1 || !have_tpdu || !have_auto_conf)
423     {
424       DEBUGOUT ("this drivers requires that the reader supports T=1, "
425                 "TPDU level exchange and auto configuration - "
426                 "this is not available\n");
427       return -1;
428     }
429
430
431   /* SCM drivers get stuck in their internal USB stack if they try to
432      send a frame of n*wMaxPacketSize back to us.  Given that
433      wMaxPacketSize is 64 for these readers we set the IFSD to a value
434      lower than that:
435         64 - 10 CCID header -  4 T1frame - 2 reserved = 48 */
436   if (handle->id_vendor == VENDOR_SCM
437       /* FIXME: check whether it is the same
438                 firmware version for all drivers.  */
439       && handle->bcd_device < 0x0513
440       && handle->max_ifsd > 48)
441     {
442       DEBUGOUT ("enabling workaround for buggy SCM readers\n");
443       handle->max_ifsd = 48;
444     }
445
446
447   return 0;
448 }
449
450
451 static char *
452 get_escaped_usb_string (usb_dev_handle *idev, int idx,
453                         const char *prefix, const char *suffix)
454 {
455   int rc;
456   unsigned char buf[280];
457   unsigned char *s;
458   unsigned int langid;
459   size_t i, n, len;
460   char *result;
461
462   if (!idx)
463     return NULL;
464
465   /* Fixme: The next line is for the current Valgrid without support
466      for USB IOCTLs. */
467   memset (buf, 0, sizeof buf);
468
469   /* First get the list of supported languages and use the first one.
470      If we do don't find it we try to use English.  Note that this is
471      all in a 2 bute Unicode encoding using little endian. */
472   rc = usb_control_msg (idev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
473                         (USB_DT_STRING << 8), 0, 
474                         buf, sizeof buf, 1000 /* ms timeout */);
475   if (rc < 4)
476     langid = 0x0409; /* English.  */
477   else
478     langid = (buf[3] << 8) | buf[2];
479
480   rc = usb_control_msg (idev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
481                         (USB_DT_STRING << 8) + idx, langid,
482                         buf, sizeof buf, 1000 /* ms timeout */);
483   if (rc < 2 || buf[1] != USB_DT_STRING)
484     return NULL; /* Error or not a string. */
485   len = buf[0];
486   if (len > rc)
487     return NULL; /* Larger than our buffer. */
488
489   for (s=buf+2, i=2, n=0; i+1 < len; i += 2, s += 2)
490     {
491       if (s[1])
492         n++; /* High byte set. */
493       else if (*s <= 0x20 || *s >= 0x7f || *s == '%' || *s == ':')
494         n += 3 ;
495       else 
496         n++;
497     }
498
499   result = malloc (strlen (prefix) + n + strlen (suffix) + 1);
500   if (!result)
501     return NULL;
502
503   strcpy (result, prefix);
504   n = strlen (prefix);
505   for (s=buf+2, i=2; i+1 < len; i += 2, s += 2)
506     {
507       if (s[1])
508         result[n++] = '\xff'; /* High byte set. */
509       else if (*s <= 0x20 || *s >= 0x7f || *s == '%' || *s == ':')
510         {
511           sprintf (result+n, "%%%02X", *s);
512           n += 3;
513         }
514       else 
515         result[n++] = *s;
516     }
517   strcpy (result+n, suffix);
518
519   return result;
520 }
521
522 /* This function creates an reader id to be used to find the same
523    physical reader after a reset.  It returns an allocated and possibly
524    percent escaped string or NULL if not enough memory is available. */
525 static char *
526 make_reader_id (usb_dev_handle *idev,
527                 unsigned int vendor, unsigned int product,
528                 unsigned char serialno_index)
529 {
530   char *rid;
531   char prefix[20];
532
533   sprintf (prefix, "%04X:%04X:", (vendor & 0xfff), (product & 0xffff));
534   rid = get_escaped_usb_string (idev, serialno_index, prefix, ":0");
535   if (!rid)
536     {
537       rid = malloc (strlen (prefix) + 3 + 1);
538       if (!rid)
539         return NULL;
540       strcpy (rid, prefix);
541       strcat (rid, "X:0");
542     }
543   return rid;
544 }
545
546
547 /* Combination function to either scan all CCID devices or to find and
548    open one specific device. 
549
550    With READERNO = -1 and READERID is NULL, scan mode is used and
551    R_RID should be the address where to store the list of reader_ids
552    we found.  If on return this list is empty, no CCID device has been
553    found; otherwise it points to an allocated linked list of reader
554    IDs.  Note that in this mode the function always returns NULL.
555
556    With READERNO >= 0 or READERID is not NULL find mode is used.  This
557    uses the same algorithm as the scan mode but stops and returns at
558    the entry number READERNO and return the handle for the the opened
559    USB device. If R_ID is not NULL it will receive the reader ID of
560    that device.  If R_DEV is not NULL it will the device pointer of
561    that device.  If IFCDESC_EXTRA is NOT NULL it will receive a
562    malloced copy of the interfaces "extra: data filed;
563    IFCDESC_EXTRA_LEN receive the lengtyh of this field.  If there is
564    no reader with number READERNO or that reader is not usable by our
565    implementation NULL will be returned.  The caller must close a
566    returned USB device handle and free (if not passed as NULL) the
567    returned reader ID info as well as the IFCDESC_EXTRA.  On error
568    NULL will get stored at R_RID, R_DEV, IFCDESC_EXTRA and
569    IFCDESC_EXTRA_LEN.  With READERID being -1 the function stops if
570    the READERID was found.
571
572    Note that the first entry of the returned reader ID list in scan mode
573    corresponds with a READERNO of 0 in find mode.
574 */
575 static usb_dev_handle *
576 scan_or_find_devices (int readerno, const char *readerid,
577                       char **r_rid,
578                       struct usb_device **r_dev,
579                       unsigned char **ifcdesc_extra,
580                       size_t *ifcdesc_extra_len)
581 {
582   char *rid_list = NULL;
583   int count = 0;
584   struct usb_bus *busses, *bus;
585   struct usb_device *dev = NULL;
586   usb_dev_handle *idev = NULL;
587   int scan_mode = (readerno == -1 && !readerid);
588
589    /* Set return values to a default. */
590   if (r_rid)
591     *r_rid = NULL;
592   if (r_dev)
593     *r_dev = NULL; 
594   if (ifcdesc_extra)
595     *ifcdesc_extra = NULL;
596   if (ifcdesc_extra_len)
597     *ifcdesc_extra_len = 0;
598
599   /* See whether we want scan or find mode. */
600   if (scan_mode) 
601     {
602       assert (r_rid);
603     }
604
605   usb_find_busses();
606   usb_find_devices();
607
608 #ifdef HAVE_USB_GET_BUSSES
609   busses = usb_get_busses();
610 #else
611   busses = usb_busses;
612 #endif
613
614   for (bus = busses; bus; bus = bus->next) 
615     {
616       for (dev = bus->devices; dev; dev = dev->next)
617         {
618           int cfg_no;
619           
620           for (cfg_no=0; cfg_no < dev->descriptor.bNumConfigurations; cfg_no++)
621             {
622               struct usb_config_descriptor *config = dev->config + cfg_no;
623               int ifc_no;
624
625               if(!config)
626                 continue;
627
628               for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
629                 {
630                   struct usb_interface *interface
631                     = config->interface + ifc_no;
632                   int set_no;
633                   
634                   if (!interface)
635                     continue;
636                   
637                   for (set_no=0; set_no < interface->num_altsetting; set_no++)
638                     {
639                       struct usb_interface_descriptor *ifcdesc
640                         = interface->altsetting + set_no;
641                       char *rid;
642                       
643                       /* The second condition is for some SCM Micro
644                          SPR 532 which does not know about the
645                          assigned CCID class. Instead of trying to
646                          interpret the strings we simply look at the
647                          product ID. */
648                       if (ifcdesc && ifcdesc->extra
649                           && (   (ifcdesc->bInterfaceClass == 11
650                                   && ifcdesc->bInterfaceSubClass == 0
651                                   && ifcdesc->bInterfaceProtocol == 0)
652                               || (ifcdesc->bInterfaceClass == 255
653                                   && dev->descriptor.idVendor == 0x04e6
654                                   && dev->descriptor.idProduct == 0xe003
655                                   && ifcdesc->bInterfaceSubClass == 1
656                                   && ifcdesc->bInterfaceProtocol == 1)))
657                         {
658                           idev = usb_open (dev);
659                           if (!idev)
660                             {
661                               DEBUGOUT_1 ("usb_open failed: %s\n",
662                                           strerror (errno));
663                               continue;
664                             }
665                               
666                           rid = make_reader_id (idev,
667                                                 dev->descriptor.idVendor,
668                                                 dev->descriptor.idProduct,
669                                                 dev->descriptor.iSerialNumber);
670                           if (rid)
671                             {
672                               if (scan_mode)
673                                 {
674                                   char *p;
675
676                                   /* We are collecting infos about all
677                                      available CCID readers.  Store
678                                      them and continue. */
679                                   DEBUGOUT_2 ("found CCID reader %d "
680                                               "(ID=%s)\n",
681                                               count, rid );
682                                   if ((p = malloc ((rid_list?
683                                                     strlen (rid_list):0)
684                                                    + 1 + strlen (rid)
685                                                    + 1)))
686                                     {
687                                       *p = 0;
688                                       if (rid_list)
689                                         {
690                                           strcat (p, rid_list);
691                                           free (rid_list);
692                                         }
693                                       strcat (p, rid);
694                                       strcat (p, "\n");
695                                       rid_list = p;
696                                     }
697                                   else /* Out of memory. */
698                                     free (rid);
699                                   rid = NULL;
700                                   count++;
701                                 }
702                               else if (!readerno
703                                        || (readerno < 0
704                                            && readerid
705                                            && !strcmp (readerid, rid)))
706                                 {
707                                   /* We found the requested reader. */
708                                   if (ifcdesc_extra && ifcdesc_extra_len)
709                                     {
710                                       *ifcdesc_extra = malloc (ifcdesc
711                                                                ->extralen);
712                                       if (!*ifcdesc_extra)
713                                         {
714                                           usb_close (idev);
715                                           free (rid);
716                                           return NULL; /* Out of core. */
717                                         }
718                                       memcpy (*ifcdesc_extra, ifcdesc->extra,
719                                               ifcdesc->extralen);
720                                       *ifcdesc_extra_len = ifcdesc->extralen;
721                                     }
722
723                                   if (r_dev)
724                                     *r_dev = dev;
725                                   if (r_rid)
726                                     {
727                                       *r_rid = rid;
728                                       rid = NULL;
729                                     }
730                                   else
731                                     free (rid);
732                                   return idev; /* READY. */
733                                 }
734                               else
735                                 {
736                                   /* This is not yet the reader we
737                                      want.  fixme: We could avoid the
738                                      extra usb_open in this case. */
739                                   if (readerno >= 0)
740                                     readerno--;
741                                 }
742                               free (rid);
743                             }
744                           
745                           usb_close (idev);
746                           idev = NULL;
747                           goto next_device;
748                         }
749                     }
750                 }
751             }
752         next_device:
753           ;
754         }
755     }
756
757   if (scan_mode)
758     *r_rid = rid_list;
759
760   return NULL;
761 }
762
763
764 /* Set the level of debugging to to usea dn return the old level.  -1
765    just returns the old level.  A level of 0 disables debugging, 1
766    enables debugging, other values are not yet defined. */
767 int
768 ccid_set_debug_level (int level)
769 {
770   int old = debug_level;
771   if (level != -1)
772     debug_level = level;
773   return old;
774 }
775
776
777 char *
778 ccid_get_reader_list (void)
779 {
780   char *reader_list;
781
782   if (!initialized_usb)
783     {
784       usb_init ();
785       initialized_usb = 1;
786     }
787
788   scan_or_find_devices (-1, NULL, &reader_list, NULL, NULL, NULL);
789   return reader_list;
790 }
791
792
793 /* Open the reader with the internal number READERNO and return a 
794    pointer to be used as handle in HANDLE.  Returns 0 on success. */
795 int 
796 ccid_open_reader (ccid_driver_t *handle, const char *readerid)
797 {
798   int rc = 0;
799   struct usb_device *dev = NULL;
800   usb_dev_handle *idev = NULL;
801   char *rid = NULL;
802   unsigned char *ifcdesc_extra = NULL;
803   size_t ifcdesc_extra_len;
804   int readerno;
805
806   *handle = NULL;
807
808   if (!initialized_usb)
809     {
810       usb_init ();
811       initialized_usb = 1;
812     }
813
814   /* See whether we want to use the reader ID string or a reader
815      number. A readerno of -1 indicates that the reader ID string is
816      to be used. */
817   if (readerid && strchr (readerid, ':'))
818     readerno = -1; /* We want to use the readerid.  */
819   else if (readerid)
820     {
821       readerno = atoi (readerid);
822       if (readerno < 0)
823         {
824           DEBUGOUT ("no CCID readers found\n");
825           rc = CCID_DRIVER_ERR_NO_READER;
826           goto leave;
827         }
828     }
829   else
830     readerno = 0;  /* Default. */
831
832   idev = scan_or_find_devices (readerno, readerid, &rid, &dev,
833                                &ifcdesc_extra, &ifcdesc_extra_len);
834   if (!idev)
835     {
836       if (readerno == -1)
837         DEBUGOUT_1 ("no CCID reader with ID %s\n", readerid );
838       else
839         DEBUGOUT_1 ("no CCID reader with number %d\n", readerno );
840       rc = CCID_DRIVER_ERR_NO_READER;
841       goto leave;
842     }
843
844   /* Okay, this is a CCID reader. */
845   *handle = calloc (1, sizeof **handle);
846   if (!*handle)
847     {
848       DEBUGOUT ("out of memory\n");
849       rc = CCID_DRIVER_ERR_OUT_OF_CORE;
850       goto leave;
851     }
852   (*handle)->idev = idev;
853   (*handle)->rid = rid;
854   (*handle)->id_vendor = dev->descriptor.idVendor;
855   (*handle)->id_product = dev->descriptor.idProduct;
856   (*handle)->bcd_device = dev->descriptor.bcdDevice;
857
858   DEBUGOUT_2 ("using CCID reader %d (ID=%s)\n",  readerno, rid );
859
860
861   if (parse_ccid_descriptor (*handle, ifcdesc_extra, ifcdesc_extra_len))
862     {
863       DEBUGOUT ("device not supported\n");
864       rc = CCID_DRIVER_ERR_NO_READER;
865       goto leave;
866     }
867   
868   /* fixme: Do we need to claim and set the interface as
869      determined above? */
870   rc = usb_claim_interface (idev, 0);
871   if (rc)
872     {
873       DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
874       rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
875       goto leave;
876     }
877   
878   /* FIXME: Do we need to get the endpoint addresses from the
879      structure and store them with the handle? */
880               
881  leave:
882   free (ifcdesc_extra);
883   if (rc)
884     {
885       free (rid);
886       if (idev)
887         usb_close (idev);
888       free (*handle);
889       *handle = NULL;
890     }
891
892   return rc;
893 }
894
895
896 static void
897 do_close_reader (ccid_driver_t handle)
898 {
899   int rc;
900   unsigned char msg[100];
901   size_t msglen;
902   unsigned char seqno;
903   
904   if (!handle->powered_off)
905     {
906       msg[0] = PC_to_RDR_IccPowerOff;
907       msg[5] = 0; /* slot */
908       msg[6] = seqno = handle->seqno++;
909       msg[7] = 0; /* RFU */
910       msg[8] = 0; /* RFU */
911       msg[9] = 0; /* RFU */
912       set_msg_len (msg, 0);
913       msglen = 10;
914       
915       rc = bulk_out (handle, msg, msglen);
916       if (!rc)
917         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,seqno);
918       handle->powered_off = 1;
919     }
920   if (handle->idev)
921     {
922       usb_release_interface (handle->idev, 0);
923       usb_close (handle->idev);
924       handle->idev = NULL;
925     }
926 }
927
928
929 /* Reset a reader on HANDLE.  This is useful in case a reader has been
930    plugged of and inserted at a different port.  By resetting the
931    handle, the same reader will be get used.  Note, that on error the
932    handle won't get released. 
933
934    This does not return an ATR, so ccid_get_atr should be called right
935    after this one.
936 */
937 int 
938 ccid_shutdown_reader (ccid_driver_t handle)
939 {
940   int rc = 0;
941   struct usb_device *dev = NULL;
942   usb_dev_handle *idev = NULL;
943   unsigned char *ifcdesc_extra = NULL;
944   size_t ifcdesc_extra_len;
945
946   if (!handle || !handle->rid)
947     return CCID_DRIVER_ERR_INV_VALUE;
948
949   do_close_reader (handle);
950
951   idev = scan_or_find_devices (-1, handle->rid, NULL, &dev,
952                                &ifcdesc_extra, &ifcdesc_extra_len);
953   if (!idev)
954     {
955       DEBUGOUT_1 ("no CCID reader with ID %s\n", handle->rid);
956       return CCID_DRIVER_ERR_NO_READER;
957     }
958
959
960   handle->idev = idev;
961
962   if (parse_ccid_descriptor (handle, ifcdesc_extra, ifcdesc_extra_len))
963     {
964       DEBUGOUT ("device not supported\n");
965       rc = CCID_DRIVER_ERR_NO_READER;
966       goto leave;
967     }
968   
969   /* fixme: Do we need to claim and set the interface as
970      determined above? */
971   rc = usb_claim_interface (idev, 0);
972   if (rc)
973     {
974       DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
975       rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
976       goto leave;
977     }
978   
979  leave:
980   free (ifcdesc_extra);
981   if (rc)
982     {
983       usb_close (handle->idev);
984       handle->idev = NULL;
985     }
986
987   return rc;
988
989 }
990
991
992 /* Close the reader HANDLE. */
993 int 
994 ccid_close_reader (ccid_driver_t handle)
995 {
996   if (!handle || !handle->idev)
997     return 0;
998
999   do_close_reader (handle);
1000   free (handle->rid);
1001   free (handle);
1002   return 0;
1003 }
1004
1005
1006 /* Return False if a card is present and powered. */
1007 int
1008 ccid_check_card_presence (ccid_driver_t handle)
1009 {
1010
1011   return -1;
1012 }
1013
1014
1015 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
1016    Returns 0 on success. */
1017 static int
1018 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen)
1019 {
1020   int rc;
1021
1022   rc = usb_bulk_write (handle->idev, 
1023                        1, /*endpoint */
1024                        msg, msglen,
1025                        1000 /* ms timeout */);
1026   if (rc == msglen)
1027     return 0;
1028
1029   if (rc == -1)
1030     DEBUGOUT_1 ("usb_bulk_write error: %s\n", strerror (errno));
1031   else
1032     DEBUGOUT_1 ("usb_bulk_write failed: %d\n", rc);
1033   return CCID_DRIVER_ERR_CARD_IO_ERROR;
1034 }
1035
1036
1037 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
1038    BUFFER and return the actual read number if bytes in NREAD. SEQNO
1039    is the sequence number used to send the request and EXPECTED_TYPE
1040    the type of message we expect. Does checks on the ccid
1041    header. Returns 0 on success. */
1042 static int
1043 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
1044          size_t *nread, int expected_type, int seqno)
1045 {
1046   int i, rc;
1047   size_t msglen;
1048
1049   /* Fixme: The next line for the current Valgrind without support
1050      for USB IOCTLs. */
1051   memset (buffer, 0, length);
1052  retry:
1053   rc = usb_bulk_read (handle->idev, 
1054                       0x82,
1055                       buffer, length,
1056                       10000 /* ms timeout */ );
1057   /* Fixme: instead of using a 10 second timeout we should better
1058      handle the timeout here and retry if appropriate.  */
1059   if (rc < 0)
1060     {
1061       DEBUGOUT_1 ("usb_bulk_read error: %s\n", strerror (errno));
1062       return CCID_DRIVER_ERR_CARD_IO_ERROR;
1063     }
1064
1065   *nread = msglen = rc;
1066
1067   if (msglen < 10)
1068     {
1069       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
1070       return CCID_DRIVER_ERR_INV_VALUE;
1071     }
1072   if (buffer[0] != expected_type)
1073     {
1074       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
1075       return CCID_DRIVER_ERR_INV_VALUE;
1076     }
1077   if (buffer[5] != 0)    
1078     {
1079       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
1080       return CCID_DRIVER_ERR_INV_VALUE;
1081     }
1082   if (buffer[6] != seqno)    
1083     {
1084       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
1085                   seqno, buffer[6]);
1086       return CCID_DRIVER_ERR_INV_VALUE;
1087     }
1088
1089   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
1090     { 
1091       /* Card present and active, time extension requested. */
1092       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
1093                   buffer[7], buffer[8]);
1094       goto retry;
1095     }
1096   
1097   DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n"
1098               "               data:",  buffer[7], buffer[8], buffer[9] );
1099   for (i=10; i < msglen; i++)
1100     DEBUGOUT_CONT_1 (" %02X", buffer[i]);
1101   DEBUGOUT_LF ();
1102
1103   switch ((buffer[7] & 0x03))
1104     {
1105     case 0: /* no error */ break;
1106     case 1: return CCID_DRIVER_ERR_CARD_INACTIVE;
1107     case 2: return CCID_DRIVER_ERR_NO_CARD;
1108     case 3: /* RFU */ break;
1109     }
1110   return 0;
1111 }
1112
1113
1114 /* Note that this fucntion won't return the error codes NO_CARD or
1115    CARD_INACTIVE */
1116 static int 
1117 send_escape_cmd (ccid_driver_t handle,
1118                  const unsigned char *data, size_t datalen)
1119 {
1120   int i, rc;
1121   unsigned char msg[100];
1122   size_t msglen;
1123   unsigned char seqno;
1124
1125   if (datalen > sizeof msg - 10)
1126     return CCID_DRIVER_ERR_INV_VALUE; /* Escape data too large.  */
1127
1128   msg[0] = PC_to_RDR_Escape;
1129   msg[5] = 0; /* slot */
1130   msg[6] = seqno = handle->seqno++;
1131   msg[7] = 0; /* RFU */
1132   msg[8] = 0; /* RFU */
1133   msg[9] = 0; /* RFU */
1134   memcpy (msg+10, data, datalen);
1135   msglen = 10 + datalen;
1136   set_msg_len (msg, datalen);
1137
1138   DEBUGOUT ("sending");
1139   for (i=0; i < msglen; i++)
1140     DEBUGOUT_CONT_1 (" %02X", msg[i]);
1141   DEBUGOUT_LF ();
1142   rc = bulk_out (handle, msg, msglen);
1143   if (rc)
1144     return rc;
1145   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Escape, seqno);
1146
1147   return rc;
1148 }
1149
1150
1151 /* experimental */
1152 int
1153 ccid_poll (ccid_driver_t handle)
1154 {
1155   int rc;
1156   unsigned char msg[10];
1157   size_t msglen;
1158   int i, j;
1159
1160   rc = usb_bulk_read (handle->idev, 
1161                       0x83,
1162                       msg, sizeof msg,
1163                       0 /* ms timeout */ );
1164   if (rc < 0 && errno == ETIMEDOUT)
1165     return 0;
1166
1167   if (rc < 0)
1168     {
1169       DEBUGOUT_1 ("usb_intr_read error: %s\n", strerror (errno));
1170       return CCID_DRIVER_ERR_CARD_IO_ERROR;
1171     }
1172
1173   msglen = rc;
1174   rc = 0;
1175
1176   if (msglen < 1)
1177     {
1178       DEBUGOUT ("intr-in msg too short\n");
1179       return CCID_DRIVER_ERR_INV_VALUE;
1180     }
1181
1182   if (msg[0] == RDR_to_PC_NotifySlotChange)
1183     {
1184       DEBUGOUT ("notify slot change:");
1185       for (i=1; i < msglen; i++)
1186         for (j=0; j < 4; j++)
1187           DEBUGOUT_CONT_3 (" %d:%c%c",
1188                            (i-1)*4+j, 
1189                            (msg[i] & (1<<(j*2)))? 'p':'-',
1190                            (msg[i] & (2<<(j*2)))? '*':' ');
1191       DEBUGOUT_LF ();
1192     }
1193   else if (msg[0] == RDR_to_PC_HardwareError)    
1194     {
1195       DEBUGOUT ("hardware error occured\n");
1196     }
1197   else
1198     {
1199       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
1200     }
1201
1202   return 0;
1203 }
1204
1205
1206 /* Note that this fucntion won't return the error codes NO_CARD or
1207    CARD_INACTIVE */
1208 int 
1209 ccid_slot_status (ccid_driver_t handle, int *statusbits)
1210 {
1211   int rc;
1212   unsigned char msg[100];
1213   size_t msglen;
1214   unsigned char seqno;
1215
1216   msg[0] = PC_to_RDR_GetSlotStatus;
1217   msg[5] = 0; /* slot */
1218   msg[6] = seqno = handle->seqno++;
1219   msg[7] = 0; /* RFU */
1220   msg[8] = 0; /* RFU */
1221   msg[9] = 0; /* RFU */
1222   set_msg_len (msg, 0);
1223
1224   rc = bulk_out (handle, msg, 10);
1225   if (rc)
1226     return rc;
1227   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus, seqno);
1228   if (rc && rc != CCID_DRIVER_ERR_NO_CARD
1229       && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
1230     return rc;
1231   *statusbits = (msg[7] & 3);
1232
1233   return 0;
1234 }
1235
1236
1237 int 
1238 ccid_get_atr (ccid_driver_t handle,
1239               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
1240 {
1241   int rc;
1242   unsigned char msg[100];
1243   unsigned char *tpdu;
1244   size_t msglen, tpdulen;
1245   unsigned char seqno;
1246   int use_crc = 0;
1247   unsigned int edc;
1248   int i;
1249
1250   msg[0] = PC_to_RDR_IccPowerOn;
1251   msg[5] = 0; /* slot */
1252   msg[6] = seqno = handle->seqno++;
1253   msg[7] = 0; /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
1254   msg[8] = 0; /* RFU */
1255   msg[9] = 0; /* RFU */
1256   set_msg_len (msg, 0);
1257   msglen = 10;
1258
1259   rc = bulk_out (handle, msg, msglen);
1260   if (rc)
1261     return rc;
1262   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock, seqno);
1263   if (rc)
1264     return rc;
1265
1266   handle->powered_off = 0;
1267   
1268   if (atr)
1269     {
1270       size_t n = msglen - 10;
1271
1272       if (n > maxatrlen)
1273         n = maxatrlen;
1274       memcpy (atr, msg+10, n);
1275       *atrlen = n;
1276     }
1277
1278   /* Setup parameters to select T=1. */
1279   msg[0] = PC_to_RDR_SetParameters;
1280   msg[5] = 0; /* slot */
1281   msg[6] = seqno = handle->seqno++;
1282   msg[7] = 1; /* Select T=1. */
1283   msg[8] = 0; /* RFU */
1284   msg[9] = 0; /* RFU */
1285
1286   /* FIXME: Get those values from the ATR. */
1287   msg[10]= 0x01; /* Fi/Di */
1288   msg[11]= 0x10; /* LRC, direct convention. */
1289   msg[12]= 0;    /* Extra guardtime. */
1290   msg[13]= 0x41; /* BWI/CWI */
1291   msg[14]= 0;    /* No clock stoppping. */
1292   msg[15]= 254;  /* IFSC */
1293   msg[16]= 0;    /* Does not support non default NAD values. */
1294   set_msg_len (msg, 7);
1295   msglen = 10 + 7;
1296
1297   DEBUGOUT ("sending");
1298   for (i=0; i < msglen; i++)
1299     DEBUGOUT_CONT_1 (" %02X", msg[i]);
1300   DEBUGOUT_LF ();
1301
1302   rc = bulk_out (handle, msg, msglen);
1303   if (rc)
1304     return rc;
1305   /* Note that we ignore the error code on purpose. */
1306   bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters, seqno);
1307
1308
1309   /* Send an S-Block with our maximun IFSD to the CCID.  */
1310   if (!handle->auto_ifsd)
1311     {
1312       tpdu = msg+10;
1313       /* NAD: DAD=1, SAD=0 */
1314       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1315       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
1316       tpdu[2] = 1;
1317       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32; 
1318       tpdulen = 4;
1319       edc = compute_edc (tpdu, tpdulen, use_crc);
1320       if (use_crc)
1321         tpdu[tpdulen++] = (edc >> 8);
1322       tpdu[tpdulen++] = edc;
1323
1324       msg[0] = PC_to_RDR_XfrBlock;
1325       msg[5] = 0; /* slot */
1326       msg[6] = seqno = handle->seqno++;
1327       msg[7] = 0; 
1328       msg[8] = 0; /* RFU */
1329       msg[9] = 0; /* RFU */
1330       set_msg_len (msg, tpdulen);
1331       msglen = 10 + tpdulen;
1332
1333       DEBUGOUT ("sending");
1334       for (i=0; i < msglen; i++)
1335         DEBUGOUT_CONT_1 (" %02X", msg[i]);
1336       DEBUGOUT_LF ();
1337
1338 #ifdef DEBUG_T1      
1339       fprintf (stderr, "T1: put %c-block seq=%d\n",
1340                ((msg[11] & 0xc0) == 0x80)? 'R' :
1341                (msg[11] & 0x80)? 'S' : 'I',
1342                ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)));
1343 #endif  
1344
1345       rc = bulk_out (handle, msg, msglen);
1346       if (rc)
1347         return rc;
1348
1349
1350       rc = bulk_in (handle, msg, sizeof msg, &msglen,
1351                     RDR_to_PC_DataBlock, seqno);
1352       if (rc)
1353         return rc;
1354       
1355       tpdu = msg + 10;
1356       tpdulen = msglen - 10;
1357       
1358       if (tpdulen < 4) 
1359         return CCID_DRIVER_ERR_ABORTED; 
1360
1361 #ifdef DEBUG_T1
1362       fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
1363                ((msg[11] & 0xc0) == 0x80)? 'R' :
1364                (msg[11] & 0x80)? 'S' : 'I',
1365                ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
1366                ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
1367                );
1368 #endif
1369       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
1370         {
1371           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
1372           return -1;
1373         }
1374       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
1375     }
1376
1377   return 0;
1378 }
1379
1380
1381 \f
1382
1383 static unsigned int 
1384 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
1385 {
1386   if (use_crc)
1387     {
1388       return 0x42; /* Not yet implemented. */
1389     }
1390   else
1391     {
1392       unsigned char crc = 0;
1393       
1394       for (; datalen; datalen--)
1395         crc ^= *data++;
1396       return crc;
1397     }
1398 }
1399
1400
1401 /*
1402   Protocol T=1 overview
1403
1404   Block Structure:
1405            Prologue Field:
1406    1 byte     Node Address (NAD) 
1407    1 byte     Protocol Control Byte (PCB)
1408    1 byte     Length (LEN) 
1409            Information Field:
1410    0-254 byte APDU or Control Information (INF)
1411            Epilogue Field:
1412    1 byte     Error Detection Code (EDC)
1413
1414   NAD:  
1415    bit 7     unused
1416    bit 4..6  Destination Node Address (DAD)
1417    bit 3     unused
1418    bit 2..0  Source Node Address (SAD)
1419
1420    If node adresses are not used, SAD and DAD should be set to 0 on
1421    the first block sent to the card.  If they are used they should
1422    have different values (0 for one is okay); that first block sets up
1423    the addresses of the nodes.
1424
1425   PCB:
1426    Information Block (I-Block):
1427       bit 7    0
1428       bit 6    Sequence number (yep, that is modulo 2)
1429       bit 5    Chaining flag 
1430       bit 4..0 reserved
1431    Received-Ready Block (R-Block):
1432       bit 7    1
1433       bit 6    0
1434       bit 5    0
1435       bit 4    Sequence number
1436       bit 3..0  0 = no error
1437                 1 = EDC or parity error
1438                 2 = other error
1439                 other values are reserved
1440    Supervisory Block (S-Block):
1441       bit 7    1
1442       bit 6    1
1443       bit 5    clear=request,set=response
1444       bit 4..0  0 = resyncronisation request
1445                 1 = information field size request
1446                 2 = abort request
1447                 3 = extension of BWT request
1448                 4 = VPP error
1449                 other values are reserved
1450
1451 */
1452
1453 int
1454 ccid_transceive (ccid_driver_t handle,
1455                  const unsigned char *apdu_buf, size_t apdu_buflen,
1456                  unsigned char *resp, size_t maxresplen, size_t *nresp)
1457 {
1458   int rc;
1459   unsigned char send_buffer[10+259], recv_buffer[10+259];
1460   const unsigned char *apdu;
1461   size_t apdulen;
1462   unsigned char *msg, *tpdu, *p;
1463   size_t msglen, tpdulen, last_tpdulen, n;
1464   unsigned char seqno;
1465   int i;
1466   unsigned int edc;
1467   int use_crc = 0;
1468   size_t dummy_nresp;
1469   int next_chunk = 1;
1470   int sending = 1;
1471   int retries = 0;
1472
1473   if (!nresp)
1474     nresp = &dummy_nresp;
1475   *nresp = 0;
1476
1477   tpdulen = 0; /* Avoid compiler warning about no initialization. */
1478   msg = send_buffer;
1479   for (;;)
1480     {
1481       if (next_chunk)
1482         {
1483           next_chunk = 0;
1484
1485           apdu = apdu_buf;
1486           apdulen = apdu_buflen;
1487           assert (apdulen);
1488
1489           /* Construct an I-Block. */
1490           if (apdulen > 254)
1491             return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
1492
1493           tpdu = msg+10;
1494           /* NAD: DAD=1, SAD=0 */
1495           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1496           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
1497           if (apdulen > 128 /* fixme: replace by ifsc */)
1498             {
1499               apdulen = 128;
1500               apdu_buf += 128;  
1501               apdu_buflen -= 128;
1502               tpdu[1] |= (1 << 5); /* Set more bit. */
1503             }
1504           tpdu[2] = apdulen;
1505           memcpy (tpdu+3, apdu, apdulen);
1506           tpdulen = 3 + apdulen;
1507           edc = compute_edc (tpdu, tpdulen, use_crc);
1508           if (use_crc)
1509             tpdu[tpdulen++] = (edc >> 8);
1510           tpdu[tpdulen++] = edc;
1511         }
1512
1513       msg[0] = PC_to_RDR_XfrBlock;
1514       msg[5] = 0; /* slot */
1515       msg[6] = seqno = handle->seqno++;
1516       msg[7] = 4; /* bBWI */
1517       msg[8] = 0; /* RFU */
1518       msg[9] = 0; /* RFU */
1519       set_msg_len (msg, tpdulen);
1520       msglen = 10 + tpdulen;
1521       last_tpdulen = tpdulen;
1522
1523       DEBUGOUT ("sending");
1524       for (i=0; i < msglen; i++)
1525         DEBUGOUT_CONT_1 (" %02X", msg[i]);
1526       DEBUGOUT_LF ();
1527
1528 #ifdef DEBUG_T1      
1529       fprintf (stderr, "T1: put %c-block seq=%d\n",
1530                ((msg[11] & 0xc0) == 0x80)? 'R' :
1531                (msg[11] & 0x80)? 'S' : 'I',
1532         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)));
1533 #endif  
1534
1535       rc = bulk_out (handle, msg, msglen);
1536       if (rc)
1537         return rc;
1538
1539       msg = recv_buffer;
1540       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
1541                     RDR_to_PC_DataBlock, seqno);
1542       if (rc)
1543         return rc;
1544       
1545       tpdu = msg + 10;
1546       tpdulen = msglen - 10;
1547       
1548       if (tpdulen < 4) 
1549         {
1550           usb_clear_halt (handle->idev, 0x82);
1551           return CCID_DRIVER_ERR_ABORTED; 
1552         }
1553 #ifdef DEBUG_T1
1554       fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
1555                ((msg[11] & 0xc0) == 0x80)? 'R' :
1556                (msg[11] & 0x80)? 'S' : 'I',
1557         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
1558                ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
1559                );
1560 #endif
1561
1562       if (!(tpdu[1] & 0x80))
1563         { /* This is an I-block. */
1564           retries = 0;
1565           if (sending)
1566             { /* last block sent was successful. */
1567               handle->t1_ns ^= 1;
1568               sending = 0;
1569             }
1570
1571           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
1572             { /* Reponse does not match our sequence number. */
1573               msg = send_buffer;
1574               tpdu = msg+10;
1575               /* NAD: DAD=1, SAD=0 */
1576               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1577               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
1578               tpdu[2] = 0;
1579               tpdulen = 3;
1580               edc = compute_edc (tpdu, tpdulen, use_crc);
1581               if (use_crc)
1582                 tpdu[tpdulen++] = (edc >> 8);
1583               tpdu[tpdulen++] = edc;
1584
1585               continue;
1586             }
1587
1588           handle->t1_nr ^= 1;
1589
1590           p = tpdu + 3; /* Skip the prologue field. */
1591           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
1592           /* fixme: verify the checksum. */
1593           if (resp)
1594             {
1595               if (n > maxresplen)
1596                 {
1597                   DEBUGOUT_2 ("provided buffer too short for received data "
1598                               "(%u/%u)\n",
1599                               (unsigned int)n, (unsigned int)maxresplen);
1600                   return CCID_DRIVER_ERR_INV_VALUE;
1601                 }
1602               
1603               memcpy (resp, p, n); 
1604               resp += n;
1605               *nresp += n;
1606               maxresplen -= n;
1607             }
1608           
1609           if (!(tpdu[1] & 0x20))
1610             return 0; /* No chaining requested - ready. */
1611           
1612           msg = send_buffer;
1613           tpdu = msg+10;
1614           /* NAD: DAD=1, SAD=0 */
1615           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1616           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
1617           tpdu[2] = 0;
1618           tpdulen = 3;
1619           edc = compute_edc (tpdu, tpdulen, use_crc);
1620           if (use_crc)
1621             tpdu[tpdulen++] = (edc >> 8);
1622           tpdu[tpdulen++] = edc;
1623         }
1624       else if ((tpdu[1] & 0xc0) == 0x80)
1625         { /* This is a R-block. */
1626           if ( (tpdu[1] & 0x0f)) 
1627             { /* Error: repeat last block */
1628               if (++retries > 3)
1629                 {
1630                   DEBUGOUT ("3 failed retries\n");
1631                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
1632                 }
1633               msg = send_buffer;
1634               tpdulen = last_tpdulen;
1635             }
1636           else if (sending && !!(tpdu[1] & 0x40) == handle->t1_ns)
1637             { /* Reponse does not match our sequence number. */
1638               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
1639               return CCID_DRIVER_ERR_CARD_IO_ERROR;
1640             }
1641           else if (sending)
1642             { /* Send next chunk. */
1643               retries = 0;
1644               msg = send_buffer;
1645               next_chunk = 1;
1646               handle->t1_ns ^= 1;
1647             }
1648           else
1649             {
1650               DEBUGOUT ("unexpected ACK R-block received\n");
1651               return CCID_DRIVER_ERR_CARD_IO_ERROR;
1652             }
1653         }
1654       else 
1655         { /* This is a S-block. */
1656           retries = 0;
1657           DEBUGOUT_2 ("T1 S-block %s received cmd=%d\n",
1658                       (tpdu[1] & 0x20)? "response": "request",
1659                       (tpdu[1] & 0x1f));
1660           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
1661             { /* Wait time extension request. */
1662               unsigned char bwi = tpdu[3];
1663               msg = send_buffer;
1664               tpdu = msg+10;
1665               /* NAD: DAD=1, SAD=0 */
1666               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1667               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
1668               tpdu[2] = 1;
1669               tpdu[3] = bwi;
1670               tpdulen = 4;
1671               edc = compute_edc (tpdu, tpdulen, use_crc);
1672               if (use_crc)
1673                 tpdu[tpdulen++] = (edc >> 8);
1674               tpdu[tpdulen++] = edc;
1675               DEBUGOUT_1 ("T1 waittime extension of bwi=%d\n", bwi);
1676             }
1677           else
1678             return CCID_DRIVER_ERR_CARD_IO_ERROR;
1679         }
1680     } /* end T=1 protocol loop. */
1681
1682   return 0;
1683 }
1684
1685
1686 /* Send the CCID Secure command to the reader.  APDU_BUF should contain the APDU   template.  PIN_MODE defines now the pin gets formatted:
1687    
1688      1 := The PIN is ASCII encoded and of variable length.  The
1689           length of the PIN entered will be put into Lc by the reader.
1690           The APDU should me made up of 4 bytes without Lc.
1691
1692    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
1693    may be used t enable usbale defaults.  PIN_PADLEN should be 0
1694    
1695    When called with RESP and NRESP set to NULL, the function will
1696    merely check whether the reader supports the secure command for the
1697    given APDU and PIN_MODE. */
1698 int
1699 ccid_transceive_secure (ccid_driver_t handle,
1700                         const unsigned char *apdu_buf, size_t apdu_buflen,
1701                         int pin_mode, int pinlen_min, int pinlen_max,
1702                         int pin_padlen, 
1703                         unsigned char *resp, size_t maxresplen, size_t *nresp)
1704 {
1705   int rc;
1706   unsigned char send_buffer[10+259], recv_buffer[10+259];
1707   unsigned char *msg, *tpdu, *p;
1708   size_t msglen, tpdulen, n;
1709   unsigned char seqno;
1710   int i;
1711   size_t dummy_nresp;
1712   int testmode;
1713
1714   testmode = !resp && !nresp;
1715
1716   if (!nresp)
1717     nresp = &dummy_nresp;
1718   *nresp = 0;
1719
1720   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
1721     ;
1722   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
1723     return CCID_DRIVER_ERR_NOT_SUPPORTED; /* Not yet by our code. */
1724   else
1725     return CCID_DRIVER_ERR_NOT_SUPPORTED;
1726     
1727   if (pin_mode != 1)
1728     return CCID_DRIVER_ERR_NOT_SUPPORTED;
1729
1730   if (pin_padlen != 0)
1731     return CCID_DRIVER_ERR_NOT_SUPPORTED;
1732
1733   if (!pinlen_min)
1734     pinlen_min = 1;
1735   if (!pinlen_max)
1736     pinlen_max = 25;
1737
1738   /* Note that the 25 is the maximum value the SPR532 allows.  */
1739   if (pinlen_min < 1 || pinlen_min > 25
1740       || pinlen_max < 1 || pinlen_max > 25 
1741       || pinlen_min > pinlen_max)
1742     return CCID_DRIVER_ERR_INV_VALUE;
1743
1744   /* We have only tested this with an SCM reader so better don't risk
1745      anything and do not allow the use with other readers. */
1746   if (handle->id_vendor != VENDOR_SCM)
1747     return CCID_DRIVER_ERR_NOT_SUPPORTED;
1748
1749   if (testmode)
1750     return 0; /* Success */
1751     
1752   msg = send_buffer;
1753   if (handle->id_vendor == VENDOR_SCM)
1754     {
1755       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
1756       rc = send_escape_cmd (handle, "\x80\x02\x00", 3);
1757       if (rc)
1758         return rc;
1759     }
1760
1761   msg[0] = PC_to_RDR_Secure;
1762   msg[5] = 0; /* slot */
1763   msg[6] = seqno = handle->seqno++;
1764   msg[7] = 4; /* bBWI */
1765   msg[8] = 0; /* RFU */
1766   msg[9] = 0; /* RFU */
1767   msg[10] = 0; /* Perform PIN verification. */
1768   msg[11] = 0; /* Timeout in seconds. */
1769   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
1770   if (handle->id_vendor == VENDOR_SCM)
1771     {
1772       /* For the SPR532 the next 2 bytes need to be zero.  We do this
1773          for all SCM product. Kudos to to Martin Paljak for this
1774          hint.  */
1775       msg[13] = msg[14] = 0;
1776     }
1777   else
1778     {
1779       msg[13] = 0x00; /* bmPINBlockString:
1780                          0 bits of pin length to insert. 
1781                          0 bytes of PIN block size.  */
1782       msg[14] = 0x00; /* bmPINLengthFormat:
1783                          Units are bytes, position is 0. */
1784     }
1785   msg[15] = pinlen_min;   /* wPINMaxExtraDigit-Minimum.  */
1786   msg[16] = pinlen_max;   /* wPINMaxExtraDigit-Maximum.  */
1787   msg[17] = 0x02; /* bEntryValidationCondition:
1788                      Validation key pressed */
1789   if (pinlen_min && pinlen_max && pinlen_min == pinlen_max)
1790     msg[17] |= 0x01; /* Max size reached.  */
1791   msg[18] = 0xff; /* bNumberMessage: Default. */
1792   msg[19] = 0x04; /* wLangId-High. */
1793   msg[20] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
1794   msg[21] = 0;    /* bMsgIndex. */
1795   /* bTeoProlog follows: */
1796   msg[22] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1797   msg[23] = ((handle->t1_ns & 1) << 6); /* I-block */
1798   msg[24] = 4; /* apdulen.  */
1799   /* APDU follows:  */
1800   msg[25] = apdu_buf[0]; /* CLA */
1801   msg[26] = apdu_buf[1]; /* INS */
1802   msg[27] = apdu_buf[2]; /* P1 */
1803   msg[28] = apdu_buf[3]; /* P2 */
1804   msglen = 29;
1805   set_msg_len (msg, msglen - 10);
1806
1807   DEBUGOUT ("sending");
1808   for (i=0; i < msglen; i++)
1809     DEBUGOUT_CONT_1 (" %02X", msg[i]);
1810   DEBUGOUT_LF ();
1811   
1812   rc = bulk_out (handle, msg, msglen);
1813   if (rc)
1814     return rc;
1815   
1816   msg = recv_buffer;
1817   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
1818                 RDR_to_PC_DataBlock, seqno);
1819   if (rc)
1820     return rc;
1821   
1822   tpdu = msg + 10;
1823   tpdulen = msglen - 10;
1824   
1825   if (tpdulen < 4) 
1826     {
1827       usb_clear_halt (handle->idev, 0x82);
1828       return CCID_DRIVER_ERR_ABORTED; 
1829     }
1830 #ifdef DEBUG_T1
1831   fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
1832            ((msg[11] & 0xc0) == 0x80)? 'R' :
1833            (msg[11] & 0x80)? 'S' : 'I',
1834            ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
1835            ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
1836            );
1837 #endif
1838
1839   if (!(tpdu[1] & 0x80))
1840     { /* This is an I-block. */
1841       /* Last block sent was successful. */
1842       handle->t1_ns ^= 1;
1843
1844       if (!!(tpdu[1] & 0x40) != handle->t1_nr)
1845         { /* Reponse does not match our sequence number. */
1846           DEBUGOUT ("I-block with wrong seqno received\n");
1847           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1848         }
1849
1850       handle->t1_nr ^= 1;
1851
1852       p = tpdu + 3; /* Skip the prologue field. */
1853       n = tpdulen - 3 - 1; /* Strip the epilogue field. */
1854       /* fixme: verify the checksum. */
1855       if (resp)
1856         {
1857           if (n > maxresplen)
1858             {
1859               DEBUGOUT_2 ("provided buffer too short for received data "
1860                           "(%u/%u)\n",
1861                           (unsigned int)n, (unsigned int)maxresplen);
1862               return CCID_DRIVER_ERR_INV_VALUE;
1863             }
1864               
1865           memcpy (resp, p, n); 
1866           resp += n;
1867           *nresp += n;
1868           maxresplen -= n;
1869         }
1870           
1871       if (!(tpdu[1] & 0x20))
1872         return 0; /* No chaining requested - ready. */
1873       
1874       DEBUGOUT ("chaining requested but not supported for Secure operation\n");
1875       return CCID_DRIVER_ERR_CARD_IO_ERROR;
1876     }
1877   else if ((tpdu[1] & 0xc0) == 0x80)
1878     { /* This is a R-block. */
1879       if ( (tpdu[1] & 0x0f)) 
1880         { /* Error: repeat last block */
1881           DEBUGOUT ("No retries supported for Secure operation\n");
1882           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1883         }
1884       else if (!!(tpdu[1] & 0x40) == handle->t1_ns)
1885         { /* Reponse does not match our sequence number. */
1886           DEBUGOUT ("R-block with wrong seqno received on more bit\n");
1887           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1888         }
1889       else
1890         { /* Send next chunk. */
1891           DEBUGOUT ("chaining not supported on Secure operation\n");
1892           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1893         }
1894     }
1895   else 
1896     { /* This is a S-block. */
1897       DEBUGOUT_2 ("T1 S-block %s received cmd=%d for Secure operation\n",
1898                   (tpdu[1] & 0x20)? "response": "request",
1899                   (tpdu[1] & 0x1f));
1900       return CCID_DRIVER_ERR_CARD_IO_ERROR;
1901     } 
1902
1903   return 0;
1904 }
1905
1906
1907
1908
1909 #ifdef TEST
1910
1911
1912 static void
1913 print_error (int err)
1914 {
1915   const char *p;
1916   char buf[50];
1917
1918   switch (err)
1919     {
1920     case 0: p = "success";
1921     case CCID_DRIVER_ERR_OUT_OF_CORE: p = "out of core"; break;
1922     case CCID_DRIVER_ERR_INV_VALUE: p = "invalid value"; break;
1923     case CCID_DRIVER_ERR_NO_DRIVER: p = "no driver"; break;
1924     case CCID_DRIVER_ERR_NOT_SUPPORTED: p = "not supported"; break;
1925     case CCID_DRIVER_ERR_LOCKING_FAILED: p = "locking failed"; break;
1926     case CCID_DRIVER_ERR_BUSY: p = "busy"; break;
1927     case CCID_DRIVER_ERR_NO_CARD: p = "no card"; break;
1928     case CCID_DRIVER_ERR_CARD_INACTIVE: p = "card inactive"; break;
1929     case CCID_DRIVER_ERR_CARD_IO_ERROR: p = "card I/O error"; break;
1930     case CCID_DRIVER_ERR_GENERAL_ERROR: p = "general error"; break;
1931     case CCID_DRIVER_ERR_NO_READER: p = "no reader"; break;
1932     case CCID_DRIVER_ERR_ABORTED: p = "aborted"; break;
1933     default: sprintf (buf, "0x%05x", err); p = buf; break;
1934     }
1935   fprintf (stderr, "operation failed: %s\n", p);
1936 }
1937
1938 static void
1939 print_data (const unsigned char *data, size_t length)
1940 {
1941   if (length >= 2)
1942     {
1943       fprintf (stderr, "operation status: %02X%02X\n",
1944                data[length-2], data[length-1]);
1945       length -= 2;
1946     }
1947   if (length)
1948     {
1949         fputs ("   returned data:", stderr);
1950         for (; length; length--, data++)
1951           fprintf (stderr, " %02X", *data);
1952         putc ('\n', stderr);
1953     }
1954 }
1955
1956 static void
1957 print_result (int rc, const unsigned char *data, size_t length)
1958 {
1959   if (rc)
1960     print_error (rc);
1961   else if (data)
1962     print_data (data, length);
1963 }
1964
1965 int
1966 main (int argc, char **argv)
1967 {
1968   int rc;
1969   ccid_driver_t ccid;
1970   unsigned int slotstat;
1971   unsigned char result[512];
1972   size_t resultlen;
1973   int no_pinpad = 0;
1974   int verify_123456 = 0;
1975   int did_verify = 0;
1976
1977   if (argc)
1978     {
1979       argc--;
1980       argv++;
1981     }
1982
1983   while (argc)
1984     {
1985       if ( !strcmp (*argv, "--list"))
1986         {
1987           char *p;
1988           p = ccid_get_reader_list ();
1989           if (!p)
1990             return 1;
1991           fputs (p, stderr);
1992           free (p);
1993           return 0;
1994         }
1995       else if ( !strcmp (*argv, "--debug"))
1996         {
1997           ccid_set_debug_level (1);
1998           argc--; argv++;
1999         }
2000       else if ( !strcmp (*argv, "--no-pinpad"))
2001         {
2002           no_pinpad = 1;
2003           argc--; argv++;
2004         }
2005       else if ( !strcmp (*argv, "--verify-123456"))
2006         {
2007           verify_123456 = 1;
2008           argc--; argv++;
2009         }
2010       else
2011         break;
2012     }
2013
2014   rc = ccid_open_reader (&ccid, argc? *argv:NULL);
2015   if (rc)
2016     return 1;
2017
2018   ccid_poll (ccid);
2019   fputs ("getting ATR ...\n", stderr);
2020   rc = ccid_get_atr (ccid, NULL, 0, NULL);
2021   if (rc)
2022     {
2023       print_error (rc);
2024       return 1;
2025     }
2026
2027   ccid_poll (ccid);
2028   fputs ("getting slot status ...\n", stderr);
2029   rc = ccid_slot_status (ccid, &slotstat);
2030   if (rc)
2031     {
2032       print_error (rc);
2033       return 1;
2034     }
2035
2036   ccid_poll (ccid);
2037
2038   fputs ("selecting application OpenPGP ....\n", stderr);
2039   {
2040     static unsigned char apdu[] = {
2041       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
2042     rc = ccid_transceive (ccid,
2043                           apdu, sizeof apdu,
2044                           result, sizeof result, &resultlen);
2045     print_result (rc, result, resultlen);
2046   }
2047   
2048
2049   ccid_poll (ccid);
2050
2051   fputs ("getting OpenPGP DO 0x65 ....\n", stderr);
2052   {
2053     static unsigned char apdu[] = { 0, 0xCA, 0, 0x65, 254 };
2054     rc = ccid_transceive (ccid, apdu, sizeof apdu,
2055                           result, sizeof result, &resultlen);
2056     print_result (rc, result, resultlen);
2057   }
2058
2059   if (!no_pinpad)
2060     {
2061     }
2062
2063   if (!no_pinpad)
2064     {
2065       static unsigned char apdu[] = { 0, 0x20, 0, 0x81 };
2066
2067       
2068       if (ccid_transceive_secure (ccid,
2069                                   apdu, sizeof apdu,
2070                                   1, 0, 0, 0,
2071                                   NULL, 0, NULL))
2072         fputs ("can't verify using a PIN-Pad reader\n", stderr);
2073       else
2074         {
2075           fputs ("verifying CHV1 using the PINPad ....\n", stderr);
2076           
2077           rc = ccid_transceive_secure (ccid,
2078                                        apdu, sizeof apdu,
2079                                        1, 0, 0, 0,
2080                                        result, sizeof result, &resultlen);
2081           print_result (rc, result, resultlen);
2082           did_verify = 1;
2083         }
2084     }
2085   
2086   if (verify_123456 && !did_verify)
2087     {
2088       fputs ("verifying that CHV1 is 123456....\n", stderr);
2089       {
2090         static unsigned char apdu[] = {0, 0x20, 0, 0x81,
2091                                        6, '1','2','3','4','5','6'};
2092         rc = ccid_transceive (ccid, apdu, sizeof apdu,
2093                               result, sizeof result, &resultlen);
2094         print_result (rc, result, resultlen);
2095       }
2096     }
2097
2098   if (!rc)
2099     {
2100       fputs ("getting OpenPGP DO 0x5E ....\n", stderr);
2101       {
2102         static unsigned char apdu[] = { 0, 0xCA, 0, 0x5E, 254 };
2103         rc = ccid_transceive (ccid, apdu, sizeof apdu,
2104                               result, sizeof result, &resultlen);
2105         print_result (rc, result, resultlen);
2106       }
2107     }
2108
2109   ccid_close_reader (ccid);
2110
2111   return 0;
2112 }
2113
2114 /*
2115  * Local Variables:
2116  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
2117  * End:
2118  */
2119 #endif /*TEST*/
2120 #endif /*HAVE_LIBUSB*/