* keyring.c: Make some strings translatable.
[gnupg.git] / g10 / 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   handle->t1_ns = 0;
1311   handle->t1_nr = 0;
1312
1313   /* Send an S-Block with our maximun IFSD to the CCID.  */
1314   if (!handle->auto_ifsd)
1315     {
1316       tpdu = msg+10;
1317       /* NAD: DAD=1, SAD=0 */
1318       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1319       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
1320       tpdu[2] = 1;
1321       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32; 
1322       tpdulen = 4;
1323       edc = compute_edc (tpdu, tpdulen, use_crc);
1324       if (use_crc)
1325         tpdu[tpdulen++] = (edc >> 8);
1326       tpdu[tpdulen++] = edc;
1327
1328       msg[0] = PC_to_RDR_XfrBlock;
1329       msg[5] = 0; /* slot */
1330       msg[6] = seqno = handle->seqno++;
1331       msg[7] = 0; 
1332       msg[8] = 0; /* RFU */
1333       msg[9] = 0; /* RFU */
1334       set_msg_len (msg, tpdulen);
1335       msglen = 10 + tpdulen;
1336
1337       DEBUGOUT ("sending");
1338       for (i=0; i < msglen; i++)
1339         DEBUGOUT_CONT_1 (" %02X", msg[i]);
1340       DEBUGOUT_LF ();
1341
1342 #ifdef DEBUG_T1      
1343       fprintf (stderr, "T1: put %c-block seq=%d\n",
1344                ((msg[11] & 0xc0) == 0x80)? 'R' :
1345                (msg[11] & 0x80)? 'S' : 'I',
1346                ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)));
1347 #endif  
1348
1349       rc = bulk_out (handle, msg, msglen);
1350       if (rc)
1351         return rc;
1352
1353
1354       rc = bulk_in (handle, msg, sizeof msg, &msglen,
1355                     RDR_to_PC_DataBlock, seqno);
1356       if (rc)
1357         return rc;
1358       
1359       tpdu = msg + 10;
1360       tpdulen = msglen - 10;
1361       
1362       if (tpdulen < 4) 
1363         return CCID_DRIVER_ERR_ABORTED; 
1364
1365 #ifdef DEBUG_T1
1366       fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
1367                ((msg[11] & 0xc0) == 0x80)? 'R' :
1368                (msg[11] & 0x80)? 'S' : 'I',
1369                ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
1370                ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
1371                );
1372 #endif
1373       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
1374         {
1375           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
1376           return -1;
1377         }
1378       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
1379     }
1380
1381   return 0;
1382 }
1383
1384
1385 \f
1386
1387 static unsigned int 
1388 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
1389 {
1390   if (use_crc)
1391     {
1392       return 0x42; /* Not yet implemented. */
1393     }
1394   else
1395     {
1396       unsigned char crc = 0;
1397       
1398       for (; datalen; datalen--)
1399         crc ^= *data++;
1400       return crc;
1401     }
1402 }
1403
1404
1405 /*
1406   Protocol T=1 overview
1407
1408   Block Structure:
1409            Prologue Field:
1410    1 byte     Node Address (NAD) 
1411    1 byte     Protocol Control Byte (PCB)
1412    1 byte     Length (LEN) 
1413            Information Field:
1414    0-254 byte APDU or Control Information (INF)
1415            Epilogue Field:
1416    1 byte     Error Detection Code (EDC)
1417
1418   NAD:  
1419    bit 7     unused
1420    bit 4..6  Destination Node Address (DAD)
1421    bit 3     unused
1422    bit 2..0  Source Node Address (SAD)
1423
1424    If node adresses are not used, SAD and DAD should be set to 0 on
1425    the first block sent to the card.  If they are used they should
1426    have different values (0 for one is okay); that first block sets up
1427    the addresses of the nodes.
1428
1429   PCB:
1430    Information Block (I-Block):
1431       bit 7    0
1432       bit 6    Sequence number (yep, that is modulo 2)
1433       bit 5    Chaining flag 
1434       bit 4..0 reserved
1435    Received-Ready Block (R-Block):
1436       bit 7    1
1437       bit 6    0
1438       bit 5    0
1439       bit 4    Sequence number
1440       bit 3..0  0 = no error
1441                 1 = EDC or parity error
1442                 2 = other error
1443                 other values are reserved
1444    Supervisory Block (S-Block):
1445       bit 7    1
1446       bit 6    1
1447       bit 5    clear=request,set=response
1448       bit 4..0  0 = resyncronisation request
1449                 1 = information field size request
1450                 2 = abort request
1451                 3 = extension of BWT request
1452                 4 = VPP error
1453                 other values are reserved
1454
1455 */
1456
1457 int
1458 ccid_transceive (ccid_driver_t handle,
1459                  const unsigned char *apdu_buf, size_t apdu_buflen,
1460                  unsigned char *resp, size_t maxresplen, size_t *nresp)
1461 {
1462   int rc;
1463   unsigned char send_buffer[10+259], recv_buffer[10+259];
1464   const unsigned char *apdu;
1465   size_t apdulen;
1466   unsigned char *msg, *tpdu, *p;
1467   size_t msglen, tpdulen, last_tpdulen, n;
1468   unsigned char seqno;
1469   int i;
1470   unsigned int edc;
1471   int use_crc = 0;
1472   size_t dummy_nresp;
1473   int next_chunk = 1;
1474   int sending = 1;
1475   int retries = 0;
1476
1477   if (!nresp)
1478     nresp = &dummy_nresp;
1479   *nresp = 0;
1480
1481   tpdulen = 0; /* Avoid compiler warning about no initialization. */
1482   msg = send_buffer;
1483   for (;;)
1484     {
1485       if (next_chunk)
1486         {
1487           next_chunk = 0;
1488
1489           apdu = apdu_buf;
1490           apdulen = apdu_buflen;
1491           assert (apdulen);
1492
1493           /* Construct an I-Block. */
1494           if (apdulen > 254)
1495             return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
1496
1497           tpdu = msg+10;
1498           /* NAD: DAD=1, SAD=0 */
1499           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1500           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
1501           if (apdulen > 128 /* fixme: replace by ifsc */)
1502             {
1503               apdulen = 128;
1504               apdu_buf += 128;  
1505               apdu_buflen -= 128;
1506               tpdu[1] |= (1 << 5); /* Set more bit. */
1507             }
1508           tpdu[2] = apdulen;
1509           memcpy (tpdu+3, apdu, apdulen);
1510           tpdulen = 3 + apdulen;
1511           edc = compute_edc (tpdu, tpdulen, use_crc);
1512           if (use_crc)
1513             tpdu[tpdulen++] = (edc >> 8);
1514           tpdu[tpdulen++] = edc;
1515         }
1516
1517       msg[0] = PC_to_RDR_XfrBlock;
1518       msg[5] = 0; /* slot */
1519       msg[6] = seqno = handle->seqno++;
1520       msg[7] = 4; /* bBWI */
1521       msg[8] = 0; /* RFU */
1522       msg[9] = 0; /* RFU */
1523       set_msg_len (msg, tpdulen);
1524       msglen = 10 + tpdulen;
1525       last_tpdulen = tpdulen;
1526
1527       DEBUGOUT ("sending");
1528       for (i=0; i < msglen; i++)
1529         DEBUGOUT_CONT_1 (" %02X", msg[i]);
1530       DEBUGOUT_LF ();
1531
1532 #ifdef DEBUG_T1      
1533       fprintf (stderr, "T1: put %c-block seq=%d\n",
1534                ((msg[11] & 0xc0) == 0x80)? 'R' :
1535                (msg[11] & 0x80)? 'S' : 'I',
1536         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)));
1537 #endif  
1538
1539       rc = bulk_out (handle, msg, msglen);
1540       if (rc)
1541         return rc;
1542
1543       msg = recv_buffer;
1544       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
1545                     RDR_to_PC_DataBlock, seqno);
1546       if (rc)
1547         return rc;
1548       
1549       tpdu = msg + 10;
1550       tpdulen = msglen - 10;
1551       
1552       if (tpdulen < 4) 
1553         {
1554           usb_clear_halt (handle->idev, 0x82);
1555           return CCID_DRIVER_ERR_ABORTED; 
1556         }
1557 #ifdef DEBUG_T1
1558       fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
1559                ((msg[11] & 0xc0) == 0x80)? 'R' :
1560                (msg[11] & 0x80)? 'S' : 'I',
1561         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
1562                ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
1563                );
1564 #endif
1565
1566       if (!(tpdu[1] & 0x80))
1567         { /* This is an I-block. */
1568           retries = 0;
1569           if (sending)
1570             { /* last block sent was successful. */
1571               handle->t1_ns ^= 1;
1572               sending = 0;
1573             }
1574
1575           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
1576             { /* Reponse does not match our sequence number. */
1577               msg = send_buffer;
1578               tpdu = msg+10;
1579               /* NAD: DAD=1, SAD=0 */
1580               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1581               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
1582               tpdu[2] = 0;
1583               tpdulen = 3;
1584               edc = compute_edc (tpdu, tpdulen, use_crc);
1585               if (use_crc)
1586                 tpdu[tpdulen++] = (edc >> 8);
1587               tpdu[tpdulen++] = edc;
1588
1589               continue;
1590             }
1591
1592           handle->t1_nr ^= 1;
1593
1594           p = tpdu + 3; /* Skip the prologue field. */
1595           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
1596           /* fixme: verify the checksum. */
1597           if (resp)
1598             {
1599               if (n > maxresplen)
1600                 {
1601                   DEBUGOUT_2 ("provided buffer too short for received data "
1602                               "(%u/%u)\n",
1603                               (unsigned int)n, (unsigned int)maxresplen);
1604                   return CCID_DRIVER_ERR_INV_VALUE;
1605                 }
1606               
1607               memcpy (resp, p, n); 
1608               resp += n;
1609               *nresp += n;
1610               maxresplen -= n;
1611             }
1612           
1613           if (!(tpdu[1] & 0x20))
1614             return 0; /* No chaining requested - ready. */
1615           
1616           msg = send_buffer;
1617           tpdu = msg+10;
1618           /* NAD: DAD=1, SAD=0 */
1619           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1620           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
1621           tpdu[2] = 0;
1622           tpdulen = 3;
1623           edc = compute_edc (tpdu, tpdulen, use_crc);
1624           if (use_crc)
1625             tpdu[tpdulen++] = (edc >> 8);
1626           tpdu[tpdulen++] = edc;
1627         }
1628       else if ((tpdu[1] & 0xc0) == 0x80)
1629         { /* This is a R-block. */
1630           if ( (tpdu[1] & 0x0f)) 
1631             { /* Error: repeat last block */
1632               if (++retries > 3)
1633                 {
1634                   DEBUGOUT ("3 failed retries\n");
1635                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
1636                 }
1637               msg = send_buffer;
1638               tpdulen = last_tpdulen;
1639             }
1640           else if (sending && !!(tpdu[1] & 0x40) == handle->t1_ns)
1641             { /* Reponse does not match our sequence number. */
1642               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
1643               return CCID_DRIVER_ERR_CARD_IO_ERROR;
1644             }
1645           else if (sending)
1646             { /* Send next chunk. */
1647               retries = 0;
1648               msg = send_buffer;
1649               next_chunk = 1;
1650               handle->t1_ns ^= 1;
1651             }
1652           else
1653             {
1654               DEBUGOUT ("unexpected ACK R-block received\n");
1655               return CCID_DRIVER_ERR_CARD_IO_ERROR;
1656             }
1657         }
1658       else 
1659         { /* This is a S-block. */
1660           retries = 0;
1661           DEBUGOUT_2 ("T1 S-block %s received cmd=%d\n",
1662                       (tpdu[1] & 0x20)? "response": "request",
1663                       (tpdu[1] & 0x1f));
1664           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
1665             { /* Wait time extension request. */
1666               unsigned char bwi = tpdu[3];
1667               msg = send_buffer;
1668               tpdu = msg+10;
1669               /* NAD: DAD=1, SAD=0 */
1670               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1671               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
1672               tpdu[2] = 1;
1673               tpdu[3] = bwi;
1674               tpdulen = 4;
1675               edc = compute_edc (tpdu, tpdulen, use_crc);
1676               if (use_crc)
1677                 tpdu[tpdulen++] = (edc >> 8);
1678               tpdu[tpdulen++] = edc;
1679               DEBUGOUT_1 ("T1 waittime extension of bwi=%d\n", bwi);
1680             }
1681           else
1682             return CCID_DRIVER_ERR_CARD_IO_ERROR;
1683         }
1684     } /* end T=1 protocol loop. */
1685
1686   return 0;
1687 }
1688
1689
1690 /* Send the CCID Secure command to the reader.  APDU_BUF should contain the APDU   template.  PIN_MODE defines now the pin gets formatted:
1691    
1692      1 := The PIN is ASCII encoded and of variable length.  The
1693           length of the PIN entered will be put into Lc by the reader.
1694           The APDU should me made up of 4 bytes without Lc.
1695
1696    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
1697    may be used t enable usbale defaults.  PIN_PADLEN should be 0
1698    
1699    When called with RESP and NRESP set to NULL, the function will
1700    merely check whether the reader supports the secure command for the
1701    given APDU and PIN_MODE. */
1702 int
1703 ccid_transceive_secure (ccid_driver_t handle,
1704                         const unsigned char *apdu_buf, size_t apdu_buflen,
1705                         int pin_mode, int pinlen_min, int pinlen_max,
1706                         int pin_padlen, 
1707                         unsigned char *resp, size_t maxresplen, size_t *nresp)
1708 {
1709   int rc;
1710   unsigned char send_buffer[10+259], recv_buffer[10+259];
1711   unsigned char *msg, *tpdu, *p;
1712   size_t msglen, tpdulen, n;
1713   unsigned char seqno;
1714   int i;
1715   size_t dummy_nresp;
1716   int testmode;
1717
1718   testmode = !resp && !nresp;
1719
1720   if (!nresp)
1721     nresp = &dummy_nresp;
1722   *nresp = 0;
1723
1724   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
1725     ;
1726   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
1727     return CCID_DRIVER_ERR_NOT_SUPPORTED; /* Not yet by our code. */
1728   else
1729     return CCID_DRIVER_ERR_NOT_SUPPORTED;
1730     
1731   if (pin_mode != 1)
1732     return CCID_DRIVER_ERR_NOT_SUPPORTED;
1733
1734   if (pin_padlen != 0)
1735     return CCID_DRIVER_ERR_NOT_SUPPORTED;
1736
1737   if (!pinlen_min)
1738     pinlen_min = 1;
1739   if (!pinlen_max)
1740     pinlen_max = 25;
1741
1742   /* Note that the 25 is the maximum value the SPR532 allows.  */
1743   if (pinlen_min < 1 || pinlen_min > 25
1744       || pinlen_max < 1 || pinlen_max > 25 
1745       || pinlen_min > pinlen_max)
1746     return CCID_DRIVER_ERR_INV_VALUE;
1747
1748   /* We have only tested this with an SCM reader so better don't risk
1749      anything and do not allow the use with other readers. */
1750   if (handle->id_vendor != VENDOR_SCM)
1751     return CCID_DRIVER_ERR_NOT_SUPPORTED;
1752
1753   if (testmode)
1754     return 0; /* Success */
1755     
1756   msg = send_buffer;
1757   if (handle->id_vendor == VENDOR_SCM)
1758     {
1759       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
1760       rc = send_escape_cmd (handle, "\x80\x02\x00", 3);
1761       if (rc)
1762         return rc;
1763     }
1764
1765   msg[0] = PC_to_RDR_Secure;
1766   msg[5] = 0; /* slot */
1767   msg[6] = seqno = handle->seqno++;
1768   msg[7] = 4; /* bBWI */
1769   msg[8] = 0; /* RFU */
1770   msg[9] = 0; /* RFU */
1771   msg[10] = 0; /* Perform PIN verification. */
1772   msg[11] = 0; /* Timeout in seconds. */
1773   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
1774   if (handle->id_vendor == VENDOR_SCM)
1775     {
1776       /* For the SPR532 the next 2 bytes need to be zero.  We do this
1777          for all SCM product. Kudos to to Martin Paljak for this
1778          hint.  */
1779       msg[13] = msg[14] = 0;
1780     }
1781   else
1782     {
1783       msg[13] = 0x00; /* bmPINBlockString:
1784                          0 bits of pin length to insert. 
1785                          0 bytes of PIN block size.  */
1786       msg[14] = 0x00; /* bmPINLengthFormat:
1787                          Units are bytes, position is 0. */
1788     }
1789   msg[15] = pinlen_min;   /* wPINMaxExtraDigit-Minimum.  */
1790   msg[16] = pinlen_max;   /* wPINMaxExtraDigit-Maximum.  */
1791   msg[17] = 0x02; /* bEntryValidationCondition:
1792                      Validation key pressed */
1793   if (pinlen_min && pinlen_max && pinlen_min == pinlen_max)
1794     msg[17] |= 0x01; /* Max size reached.  */
1795   msg[18] = 0xff; /* bNumberMessage: Default. */
1796   msg[19] = 0x04; /* wLangId-High. */
1797   msg[20] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
1798   msg[21] = 0;    /* bMsgIndex. */
1799   /* bTeoProlog follows: */
1800   msg[22] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1801   msg[23] = ((handle->t1_ns & 1) << 6); /* I-block */
1802   msg[24] = 4; /* apdulen.  */
1803   /* APDU follows:  */
1804   msg[25] = apdu_buf[0]; /* CLA */
1805   msg[26] = apdu_buf[1]; /* INS */
1806   msg[27] = apdu_buf[2]; /* P1 */
1807   msg[28] = apdu_buf[3]; /* P2 */
1808   msglen = 29;
1809   set_msg_len (msg, msglen - 10);
1810
1811   DEBUGOUT ("sending");
1812   for (i=0; i < msglen; i++)
1813     DEBUGOUT_CONT_1 (" %02X", msg[i]);
1814   DEBUGOUT_LF ();
1815   
1816   rc = bulk_out (handle, msg, msglen);
1817   if (rc)
1818     return rc;
1819   
1820   msg = recv_buffer;
1821   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
1822                 RDR_to_PC_DataBlock, seqno);
1823   if (rc)
1824     return rc;
1825   
1826   tpdu = msg + 10;
1827   tpdulen = msglen - 10;
1828   
1829   if (tpdulen < 4) 
1830     {
1831       usb_clear_halt (handle->idev, 0x82);
1832       return CCID_DRIVER_ERR_ABORTED; 
1833     }
1834 #ifdef DEBUG_T1
1835   fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
1836            ((msg[11] & 0xc0) == 0x80)? 'R' :
1837            (msg[11] & 0x80)? 'S' : 'I',
1838            ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
1839            ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
1840            );
1841 #endif
1842
1843   if (!(tpdu[1] & 0x80))
1844     { /* This is an I-block. */
1845       /* Last block sent was successful. */
1846       handle->t1_ns ^= 1;
1847
1848       if (!!(tpdu[1] & 0x40) != handle->t1_nr)
1849         { /* Reponse does not match our sequence number. */
1850           DEBUGOUT ("I-block with wrong seqno received\n");
1851           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1852         }
1853
1854       handle->t1_nr ^= 1;
1855
1856       p = tpdu + 3; /* Skip the prologue field. */
1857       n = tpdulen - 3 - 1; /* Strip the epilogue field. */
1858       /* fixme: verify the checksum. */
1859       if (resp)
1860         {
1861           if (n > maxresplen)
1862             {
1863               DEBUGOUT_2 ("provided buffer too short for received data "
1864                           "(%u/%u)\n",
1865                           (unsigned int)n, (unsigned int)maxresplen);
1866               return CCID_DRIVER_ERR_INV_VALUE;
1867             }
1868               
1869           memcpy (resp, p, n); 
1870           resp += n;
1871           *nresp += n;
1872           maxresplen -= n;
1873         }
1874           
1875       if (!(tpdu[1] & 0x20))
1876         return 0; /* No chaining requested - ready. */
1877       
1878       DEBUGOUT ("chaining requested but not supported for Secure operation\n");
1879       return CCID_DRIVER_ERR_CARD_IO_ERROR;
1880     }
1881   else if ((tpdu[1] & 0xc0) == 0x80)
1882     { /* This is a R-block. */
1883       if ( (tpdu[1] & 0x0f)) 
1884         { /* Error: repeat last block */
1885           DEBUGOUT ("No retries supported for Secure operation\n");
1886           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1887         }
1888       else if (!!(tpdu[1] & 0x40) == handle->t1_ns)
1889         { /* Reponse does not match our sequence number. */
1890           DEBUGOUT ("R-block with wrong seqno received on more bit\n");
1891           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1892         }
1893       else
1894         { /* Send next chunk. */
1895           DEBUGOUT ("chaining not supported on Secure operation\n");
1896           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1897         }
1898     }
1899   else 
1900     { /* This is a S-block. */
1901       DEBUGOUT_2 ("T1 S-block %s received cmd=%d for Secure operation\n",
1902                   (tpdu[1] & 0x20)? "response": "request",
1903                   (tpdu[1] & 0x1f));
1904       return CCID_DRIVER_ERR_CARD_IO_ERROR;
1905     } 
1906
1907   return 0;
1908 }
1909
1910
1911
1912
1913 #ifdef TEST
1914
1915
1916 static void
1917 print_error (int err)
1918 {
1919   const char *p;
1920   char buf[50];
1921
1922   switch (err)
1923     {
1924     case 0: p = "success";
1925     case CCID_DRIVER_ERR_OUT_OF_CORE: p = "out of core"; break;
1926     case CCID_DRIVER_ERR_INV_VALUE: p = "invalid value"; break;
1927     case CCID_DRIVER_ERR_NO_DRIVER: p = "no driver"; break;
1928     case CCID_DRIVER_ERR_NOT_SUPPORTED: p = "not supported"; break;
1929     case CCID_DRIVER_ERR_LOCKING_FAILED: p = "locking failed"; break;
1930     case CCID_DRIVER_ERR_BUSY: p = "busy"; break;
1931     case CCID_DRIVER_ERR_NO_CARD: p = "no card"; break;
1932     case CCID_DRIVER_ERR_CARD_INACTIVE: p = "card inactive"; break;
1933     case CCID_DRIVER_ERR_CARD_IO_ERROR: p = "card I/O error"; break;
1934     case CCID_DRIVER_ERR_GENERAL_ERROR: p = "general error"; break;
1935     case CCID_DRIVER_ERR_NO_READER: p = "no reader"; break;
1936     case CCID_DRIVER_ERR_ABORTED: p = "aborted"; break;
1937     default: sprintf (buf, "0x%05x", err); p = buf; break;
1938     }
1939   fprintf (stderr, "operation failed: %s\n", p);
1940 }
1941
1942 static void
1943 print_data (const unsigned char *data, size_t length)
1944 {
1945   if (length >= 2)
1946     {
1947       fprintf (stderr, "operation status: %02X%02X\n",
1948                data[length-2], data[length-1]);
1949       length -= 2;
1950     }
1951   if (length)
1952     {
1953         fputs ("   returned data:", stderr);
1954         for (; length; length--, data++)
1955           fprintf (stderr, " %02X", *data);
1956         putc ('\n', stderr);
1957     }
1958 }
1959
1960 static void
1961 print_result (int rc, const unsigned char *data, size_t length)
1962 {
1963   if (rc)
1964     print_error (rc);
1965   else if (data)
1966     print_data (data, length);
1967 }
1968
1969 int
1970 main (int argc, char **argv)
1971 {
1972   int rc;
1973   ccid_driver_t ccid;
1974   unsigned int slotstat;
1975   unsigned char result[512];
1976   size_t resultlen;
1977   int no_pinpad = 0;
1978   int verify_123456 = 0;
1979   int did_verify = 0;
1980
1981   if (argc)
1982     {
1983       argc--;
1984       argv++;
1985     }
1986
1987   while (argc)
1988     {
1989       if ( !strcmp (*argv, "--list"))
1990         {
1991           char *p;
1992           p = ccid_get_reader_list ();
1993           if (!p)
1994             return 1;
1995           fputs (p, stderr);
1996           free (p);
1997           return 0;
1998         }
1999       else if ( !strcmp (*argv, "--debug"))
2000         {
2001           ccid_set_debug_level (1);
2002           argc--; argv++;
2003         }
2004       else if ( !strcmp (*argv, "--no-pinpad"))
2005         {
2006           no_pinpad = 1;
2007           argc--; argv++;
2008         }
2009       else if ( !strcmp (*argv, "--verify-123456"))
2010         {
2011           verify_123456 = 1;
2012           argc--; argv++;
2013         }
2014       else
2015         break;
2016     }
2017
2018   rc = ccid_open_reader (&ccid, argc? *argv:NULL);
2019   if (rc)
2020     return 1;
2021
2022   ccid_poll (ccid);
2023   fputs ("getting ATR ...\n", stderr);
2024   rc = ccid_get_atr (ccid, NULL, 0, NULL);
2025   if (rc)
2026     {
2027       print_error (rc);
2028       return 1;
2029     }
2030
2031   ccid_poll (ccid);
2032   fputs ("getting slot status ...\n", stderr);
2033   rc = ccid_slot_status (ccid, &slotstat);
2034   if (rc)
2035     {
2036       print_error (rc);
2037       return 1;
2038     }
2039
2040   ccid_poll (ccid);
2041
2042   fputs ("selecting application OpenPGP ....\n", stderr);
2043   {
2044     static unsigned char apdu[] = {
2045       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
2046     rc = ccid_transceive (ccid,
2047                           apdu, sizeof apdu,
2048                           result, sizeof result, &resultlen);
2049     print_result (rc, result, resultlen);
2050   }
2051   
2052
2053   ccid_poll (ccid);
2054
2055   fputs ("getting OpenPGP DO 0x65 ....\n", stderr);
2056   {
2057     static unsigned char apdu[] = { 0, 0xCA, 0, 0x65, 254 };
2058     rc = ccid_transceive (ccid, apdu, sizeof apdu,
2059                           result, sizeof result, &resultlen);
2060     print_result (rc, result, resultlen);
2061   }
2062
2063   if (!no_pinpad)
2064     {
2065     }
2066
2067   if (!no_pinpad)
2068     {
2069       static unsigned char apdu[] = { 0, 0x20, 0, 0x81 };
2070
2071       
2072       if (ccid_transceive_secure (ccid,
2073                                   apdu, sizeof apdu,
2074                                   1, 0, 0, 0,
2075                                   NULL, 0, NULL))
2076         fputs ("can't verify using a PIN-Pad reader\n", stderr);
2077       else
2078         {
2079           fputs ("verifying CHV1 using the PINPad ....\n", stderr);
2080           
2081           rc = ccid_transceive_secure (ccid,
2082                                        apdu, sizeof apdu,
2083                                        1, 0, 0, 0,
2084                                        result, sizeof result, &resultlen);
2085           print_result (rc, result, resultlen);
2086           did_verify = 1;
2087         }
2088     }
2089   
2090   if (verify_123456 && !did_verify)
2091     {
2092       fputs ("verifying that CHV1 is 123456....\n", stderr);
2093       {
2094         static unsigned char apdu[] = {0, 0x20, 0, 0x81,
2095                                        6, '1','2','3','4','5','6'};
2096         rc = ccid_transceive (ccid, apdu, sizeof apdu,
2097                               result, sizeof result, &resultlen);
2098         print_result (rc, result, resultlen);
2099       }
2100     }
2101
2102   if (!rc)
2103     {
2104       fputs ("getting OpenPGP DO 0x5E ....\n", stderr);
2105       {
2106         static unsigned char apdu[] = { 0, 0xCA, 0, 0x5E, 254 };
2107         rc = ccid_transceive (ccid, apdu, sizeof apdu,
2108                               result, sizeof result, &resultlen);
2109         print_result (rc, result, resultlen);
2110       }
2111     }
2112
2113   ccid_close_reader (ccid);
2114
2115   return 0;
2116 }
2117
2118 /*
2119  * Local Variables:
2120  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
2121  * End:
2122  */
2123 #endif /*TEST*/
2124 #endif /*HAVE_LIBUSB*/