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