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