Fixed the card removed with cached app bug. (Famous last fix).
[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   (void)handle;  /* Not yet implemented.  */
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 /* Return the ATR of the card.  This is not a cached value and thus an
1711    actual reset is done.  */
1712 int 
1713 ccid_get_atr (ccid_driver_t handle,
1714               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
1715 {
1716   int rc;
1717   int statusbits;
1718   unsigned char msg[100];
1719   unsigned char *tpdu;
1720   size_t msglen, tpdulen;
1721   unsigned char seqno;
1722   int use_crc = 0;
1723   unsigned int edc;
1724   int i;
1725   int tried_iso = 0;
1726   int got_param;
1727
1728   /* First check whether a card is available.  */
1729   rc = ccid_slot_status (handle, &statusbits);
1730   if (rc)
1731     return rc;
1732   if (statusbits == 2)
1733     return CCID_DRIVER_ERR_NO_CARD;
1734
1735   /* For an inactive and also for an active card, issue the PowerOn
1736      command to get the ATR.  */
1737  again:
1738   msg[0] = PC_to_RDR_IccPowerOn;
1739   msg[5] = 0; /* slot */
1740   msg[6] = seqno = handle->seqno++;
1741   msg[7] = 0; /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
1742   msg[8] = 0; /* RFU */
1743   msg[9] = 0; /* RFU */
1744   set_msg_len (msg, 0);
1745   msglen = 10;
1746
1747   rc = bulk_out (handle, msg, msglen);
1748   if (rc)
1749     return rc;
1750   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
1751                 seqno, 5000, 0);
1752   if (rc)
1753     return rc;
1754   if (!tried_iso && CCID_COMMAND_FAILED (msg) && CCID_ERROR_CODE (msg) == 0xbb
1755       && ((handle->id_vendor == VENDOR_CHERRY
1756            && handle->id_product == 0x0005)
1757           || (handle->id_vendor == VENDOR_GEMPC
1758               && handle->id_product == 0x4433)
1759           ))
1760     {
1761       tried_iso = 1;
1762       /* Try switching to ISO mode. */
1763       if (!send_escape_cmd (handle, (const unsigned char*)"\xF1\x01", 2,
1764                             NULL, 0, NULL))
1765         goto again;
1766     }
1767   else if (CCID_COMMAND_FAILED (msg))
1768     return CCID_DRIVER_ERR_CARD_IO_ERROR;
1769
1770
1771   handle->powered_off = 0;
1772   
1773   if (atr)
1774     {
1775       size_t n = msglen - 10;
1776
1777       if (n > maxatrlen)
1778         n = maxatrlen;
1779       memcpy (atr, msg+10, n);
1780       *atrlen = n;
1781     }
1782
1783   got_param = 0;
1784   msg[0] = PC_to_RDR_GetParameters;
1785   msg[5] = 0; /* slot */
1786   msg[6] = seqno = handle->seqno++;
1787   msg[7] = 0; /* RFU */
1788   msg[8] = 0; /* RFU */
1789   msg[9] = 0; /* RFU */
1790   set_msg_len (msg, 0);
1791   msglen = 10;
1792   rc = bulk_out (handle, msg, msglen);
1793   if (!rc)
1794     rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
1795                   seqno, 2000, 0);
1796   if (rc)
1797     DEBUGOUT ("GetParameters failed\n");
1798   else
1799     {
1800       DEBUGOUT ("GetParametes returned");
1801       for (i=0; i < msglen; i++)
1802         DEBUGOUT_CONT_1 (" %02X", msg[i]);
1803       DEBUGOUT_LF ();
1804       if (msglen >= 10)
1805         {
1806           DEBUGOUT_1 ("  protocol ..........: T=%d\n", msg[9]);
1807           if (msglen == 17 && msg[9] == 1)
1808             {
1809               DEBUGOUT_1 ("  bmFindexDindex ....: %02X\n", msg[10]);
1810               DEBUGOUT_1 ("  bmTCCKST1 .........: %02X\n", msg[11]);
1811               DEBUGOUT_1 ("  bGuardTimeT1 ......: %02X\n", msg[12]);
1812               DEBUGOUT_1 ("  bmWaitingIntegersT1: %02X\n", msg[13]);
1813               DEBUGOUT_1 ("  bClockStop ........: %02X\n", msg[14]);
1814               DEBUGOUT_1 ("  bIFSC .............: %d\n", msg[15]);
1815               DEBUGOUT_1 ("  bNadValue .........: %d\n", msg[16]);
1816               got_param = 1;
1817             }
1818         }
1819     }
1820
1821   /* Setup parameters to select T=1. */
1822   msg[0] = PC_to_RDR_SetParameters;
1823   msg[5] = 0; /* slot */
1824   msg[6] = seqno = handle->seqno++;
1825   msg[7] = 1; /* Select T=1. */
1826   msg[8] = 0; /* RFU */
1827   msg[9] = 0; /* RFU */
1828
1829   if (!got_param)
1830     {
1831       /* FIXME: Get those values from the ATR. */
1832       msg[10]= 0x01; /* Fi/Di */
1833       msg[11]= 0x10; /* LRC, direct convention. */
1834       msg[12]= 0;    /* Extra guardtime. */
1835       msg[13]= 0x41; /* BWI/CWI */
1836       msg[14]= 0;    /* No clock stoppping. */
1837       msg[15]= 254;  /* IFSC */
1838       msg[16]= 0;    /* Does not support non default NAD values. */
1839     }
1840   set_msg_len (msg, 7);
1841   msglen = 10 + 7;
1842
1843   DEBUGOUT ("sending");
1844   for (i=0; i < msglen; i++)
1845     DEBUGOUT_CONT_1 (" %02X", msg[i]);
1846   DEBUGOUT_LF ();
1847
1848   rc = bulk_out (handle, msg, msglen);
1849   if (rc)
1850     return rc;
1851   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
1852                 seqno, 5000, 0);
1853   if (rc)
1854     DEBUGOUT ("SetParameters failed (ignored)\n");
1855
1856   handle->t1_ns = 0;
1857   handle->t1_nr = 0;
1858
1859   /* Send an S-Block with our maximum IFSD to the CCID.  */
1860   if (!handle->apdu_level && !handle->auto_ifsd)
1861     {
1862       tpdu = msg+10;
1863       /* NAD: DAD=1, SAD=0 */
1864       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1865       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
1866       tpdu[2] = 1;
1867       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32; 
1868       tpdulen = 4;
1869       edc = compute_edc (tpdu, tpdulen, use_crc);
1870       if (use_crc)
1871         tpdu[tpdulen++] = (edc >> 8);
1872       tpdu[tpdulen++] = edc;
1873
1874       msg[0] = PC_to_RDR_XfrBlock;
1875       msg[5] = 0; /* slot */
1876       msg[6] = seqno = handle->seqno++;
1877       msg[7] = 0; 
1878       msg[8] = 0; /* RFU */
1879       msg[9] = 0; /* RFU */
1880       set_msg_len (msg, tpdulen);
1881       msglen = 10 + tpdulen;
1882
1883       DEBUGOUT ("sending");
1884       for (i=0; i < msglen; i++)
1885         DEBUGOUT_CONT_1 (" %02X", msg[i]);
1886       DEBUGOUT_LF ();
1887
1888       if (debug_level > 1)
1889         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
1890                       ((msg[11] & 0xc0) == 0x80)? 'R' :
1891                                 (msg[11] & 0x80)? 'S' : 'I',
1892                       ((msg[11] & 0x80)? !!(msg[11]& 0x10)
1893                                        : !!(msg[11] & 0x40)),
1894                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
1895
1896       rc = bulk_out (handle, msg, msglen);
1897       if (rc)
1898         return rc;
1899
1900
1901       rc = bulk_in (handle, msg, sizeof msg, &msglen,
1902                     RDR_to_PC_DataBlock, seqno, 5000, 0);
1903       if (rc)
1904         return rc;
1905       
1906       tpdu = msg + 10;
1907       tpdulen = msglen - 10;
1908       
1909       if (tpdulen < 4) 
1910         return CCID_DRIVER_ERR_ABORTED; 
1911
1912       if (debug_level > 1)
1913         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
1914                     ((msg[11] & 0xc0) == 0x80)? 'R' :
1915                               (msg[11] & 0x80)? 'S' : 'I',
1916                     ((msg[11] & 0x80)? !!(msg[11]& 0x10)
1917                                      : !!(msg[11] & 0x40)),
1918                     ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
1919                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
1920
1921       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
1922         {
1923           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
1924           return -1;
1925         }
1926       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
1927     }
1928
1929   return 0;
1930 }
1931
1932
1933 \f
1934
1935 static unsigned int 
1936 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
1937 {
1938   if (use_crc)
1939     {
1940       return 0x42; /* Not yet implemented. */
1941     }
1942   else
1943     {
1944       unsigned char crc = 0;
1945       
1946       for (; datalen; datalen--)
1947         crc ^= *data++;
1948       return crc;
1949     }
1950 }
1951
1952
1953 /* Helper for ccid_transceive used for APDU level exchanges.  */
1954 static int
1955 ccid_transceive_apdu_level (ccid_driver_t handle,
1956                             const unsigned char *apdu_buf, size_t apdu_buflen,
1957                             unsigned char *resp, size_t maxresplen,
1958                             size_t *nresp)
1959 {
1960   int rc;
1961   unsigned char send_buffer[10+261], recv_buffer[10+261];
1962   const unsigned char *apdu;
1963   size_t apdulen;
1964   unsigned char *msg;
1965   size_t msglen;
1966   unsigned char seqno;
1967   int i;
1968
1969   msg = send_buffer;
1970
1971   apdu = apdu_buf;
1972   apdulen = apdu_buflen;
1973   assert (apdulen);
1974
1975   /* The maximum length for a short APDU T=1 block is 261.  For an
1976      extended APDU T=1 block the maximum length 65544; however
1977      extended APDU exchange levele is not yet supported.  */
1978   if (apdulen > 261)
1979     return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
1980
1981   msg[0] = PC_to_RDR_XfrBlock;
1982   msg[5] = 0; /* slot */
1983   msg[6] = seqno = handle->seqno++;
1984   msg[7] = 4; /* bBWI */
1985   msg[8] = 0; /* RFU */
1986   msg[9] = 0; /* RFU */
1987   memcpy (msg+10, apdu, apdulen);
1988   set_msg_len (msg, apdulen);
1989   msglen = 10 + apdulen;
1990
1991   DEBUGOUT ("sending");
1992   for (i=0; i < msglen; i++)
1993     DEBUGOUT_CONT_1 (" %02X", msg[i]);
1994   DEBUGOUT_LF ();
1995   
1996   rc = bulk_out (handle, msg, msglen);
1997   if (rc)
1998     return rc;
1999
2000   msg = recv_buffer;
2001   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
2002                 RDR_to_PC_DataBlock, seqno, 5000, 0);
2003   if (rc)
2004     return rc;
2005       
2006   apdu = msg + 10;
2007   apdulen = msglen - 10;
2008       
2009   if (resp)
2010     {
2011       if (apdulen > maxresplen)
2012         {
2013           DEBUGOUT_2 ("provided buffer too short for received data "
2014                       "(%u/%u)\n",
2015                       (unsigned int)apdulen, (unsigned int)maxresplen);
2016           return CCID_DRIVER_ERR_INV_VALUE;
2017         }
2018       
2019       memcpy (resp, apdu, apdulen); 
2020       *nresp = apdulen;
2021     }
2022           
2023   return 0;
2024 }
2025
2026
2027
2028 /*
2029   Protocol T=1 overview
2030
2031   Block Structure:
2032            Prologue Field:
2033    1 byte     Node Address (NAD) 
2034    1 byte     Protocol Control Byte (PCB)
2035    1 byte     Length (LEN) 
2036            Information Field:
2037    0-254 byte APDU or Control Information (INF)
2038            Epilogue Field:
2039    1 byte     Error Detection Code (EDC)
2040
2041   NAD:  
2042    bit 7     unused
2043    bit 4..6  Destination Node Address (DAD)
2044    bit 3     unused
2045    bit 2..0  Source Node Address (SAD)
2046
2047    If node adresses are not used, SAD and DAD should be set to 0 on
2048    the first block sent to the card.  If they are used they should
2049    have different values (0 for one is okay); that first block sets up
2050    the addresses of the nodes.
2051
2052   PCB:
2053    Information Block (I-Block):
2054       bit 7    0
2055       bit 6    Sequence number (yep, that is modulo 2)
2056       bit 5    Chaining flag 
2057       bit 4..0 reserved
2058    Received-Ready Block (R-Block):
2059       bit 7    1
2060       bit 6    0
2061       bit 5    0
2062       bit 4    Sequence number
2063       bit 3..0  0 = no error
2064                 1 = EDC or parity error
2065                 2 = other error
2066                 other values are reserved
2067    Supervisory Block (S-Block):
2068       bit 7    1
2069       bit 6    1
2070       bit 5    clear=request,set=response
2071       bit 4..0  0 = resyncronisation request
2072                 1 = information field size request
2073                 2 = abort request
2074                 3 = extension of BWT request
2075                 4 = VPP error
2076                 other values are reserved
2077
2078 */
2079
2080 int
2081 ccid_transceive (ccid_driver_t handle,
2082                  const unsigned char *apdu_buf, size_t apdu_buflen,
2083                  unsigned char *resp, size_t maxresplen, size_t *nresp)
2084 {
2085   int rc;
2086   unsigned char send_buffer[10+259], recv_buffer[10+259];
2087   const unsigned char *apdu;
2088   size_t apdulen;
2089   unsigned char *msg, *tpdu, *p;
2090   size_t msglen, tpdulen, last_tpdulen, n;
2091   unsigned char seqno;
2092   int i;
2093   unsigned int edc;
2094   int use_crc = 0;
2095   size_t dummy_nresp;
2096   int next_chunk = 1;
2097   int sending = 1;
2098   int retries = 0;
2099
2100   if (!nresp)
2101     nresp = &dummy_nresp;
2102   *nresp = 0;
2103
2104   /* Smarter readers allow to send APDUs directly; divert here. */
2105   if (handle->apdu_level)
2106     return ccid_transceive_apdu_level (handle, apdu_buf, apdu_buflen,
2107                                        resp, maxresplen, nresp);
2108
2109   /* The other readers we support require sending TPDUs.  */
2110
2111   tpdulen = 0; /* Avoid compiler warning about no initialization. */
2112   msg = send_buffer;
2113   for (;;)
2114     {
2115       if (next_chunk)
2116         {
2117           next_chunk = 0;
2118
2119           apdu = apdu_buf;
2120           apdulen = apdu_buflen;
2121           assert (apdulen);
2122
2123           /* Construct an I-Block. */
2124           /* Fixme: I am not sure whether limiting the length to 259
2125              as per CCID spec is required.  The code blow chops the
2126              APDU anyway into 128 byte blocks.  Needs to be addressed
2127              when supporting extended length APDUs. */
2128           if (apdulen > 259)
2129             return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
2130
2131           tpdu = msg+10;
2132           /* NAD: DAD=1, SAD=0 */
2133           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2134           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
2135           if (apdulen > 128 /* fixme: replace by ifsc */)
2136             {
2137               apdulen = 128;
2138               apdu_buf += 128;  
2139               apdu_buflen -= 128;
2140               tpdu[1] |= (1 << 5); /* Set more bit. */
2141             }
2142           tpdu[2] = apdulen;
2143           memcpy (tpdu+3, apdu, apdulen);
2144           tpdulen = 3 + apdulen;
2145           edc = compute_edc (tpdu, tpdulen, use_crc);
2146           if (use_crc)
2147             tpdu[tpdulen++] = (edc >> 8);
2148           tpdu[tpdulen++] = edc;
2149         }
2150
2151       msg[0] = PC_to_RDR_XfrBlock;
2152       msg[5] = 0; /* slot */
2153       msg[6] = seqno = handle->seqno++;
2154       msg[7] = 4; /* bBWI */
2155       msg[8] = 0; /* RFU */
2156       msg[9] = 0; /* RFU */
2157       set_msg_len (msg, tpdulen);
2158       msglen = 10 + tpdulen;
2159       last_tpdulen = tpdulen;
2160
2161       DEBUGOUT ("sending");
2162       for (i=0; i < msglen; i++)
2163         DEBUGOUT_CONT_1 (" %02X", msg[i]);
2164       DEBUGOUT_LF ();
2165
2166       if (debug_level > 1)
2167           DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
2168                       ((msg[11] & 0xc0) == 0x80)? 'R' :
2169                                 (msg[11] & 0x80)? 'S' : 'I',
2170                       ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2171                                        : !!(msg[11] & 0x40)),
2172                       (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2173
2174       rc = bulk_out (handle, msg, msglen);
2175       if (rc)
2176         return rc;
2177
2178       msg = recv_buffer;
2179       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
2180                     RDR_to_PC_DataBlock, seqno, 5000, 0);
2181       if (rc)
2182         return rc;
2183       
2184       tpdu = msg + 10;
2185       tpdulen = msglen - 10;
2186       
2187       if (tpdulen < 4) 
2188         {
2189           usb_clear_halt (handle->idev, handle->ep_bulk_in);
2190           return CCID_DRIVER_ERR_ABORTED; 
2191         }
2192
2193       if (debug_level > 1)
2194         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
2195                     ((msg[11] & 0xc0) == 0x80)? 'R' :
2196                               (msg[11] & 0x80)? 'S' : 'I',
2197                     ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
2198                     ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
2199                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2200
2201       if (!(tpdu[1] & 0x80))
2202         { /* This is an I-block. */
2203           retries = 0;
2204           if (sending)
2205             { /* last block sent was successful. */
2206               handle->t1_ns ^= 1;
2207               sending = 0;
2208             }
2209
2210           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
2211             { /* Reponse does not match our sequence number. */
2212               msg = send_buffer;
2213               tpdu = msg+10;
2214               /* NAD: DAD=1, SAD=0 */
2215               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2216               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
2217               tpdu[2] = 0;
2218               tpdulen = 3;
2219               edc = compute_edc (tpdu, tpdulen, use_crc);
2220               if (use_crc)
2221                 tpdu[tpdulen++] = (edc >> 8);
2222               tpdu[tpdulen++] = edc;
2223
2224               continue;
2225             }
2226
2227           handle->t1_nr ^= 1;
2228
2229           p = tpdu + 3; /* Skip the prologue field. */
2230           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
2231           /* fixme: verify the checksum. */
2232           if (resp)
2233             {
2234               if (n > maxresplen)
2235                 {
2236                   DEBUGOUT_2 ("provided buffer too short for received data "
2237                               "(%u/%u)\n",
2238                               (unsigned int)n, (unsigned int)maxresplen);
2239                   return CCID_DRIVER_ERR_INV_VALUE;
2240                 }
2241               
2242               memcpy (resp, p, n); 
2243               resp += n;
2244               *nresp += n;
2245               maxresplen -= n;
2246             }
2247           
2248           if (!(tpdu[1] & 0x20))
2249             return 0; /* No chaining requested - ready. */
2250           
2251           msg = send_buffer;
2252           tpdu = msg+10;
2253           /* NAD: DAD=1, SAD=0 */
2254           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2255           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
2256           tpdu[2] = 0;
2257           tpdulen = 3;
2258           edc = compute_edc (tpdu, tpdulen, use_crc);
2259           if (use_crc)
2260             tpdu[tpdulen++] = (edc >> 8);
2261           tpdu[tpdulen++] = edc;
2262         }
2263       else if ((tpdu[1] & 0xc0) == 0x80)
2264         { /* This is a R-block. */
2265           if ( (tpdu[1] & 0x0f)) 
2266             { /* Error: repeat last block */
2267               if (++retries > 3)
2268                 {
2269                   DEBUGOUT ("3 failed retries\n");
2270                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
2271                 }
2272               msg = send_buffer;
2273               tpdulen = last_tpdulen;
2274             }
2275           else if (sending && !!(tpdu[1] & 0x10) == handle->t1_ns)
2276             { /* Response does not match our sequence number. */
2277               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
2278               return CCID_DRIVER_ERR_CARD_IO_ERROR;
2279             }
2280           else if (sending)
2281             { /* Send next chunk. */
2282               retries = 0;
2283               msg = send_buffer;
2284               next_chunk = 1;
2285               handle->t1_ns ^= 1;
2286             }
2287           else
2288             {
2289               DEBUGOUT ("unexpected ACK R-block received\n");
2290               return CCID_DRIVER_ERR_CARD_IO_ERROR;
2291             }
2292         }
2293       else 
2294         { /* This is a S-block. */
2295           retries = 0;
2296           DEBUGOUT_2 ("T=1 S-block %s received cmd=%d\n",
2297                       (tpdu[1] & 0x20)? "response": "request",
2298                       (tpdu[1] & 0x1f));
2299           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
2300             { /* Wait time extension request. */
2301               unsigned char bwi = tpdu[3];
2302               msg = send_buffer;
2303               tpdu = msg+10;
2304               /* NAD: DAD=1, SAD=0 */
2305               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2306               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
2307               tpdu[2] = 1;
2308               tpdu[3] = bwi;
2309               tpdulen = 4;
2310               edc = compute_edc (tpdu, tpdulen, use_crc);
2311               if (use_crc)
2312                 tpdu[tpdulen++] = (edc >> 8);
2313               tpdu[tpdulen++] = edc;
2314               DEBUGOUT_1 ("T=1 waittime extension of bwi=%d\n", bwi);
2315             }
2316           else
2317             return CCID_DRIVER_ERR_CARD_IO_ERROR;
2318         }
2319     } /* end T=1 protocol loop. */
2320
2321   return 0;
2322 }
2323
2324
2325 /* Send the CCID Secure command to the reader.  APDU_BUF should
2326    contain the APDU template.  PIN_MODE defines how the pin gets
2327    formatted:
2328    
2329      1 := The PIN is ASCII encoded and of variable length.  The
2330           length of the PIN entered will be put into Lc by the reader.
2331           The APDU should me made up of 4 bytes without Lc.
2332
2333    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
2334    may be used t enable reasonable defaults.  PIN_PADLEN should be 0.
2335    
2336    When called with RESP and NRESP set to NULL, the function will
2337    merely check whether the reader supports the secure command for the
2338    given APDU and PIN_MODE. */
2339 int
2340 ccid_transceive_secure (ccid_driver_t handle,
2341                         const unsigned char *apdu_buf, size_t apdu_buflen,
2342                         int pin_mode, int pinlen_min, int pinlen_max,
2343                         int pin_padlen, 
2344                         unsigned char *resp, size_t maxresplen, size_t *nresp)
2345 {
2346   int rc;
2347   unsigned char send_buffer[10+259], recv_buffer[10+259];
2348   unsigned char *msg, *tpdu, *p;
2349   size_t msglen, tpdulen, n;
2350   unsigned char seqno;
2351   int i;
2352   size_t dummy_nresp;
2353   int testmode;
2354   int cherry_mode = 0;
2355
2356   testmode = !resp && !nresp;
2357
2358   if (!nresp)
2359     nresp = &dummy_nresp;
2360   *nresp = 0;
2361
2362   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
2363     ;
2364   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
2365     return CCID_DRIVER_ERR_NOT_SUPPORTED; /* Not yet by our code. */
2366   else
2367     return CCID_DRIVER_ERR_NO_KEYPAD;
2368     
2369   if (pin_mode != 1)
2370     return CCID_DRIVER_ERR_NOT_SUPPORTED;
2371
2372   if (pin_padlen != 0)
2373     return CCID_DRIVER_ERR_NOT_SUPPORTED;
2374
2375   if (!pinlen_min)
2376     pinlen_min = 1;
2377   if (!pinlen_max)
2378     pinlen_max = 25;
2379
2380   /* Note that the 25 is the maximum value the SPR532 allows.  */
2381   if (pinlen_min < 1 || pinlen_min > 25
2382       || pinlen_max < 1 || pinlen_max > 25 
2383       || pinlen_min > pinlen_max)
2384     return CCID_DRIVER_ERR_INV_VALUE;
2385
2386   /* We have only tested a few readers so better don't risk anything
2387      and do not allow the use with other readers. */
2388   switch (handle->id_vendor)
2389     {
2390     case VENDOR_SCM:  /* Tested with SPR 532. */
2391     case VENDOR_KAAN: /* Tested with KAAN Advanced (1.02). */
2392       break;
2393     case VENDOR_CHERRY:
2394       /* The CHERRY XX44 keyboard echos an asterisk for each entered
2395          character on the keyboard channel.  We use a special variant
2396          of PC_to_RDR_Secure which directs these characters to the
2397          smart card's bulk-in channel.  We also need to append a zero
2398          Lc byte to the APDU.  It seems that it will be replaced with
2399          the actual length instead of being appended before the APDU
2400          is send to the card. */
2401       cherry_mode = 1;
2402       break;
2403     default:
2404      return CCID_DRIVER_ERR_NOT_SUPPORTED;
2405     }
2406
2407   if (testmode)
2408     return 0; /* Success */
2409     
2410   msg = send_buffer;
2411   if (handle->id_vendor == VENDOR_SCM)
2412     {
2413       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
2414       rc = send_escape_cmd (handle, (const unsigned char*)"\x80\x02\x00", 3,
2415                             NULL, 0, NULL);
2416       if (rc)
2417         return rc;
2418     }
2419
2420   msg[0] = cherry_mode? 0x89 : PC_to_RDR_Secure;
2421   msg[5] = 0; /* slot */
2422   msg[6] = seqno = handle->seqno++;
2423   msg[7] = 0; /* bBWI */
2424   msg[8] = 0; /* RFU */
2425   msg[9] = 0; /* RFU */
2426   msg[10] = 0; /* Perform PIN verification. */
2427   msg[11] = 0; /* Timeout in seconds. */
2428   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2429   if (handle->id_vendor == VENDOR_SCM)
2430     {
2431       /* For the SPR532 the next 2 bytes need to be zero.  We do this
2432          for all SCM products.  Kudos to Martin Paljak for this
2433          hint.  */
2434       msg[13] = msg[14] = 0;
2435     }
2436   else
2437     {
2438       msg[13] = 0x00; /* bmPINBlockString:
2439                          0 bits of pin length to insert. 
2440                          0 bytes of PIN block size.  */
2441       msg[14] = 0x00; /* bmPINLengthFormat:
2442                          Units are bytes, position is 0. */
2443     }
2444
2445   /* The following is a little endian word. */
2446   msg[15] = pinlen_max;   /* wPINMaxExtraDigit-Maximum.  */
2447   msg[16] = pinlen_min;   /* wPINMaxExtraDigit-Minimum.  */
2448
2449   msg[17] = 0x02; /* bEntryValidationCondition:
2450                      Validation key pressed */
2451   if (pinlen_min && pinlen_max && pinlen_min == pinlen_max)
2452     msg[17] |= 0x01; /* Max size reached.  */
2453   msg[18] = 0xff; /* bNumberMessage: Default. */
2454   msg[19] = 0x04; /* wLangId-High. */
2455   msg[20] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
2456   msg[21] = 0;    /* bMsgIndex. */
2457   /* bTeoProlog follows: */
2458   msg[22] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2459   msg[23] = ((handle->t1_ns & 1) << 6); /* I-block */
2460   msg[24] = 0; /* The apdulen will be filled in by the reader.  */
2461   /* APDU follows:  */
2462   msg[25] = apdu_buf[0]; /* CLA */
2463   msg[26] = apdu_buf[1]; /* INS */
2464   msg[27] = apdu_buf[2]; /* P1 */
2465   msg[28] = apdu_buf[3]; /* P2 */
2466   msglen = 29;
2467   if (cherry_mode)
2468     msg[msglen++] = 0;
2469   /* An EDC is not required. */
2470   set_msg_len (msg, msglen - 10);
2471
2472   DEBUGOUT ("sending");
2473   for (i=0; i < msglen; i++)
2474     DEBUGOUT_CONT_1 (" %02X", msg[i]);
2475   DEBUGOUT_LF ();
2476   
2477   rc = bulk_out (handle, msg, msglen);
2478   if (rc)
2479     return rc;
2480   
2481   msg = recv_buffer;
2482   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
2483                 RDR_to_PC_DataBlock, seqno, 30000, 0);
2484   if (rc)
2485     return rc;
2486   
2487   tpdu = msg + 10;
2488   tpdulen = msglen - 10;
2489
2490   if (handle->apdu_level)
2491     {
2492       if (resp)
2493         {
2494           if (tpdulen > maxresplen)
2495             {
2496               DEBUGOUT_2 ("provided buffer too short for received data "
2497                           "(%u/%u)\n",
2498                           (unsigned int)tpdulen, (unsigned int)maxresplen);
2499               return CCID_DRIVER_ERR_INV_VALUE;
2500             }
2501           
2502           memcpy (resp, tpdu, tpdulen); 
2503           *nresp = tpdulen;
2504         }
2505       return 0;
2506     }
2507   
2508   if (tpdulen < 4) 
2509     {
2510       usb_clear_halt (handle->idev, handle->ep_bulk_in);
2511       return CCID_DRIVER_ERR_ABORTED; 
2512     }
2513   if (debug_level > 1)
2514     DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
2515                 ((msg[11] & 0xc0) == 0x80)? 'R' :
2516                           (msg[11] & 0x80)? 'S' : 'I',
2517                 ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
2518                 ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
2519                 (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2520
2521   if (!(tpdu[1] & 0x80))
2522     { /* This is an I-block. */
2523       /* Last block sent was successful. */
2524       handle->t1_ns ^= 1;
2525
2526       if (!!(tpdu[1] & 0x40) != handle->t1_nr)
2527         { /* Reponse does not match our sequence number. */
2528           DEBUGOUT ("I-block with wrong seqno received\n");
2529           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2530         }
2531
2532       handle->t1_nr ^= 1;
2533
2534       p = tpdu + 3; /* Skip the prologue field. */
2535       n = tpdulen - 3 - 1; /* Strip the epilogue field. */
2536       /* fixme: verify the checksum. */
2537       if (resp)
2538         {
2539           if (n > maxresplen)
2540             {
2541               DEBUGOUT_2 ("provided buffer too short for received data "
2542                           "(%u/%u)\n",
2543                           (unsigned int)n, (unsigned int)maxresplen);
2544               return CCID_DRIVER_ERR_INV_VALUE;
2545             }
2546               
2547           memcpy (resp, p, n); 
2548           resp += n;
2549           *nresp += n;
2550           maxresplen -= n;
2551         }
2552           
2553       if (!(tpdu[1] & 0x20))
2554         return 0; /* No chaining requested - ready. */
2555       
2556       DEBUGOUT ("chaining requested but not supported for Secure operation\n");
2557       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2558     }
2559   else if ((tpdu[1] & 0xc0) == 0x80)
2560     { /* This is a R-block. */
2561       if ( (tpdu[1] & 0x0f)) 
2562         { /* Error: repeat last block */
2563           DEBUGOUT ("No retries supported for Secure operation\n");
2564           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2565         }
2566       else if (!!(tpdu[1] & 0x10) == handle->t1_ns)
2567         { /* Reponse does not match our sequence number. */
2568           DEBUGOUT ("R-block with wrong seqno received on more bit\n");
2569           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2570         }
2571       else
2572         { /* Send next chunk. */
2573           DEBUGOUT ("chaining not supported on Secure operation\n");
2574           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2575         }
2576     }
2577   else 
2578     { /* This is a S-block. */
2579       DEBUGOUT_2 ("T=1 S-block %s received cmd=%d for Secure operation\n",
2580                   (tpdu[1] & 0x20)? "response": "request",
2581                   (tpdu[1] & 0x1f));
2582       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2583     } 
2584
2585   return 0;
2586 }
2587
2588
2589
2590
2591 #ifdef TEST
2592
2593
2594 static void
2595 print_error (int err)
2596 {
2597   const char *p;
2598   char buf[50];
2599
2600   switch (err)
2601     {
2602     case 0: p = "success";
2603     case CCID_DRIVER_ERR_OUT_OF_CORE: p = "out of core"; break;
2604     case CCID_DRIVER_ERR_INV_VALUE: p = "invalid value"; break;
2605     case CCID_DRIVER_ERR_NO_DRIVER: p = "no driver"; break;
2606     case CCID_DRIVER_ERR_NOT_SUPPORTED: p = "not supported"; break;
2607     case CCID_DRIVER_ERR_LOCKING_FAILED: p = "locking failed"; break;
2608     case CCID_DRIVER_ERR_BUSY: p = "busy"; break;
2609     case CCID_DRIVER_ERR_NO_CARD: p = "no card"; break;
2610     case CCID_DRIVER_ERR_CARD_INACTIVE: p = "card inactive"; break;
2611     case CCID_DRIVER_ERR_CARD_IO_ERROR: p = "card I/O error"; break;
2612     case CCID_DRIVER_ERR_GENERAL_ERROR: p = "general error"; break;
2613     case CCID_DRIVER_ERR_NO_READER: p = "no reader"; break;
2614     case CCID_DRIVER_ERR_ABORTED: p = "aborted"; break;
2615     default: sprintf (buf, "0x%05x", err); p = buf; break;
2616     }
2617   fprintf (stderr, "operation failed: %s\n", p);
2618 }
2619
2620 static void
2621 print_data (const unsigned char *data, size_t length)
2622 {
2623   if (length >= 2)
2624     {
2625       fprintf (stderr, "operation status: %02X%02X\n",
2626                data[length-2], data[length-1]);
2627       length -= 2;
2628     }
2629   if (length)
2630     {
2631         fputs ("   returned data:", stderr);
2632         for (; length; length--, data++)
2633           fprintf (stderr, " %02X", *data);
2634         putc ('\n', stderr);
2635     }
2636 }
2637
2638 static void
2639 print_result (int rc, const unsigned char *data, size_t length)
2640 {
2641   if (rc)
2642     print_error (rc);
2643   else if (data)
2644     print_data (data, length);
2645 }
2646
2647 int
2648 main (int argc, char **argv)
2649 {
2650   int rc;
2651   ccid_driver_t ccid;
2652   int slotstat;
2653   unsigned char result[512];
2654   size_t resultlen;
2655   int no_pinpad = 0;
2656   int verify_123456 = 0;
2657   int did_verify = 0;
2658   int no_poll = 0;
2659
2660   if (argc)
2661     {
2662       argc--;
2663       argv++;
2664     }
2665
2666   while (argc)
2667     {
2668       if ( !strcmp (*argv, "--list"))
2669         {
2670           char *p;
2671           p = ccid_get_reader_list ();
2672           if (!p)
2673             return 1;
2674           fputs (p, stderr);
2675           free (p);
2676           return 0;
2677         }
2678       else if ( !strcmp (*argv, "--debug"))
2679         {
2680           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
2681           argc--; argv++;
2682         }
2683       else if ( !strcmp (*argv, "--no-poll"))
2684         {
2685           no_poll = 1;
2686           argc--; argv++;
2687         }
2688       else if ( !strcmp (*argv, "--no-pinpad"))
2689         {
2690           no_pinpad = 1;
2691           argc--; argv++;
2692         }
2693       else if ( !strcmp (*argv, "--verify-123456"))
2694         {
2695           verify_123456 = 1;
2696           argc--; argv++;
2697         }
2698       else
2699         break;
2700     }
2701
2702   rc = ccid_open_reader (&ccid, argc? *argv:NULL);
2703   if (rc)
2704     return 1;
2705
2706   if (!no_poll)
2707     ccid_poll (ccid);
2708   fputs ("getting ATR ...\n", stderr);
2709   rc = ccid_get_atr (ccid, NULL, 0, NULL);
2710   if (rc)
2711     {
2712       print_error (rc);
2713       return 1;
2714     }
2715
2716   if (!no_poll)
2717     ccid_poll (ccid);
2718   fputs ("getting slot status ...\n", stderr);
2719   rc = ccid_slot_status (ccid, &slotstat);
2720   if (rc)
2721     {
2722       print_error (rc);
2723       return 1;
2724     }
2725
2726   if (!no_poll)
2727     ccid_poll (ccid);
2728
2729   fputs ("selecting application OpenPGP ....\n", stderr);
2730   {
2731     static unsigned char apdu[] = {
2732       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
2733     rc = ccid_transceive (ccid,
2734                           apdu, sizeof apdu,
2735                           result, sizeof result, &resultlen);
2736     print_result (rc, result, resultlen);
2737   }
2738   
2739
2740   if (!no_poll)
2741     ccid_poll (ccid);
2742
2743   fputs ("getting OpenPGP DO 0x65 ....\n", stderr);
2744   {
2745     static unsigned char apdu[] = { 0, 0xCA, 0, 0x65, 254 };
2746     rc = ccid_transceive (ccid, apdu, sizeof apdu,
2747                           result, sizeof result, &resultlen);
2748     print_result (rc, result, resultlen);
2749   }
2750
2751   if (!no_pinpad)
2752     {
2753     }
2754
2755   if (!no_pinpad)
2756     {
2757       static unsigned char apdu[] = { 0, 0x20, 0, 0x81 };
2758
2759       
2760       if (ccid_transceive_secure (ccid,
2761                                   apdu, sizeof apdu,
2762                                   1, 0, 0, 0,
2763                                   NULL, 0, NULL))
2764         fputs ("can't verify using a PIN-Pad reader\n", stderr);
2765       else
2766         {
2767           fputs ("verifying CHV1 using the PINPad ....\n", stderr);
2768           
2769           rc = ccid_transceive_secure (ccid,
2770                                        apdu, sizeof apdu,
2771                                        1, 0, 0, 0,
2772                                        result, sizeof result, &resultlen);
2773           print_result (rc, result, resultlen);
2774           did_verify = 1;
2775         }
2776     }
2777   
2778   if (verify_123456 && !did_verify)
2779     {
2780       fputs ("verifying that CHV1 is 123456....\n", stderr);
2781       {
2782         static unsigned char apdu[] = {0, 0x20, 0, 0x81,
2783                                        6, '1','2','3','4','5','6'};
2784         rc = ccid_transceive (ccid, apdu, sizeof apdu,
2785                               result, sizeof result, &resultlen);
2786         print_result (rc, result, resultlen);
2787       }
2788     }
2789
2790   if (!rc)
2791     {
2792       fputs ("getting OpenPGP DO 0x5E ....\n", stderr);
2793       {
2794         static unsigned char apdu[] = { 0, 0xCA, 0, 0x5E, 254 };
2795         rc = ccid_transceive (ccid, apdu, sizeof apdu,
2796                               result, sizeof result, &resultlen);
2797         print_result (rc, result, resultlen);
2798       }
2799     }
2800
2801   ccid_close_reader (ccid);
2802
2803   return 0;
2804 }
2805
2806 /*
2807  * Local Variables:
2808  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
2809  * End:
2810  */
2811 #endif /*TEST*/
2812 #endif /*HAVE_LIBUSB*/