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