Make gpgconf aware of --p12-charset.
[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)
993         {
994           DEBUGOUT_2 ("failed to open `%s': %s\n",
995                      transports[i].name, strerror (errno));
996           continue;
997         }
998
999       rid = malloc (strlen (transports[i].name) + 30 + 10);
1000       if (!rid)
1001         {
1002           close (fd);
1003           free (rid_list);
1004           return -1; /* Error. */
1005         }
1006       sprintf (rid, "0000:%04X:%s:0", transports[i].type, transports[i].name);
1007       if (scan_mode)
1008         {
1009           DEBUGOUT_2 ("found CCID reader %d (ID=%s)\n", count, rid);
1010           p = malloc ((rid_list? strlen (rid_list):0) + 1 + strlen (rid) + 1);
1011           if (!p)
1012             {
1013               close (fd);
1014               free (rid_list);
1015               free (rid);
1016               return -1; /* Error. */
1017             }
1018           *p = 0;
1019           if (rid_list)
1020             {
1021               strcat (p, rid_list);
1022               free (rid_list);
1023             }
1024           strcat (p, rid);
1025           strcat (p, "\n");
1026           rid_list = p;
1027           ++count;
1028         }
1029       else if (!readerno ||
1030                (readerno < 0 && readerid && !strcmp (readerid, rid)))
1031         {
1032           /* Found requested device. */
1033           if (interface_number)
1034             *interface_number = transports[i].type;
1035           if (r_rid)
1036             *r_rid = rid;
1037           else
1038             free (rid);
1039           if (r_fd)
1040             *r_fd = fd;
1041           return 0; /* Okay, found device */
1042         }
1043       else /* This is not yet the reader we want. */
1044         {
1045           if (readerno >= 0)
1046             --readerno;
1047         }
1048       free (rid);
1049       close (fd);
1050     }
1051
1052   if (scan_mode)
1053     {
1054       *r_rid = rid_list;
1055       return 0;
1056     }
1057   else
1058     return -1;
1059 }
1060
1061
1062 /* Set the level of debugging to LEVEL and return the old level.  -1
1063    just returns the old level.  A level of 0 disables debugging, 1
1064    enables debugging, 2 enables additional tracing of the T=1
1065    protocol, other values are not yet defined. */
1066 int
1067 ccid_set_debug_level (int level)
1068 {
1069   int old = debug_level;
1070   if (level != -1)
1071     debug_level = level;
1072   return old;
1073 }
1074
1075
1076 char *
1077 ccid_get_reader_list (void)
1078 {
1079   char *reader_list;
1080
1081   if (!initialized_usb)
1082     {
1083       usb_init ();
1084       initialized_usb = 1;
1085     }
1086
1087   if (scan_or_find_devices (-1, NULL, &reader_list, NULL, NULL, NULL, NULL,
1088                             NULL, NULL, NULL, NULL, NULL))
1089     return NULL; /* Error. */
1090   return reader_list;
1091 }
1092
1093
1094 /* Open the reader with the internal number READERNO and return a 
1095    pointer to be used as handle in HANDLE.  Returns 0 on success. */
1096 int 
1097 ccid_open_reader (ccid_driver_t *handle, const char *readerid)
1098 {
1099   int rc = 0;
1100   struct usb_device *dev = NULL;
1101   usb_dev_handle *idev = NULL;
1102   int dev_fd = -1;
1103   char *rid = NULL;
1104   unsigned char *ifcdesc_extra = NULL;
1105   size_t ifcdesc_extra_len;
1106   int readerno;
1107   int ifc_no, ep_bulk_out, ep_bulk_in, ep_intr;
1108
1109   *handle = NULL;
1110
1111   if (!initialized_usb)
1112     {
1113       usb_init ();
1114       initialized_usb = 1;
1115     }
1116
1117   /* See whether we want to use the reader ID string or a reader
1118      number. A readerno of -1 indicates that the reader ID string is
1119      to be used. */
1120   if (readerid && strchr (readerid, ':'))
1121     readerno = -1; /* We want to use the readerid.  */
1122   else if (readerid)
1123     {
1124       readerno = atoi (readerid);
1125       if (readerno < 0)
1126         {
1127           DEBUGOUT ("no CCID readers found\n");
1128           rc = CCID_DRIVER_ERR_NO_READER;
1129           goto leave;
1130         }
1131     }
1132   else
1133     readerno = 0;  /* Default. */
1134
1135   if (scan_or_find_devices (readerno, readerid, &rid, &dev,
1136                             &ifcdesc_extra, &ifcdesc_extra_len,
1137                             &ifc_no, &ep_bulk_out, &ep_bulk_in, &ep_intr,
1138                             &idev, &dev_fd) )
1139     {
1140       if (readerno == -1)
1141         DEBUGOUT_1 ("no CCID reader with ID %s\n", readerid );
1142       else
1143         DEBUGOUT_1 ("no CCID reader with number %d\n", readerno );
1144       rc = CCID_DRIVER_ERR_NO_READER;
1145       goto leave;
1146     }
1147
1148   /* Okay, this is a CCID reader. */
1149   *handle = calloc (1, sizeof **handle);
1150   if (!*handle)
1151     {
1152       DEBUGOUT ("out of memory\n");
1153       rc = CCID_DRIVER_ERR_OUT_OF_CORE;
1154       goto leave;
1155     }
1156   (*handle)->rid = rid;
1157   if (idev) /* Regular USB transport. */
1158     {
1159       (*handle)->idev = idev;
1160       (*handle)->dev_fd = -1;
1161       (*handle)->id_vendor = dev->descriptor.idVendor;
1162       (*handle)->id_product = dev->descriptor.idProduct;
1163       (*handle)->bcd_device = dev->descriptor.bcdDevice;
1164       (*handle)->ifc_no = ifc_no;
1165       (*handle)->ep_bulk_out = ep_bulk_out;
1166       (*handle)->ep_bulk_in = ep_bulk_in;
1167       (*handle)->ep_intr = ep_intr;
1168     }
1169   else if (dev_fd != -1) /* Device transport. */
1170     {
1171       (*handle)->idev = NULL;
1172       (*handle)->dev_fd = dev_fd;
1173       (*handle)->id_vendor = 0;  /* Magic vendor for special transport. */
1174       (*handle)->id_product = ifc_no; /* Transport type */
1175       prepare_special_transport (*handle);
1176     }
1177   else
1178     {
1179       assert (!"no transport"); /* Bug. */
1180     }
1181
1182   DEBUGOUT_2 ("using CCID reader %d (ID=%s)\n",  readerno, rid );
1183
1184   if (idev)
1185     {
1186       if (parse_ccid_descriptor (*handle, ifcdesc_extra, ifcdesc_extra_len))
1187         {
1188           DEBUGOUT ("device not supported\n");
1189           rc = CCID_DRIVER_ERR_NO_READER;
1190           goto leave;
1191         }
1192       
1193       rc = usb_claim_interface (idev, ifc_no);
1194       if (rc)
1195         {
1196           DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
1197           rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1198           goto leave;
1199         }
1200     }
1201
1202  leave:
1203   free (ifcdesc_extra);
1204   if (rc)
1205     {
1206       free (rid);
1207       if (idev)
1208         usb_close (idev);
1209       if (dev_fd != -1)
1210         close (dev_fd);
1211       free (*handle);
1212       *handle = NULL;
1213     }
1214
1215   return rc;
1216 }
1217
1218
1219 static void
1220 do_close_reader (ccid_driver_t handle)
1221 {
1222   int rc;
1223   unsigned char msg[100];
1224   size_t msglen;
1225   unsigned char seqno;
1226   
1227   if (!handle->powered_off)
1228     {
1229       msg[0] = PC_to_RDR_IccPowerOff;
1230       msg[5] = 0; /* slot */
1231       msg[6] = seqno = handle->seqno++;
1232       msg[7] = 0; /* RFU */
1233       msg[8] = 0; /* RFU */
1234       msg[9] = 0; /* RFU */
1235       set_msg_len (msg, 0);
1236       msglen = 10;
1237       
1238       rc = bulk_out (handle, msg, msglen);
1239       if (!rc)
1240         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
1241                  seqno, 2000, 0);
1242       handle->powered_off = 1;
1243     }
1244   if (handle->idev)
1245     {
1246       usb_release_interface (handle->idev, handle->ifc_no);
1247       usb_close (handle->idev);
1248       handle->idev = NULL;
1249     }
1250   if (handle->dev_fd != -1)
1251     {
1252       close (handle->dev_fd);
1253       handle->dev_fd = -1;
1254     }
1255 }
1256
1257
1258 /* Reset a reader on HANDLE.  This is useful in case a reader has been
1259    plugged of and inserted at a different port.  By resetting the
1260    handle, the same reader will be get used.  Note, that on error the
1261    handle won't get released. 
1262
1263    This does not return an ATR, so ccid_get_atr should be called right
1264    after this one.
1265 */
1266 int 
1267 ccid_shutdown_reader (ccid_driver_t handle)
1268 {
1269   int rc = 0;
1270   struct usb_device *dev = NULL;
1271   usb_dev_handle *idev = NULL;
1272   unsigned char *ifcdesc_extra = NULL;
1273   size_t ifcdesc_extra_len;
1274   int ifc_no, ep_bulk_out, ep_bulk_in, ep_intr;
1275
1276   if (!handle || !handle->rid)
1277     return CCID_DRIVER_ERR_INV_VALUE;
1278
1279   do_close_reader (handle);
1280
1281   if (scan_or_find_devices (-1, handle->rid, NULL, &dev,
1282                             &ifcdesc_extra, &ifcdesc_extra_len,
1283                             &ifc_no, &ep_bulk_out, &ep_bulk_in, &ep_intr,
1284                             &idev, NULL) || !idev)
1285     {
1286       DEBUGOUT_1 ("no CCID reader with ID %s\n", handle->rid);
1287       return CCID_DRIVER_ERR_NO_READER;
1288     }
1289
1290   if (idev)
1291     {
1292       handle->idev = idev;
1293       handle->ifc_no = ifc_no;
1294       handle->ep_bulk_out = ep_bulk_out;
1295       handle->ep_bulk_in = ep_bulk_in;
1296       handle->ep_intr = ep_intr;
1297
1298       if (parse_ccid_descriptor (handle, ifcdesc_extra, ifcdesc_extra_len))
1299         {
1300           DEBUGOUT ("device not supported\n");
1301           rc = CCID_DRIVER_ERR_NO_READER;
1302           goto leave;
1303         }
1304       
1305       rc = usb_claim_interface (idev, ifc_no);
1306       if (rc)
1307         {
1308           DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
1309           rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1310           goto leave;
1311         }
1312     }
1313
1314  leave:
1315   free (ifcdesc_extra);
1316   if (rc)
1317     {
1318       if (handle->idev)
1319         usb_close (handle->idev);
1320       handle->idev = NULL;
1321       if (handle->dev_fd != -1)
1322         close (handle->dev_fd);
1323       handle->dev_fd = -1;
1324     }
1325
1326   return rc;
1327
1328 }
1329
1330
1331 /* Close the reader HANDLE. */
1332 int 
1333 ccid_close_reader (ccid_driver_t handle)
1334 {
1335   if (!handle || (!handle->idev && handle->dev_fd == -1))
1336     return 0;
1337
1338   do_close_reader (handle);
1339   free (handle->rid);
1340   free (handle);
1341   return 0;
1342 }
1343
1344
1345 /* Return False if a card is present and powered. */
1346 int
1347 ccid_check_card_presence (ccid_driver_t handle)
1348 {
1349
1350   return -1;
1351 }
1352
1353
1354 /* Write NBYTES of BUF to file descriptor FD. */
1355 static int
1356 writen (int fd, const void *buf, size_t nbytes)
1357 {
1358   size_t nleft = nbytes;
1359   int nwritten;
1360   
1361   while (nleft > 0)
1362     {
1363       nwritten = write (fd, buf, nleft);
1364       if (nwritten < 0)
1365         {
1366           if (errno == EINTR)
1367             nwritten = 0;
1368           else
1369             return -1;
1370         }
1371       nleft -= nwritten;
1372       buf = (const char*)buf + nwritten;
1373     }
1374     
1375   return 0;
1376 }
1377
1378
1379 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
1380    Returns 0 on success. */
1381 static int
1382 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen)
1383 {
1384   int rc;
1385
1386   if (handle->idev)
1387     {
1388       rc = usb_bulk_write (handle->idev, 
1389                            handle->ep_bulk_out,
1390                            (char*)msg, msglen,
1391                            1000 /* ms timeout */);
1392       if (rc == msglen)
1393         return 0;
1394       if (rc == -1)
1395         DEBUGOUT_1 ("usb_bulk_write error: %s\n", strerror (errno));
1396       else
1397         DEBUGOUT_1 ("usb_bulk_write failed: %d\n", rc);
1398     }
1399   else
1400     {
1401       rc = writen (handle->dev_fd, msg, msglen);
1402       if (!rc)
1403         return 0;
1404       DEBUGOUT_2 ("writen to %d failed: %s\n",
1405                   handle->dev_fd, strerror (errno));
1406       
1407     }
1408   return CCID_DRIVER_ERR_CARD_IO_ERROR;
1409 }
1410
1411
1412 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
1413    BUFFER and return the actual read number if bytes in NREAD. SEQNO
1414    is the sequence number used to send the request and EXPECTED_TYPE
1415    the type of message we expect. Does checks on the ccid
1416    header. TIMEOUT is the timeout value in ms. NO_DEBUG may be set to
1417    avoid debug messages in case of no error. Returns 0 on success. */
1418 static int
1419 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
1420          size_t *nread, int expected_type, int seqno, int timeout,
1421          int no_debug)
1422 {
1423   int i, rc;
1424   size_t msglen;
1425
1426   /* Fixme: The next line for the current Valgrind without support
1427      for USB IOCTLs. */
1428   memset (buffer, 0, length);
1429  retry:
1430   if (handle->idev)
1431     {
1432       rc = usb_bulk_read (handle->idev, 
1433                           handle->ep_bulk_in,
1434                           (char*)buffer, length,
1435                           timeout);
1436       if (rc < 0)
1437         {
1438           DEBUGOUT_1 ("usb_bulk_read error: %s\n", strerror (errno));
1439           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1440         }
1441       *nread = msglen = rc;
1442     }
1443   else
1444     {
1445       rc = read (handle->dev_fd, buffer, length);
1446       if (rc < 0)
1447         {
1448           DEBUGOUT_2 ("read from %d failed: %s\n",
1449                       handle->dev_fd, strerror (errno));
1450           return CCID_DRIVER_ERR_CARD_IO_ERROR;
1451         }
1452       *nread = msglen = rc;
1453     }
1454
1455
1456   if (msglen < 10)
1457     {
1458       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
1459       return CCID_DRIVER_ERR_INV_VALUE;
1460     }
1461   if (buffer[5] != 0)    
1462     {
1463       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
1464       return CCID_DRIVER_ERR_INV_VALUE;
1465     }
1466   if (buffer[6] != seqno)    
1467     {
1468       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
1469                   seqno, buffer[6]);
1470       return CCID_DRIVER_ERR_INV_VALUE;
1471     }
1472
1473   /* We need to handle the time extension request before we check that
1474      we go the expected message type.  This is in particular required
1475      for the Cherry keyboard which sends a time extension request for
1476      each key hit.  */
1477   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
1478     { 
1479       /* Card present and active, time extension requested. */
1480       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
1481                   buffer[7], buffer[8]);
1482       goto retry;
1483     }
1484
1485   if (buffer[0] != expected_type)
1486     {
1487       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
1488       return CCID_DRIVER_ERR_INV_VALUE;
1489     }
1490
1491
1492   if (!no_debug)
1493     {
1494       DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n"
1495                   "               data:",  buffer[7], buffer[8], buffer[9] );
1496       for (i=10; i < msglen; i++)
1497         DEBUGOUT_CONT_1 (" %02X", buffer[i]);
1498       DEBUGOUT_LF ();
1499     }
1500   if (CCID_COMMAND_FAILED (buffer))
1501     print_command_failed (buffer);
1502
1503   /* Check whether a card is at all available.  Note: If you add new
1504      error codes here, check whether they need to be ignored in
1505      send_escape_cmd. */
1506   switch ((buffer[7] & 0x03))
1507     {
1508     case 0: /* no error */ break;
1509     case 1: return CCID_DRIVER_ERR_CARD_INACTIVE;
1510     case 2: return CCID_DRIVER_ERR_NO_CARD;
1511     case 3: /* RFU */ break;
1512     }
1513   return 0;
1514 }
1515
1516
1517 /* Note that this function won't return the error codes NO_CARD or
1518    CARD_INACTIVE.  IF RESULT is not NULL, the result from the
1519    operation will get returned in RESULT and its length in RESULTLEN.
1520    If the response is larger than RESULTMAX, an error is returned and
1521    the required buffer length returned in RESULTLEN.  */
1522 static int 
1523 send_escape_cmd (ccid_driver_t handle,
1524                  const unsigned char *data, size_t datalen,
1525                  unsigned char *result, size_t resultmax, size_t *resultlen)
1526 {
1527   int i, rc;
1528   unsigned char msg[100];
1529   size_t msglen;
1530   unsigned char seqno;
1531
1532   if (resultlen)
1533     *resultlen = 0;
1534
1535   if (datalen > sizeof msg - 10)
1536     return CCID_DRIVER_ERR_INV_VALUE; /* Escape data too large.  */
1537
1538   msg[0] = PC_to_RDR_Escape;
1539   msg[5] = 0; /* slot */
1540   msg[6] = seqno = handle->seqno++;
1541   msg[7] = 0; /* RFU */
1542   msg[8] = 0; /* RFU */
1543   msg[9] = 0; /* RFU */
1544   memcpy (msg+10, data, datalen);
1545   msglen = 10 + datalen;
1546   set_msg_len (msg, datalen);
1547
1548   DEBUGOUT ("sending");
1549   for (i=0; i < msglen; i++)
1550     DEBUGOUT_CONT_1 (" %02X", msg[i]);
1551   DEBUGOUT_LF ();
1552   rc = bulk_out (handle, msg, msglen);
1553   if (rc)
1554     return rc;
1555   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Escape,
1556                 seqno, 5000, 0);
1557   if (result)
1558     switch (rc)
1559       {
1560         /* We need to ignore certain errorcode here. */
1561       case 0:
1562       case CCID_DRIVER_ERR_CARD_INACTIVE:
1563       case CCID_DRIVER_ERR_NO_CARD:
1564         {
1565           if (msglen > resultmax)
1566             rc = CCID_DRIVER_ERR_INV_VALUE; /* Response too large. */
1567           else
1568             {
1569               memcpy (result, msg, msglen);
1570               *resultlen = msglen;
1571             }
1572           rc = 0;
1573         }
1574         break;
1575       default:
1576         break;
1577       }
1578   
1579   return rc;
1580 }
1581
1582
1583 int
1584 ccid_transceive_escape (ccid_driver_t handle,
1585                         const unsigned char *data, size_t datalen,
1586                         unsigned char *resp, size_t maxresplen, size_t *nresp)
1587 {
1588   return send_escape_cmd (handle, data, datalen, resp, maxresplen, nresp);
1589 }
1590
1591
1592
1593 /* experimental */
1594 int
1595 ccid_poll (ccid_driver_t handle)
1596 {
1597   int rc;
1598   unsigned char msg[10];
1599   size_t msglen;
1600   int i, j;
1601
1602   if (handle->idev)
1603     {
1604       rc = usb_bulk_read (handle->idev, 
1605                           handle->ep_intr,
1606                           (char*)msg, sizeof msg,
1607                           0 /* ms timeout */ );
1608       if (rc < 0 && errno == ETIMEDOUT)
1609         return 0;
1610     }
1611   else 
1612     return 0;
1613
1614   if (rc < 0)
1615     {
1616       DEBUGOUT_1 ("usb_intr_read error: %s\n", strerror (errno));
1617       return CCID_DRIVER_ERR_CARD_IO_ERROR;
1618     }
1619
1620   msglen = rc;
1621   rc = 0;
1622
1623   if (msglen < 1)
1624     {
1625       DEBUGOUT ("intr-in msg too short\n");
1626       return CCID_DRIVER_ERR_INV_VALUE;
1627     }
1628
1629   if (msg[0] == RDR_to_PC_NotifySlotChange)
1630     {
1631       DEBUGOUT ("notify slot change:");
1632       for (i=1; i < msglen; i++)
1633         for (j=0; j < 4; j++)
1634           DEBUGOUT_CONT_3 (" %d:%c%c",
1635                            (i-1)*4+j, 
1636                            (msg[i] & (1<<(j*2)))? 'p':'-',
1637                            (msg[i] & (2<<(j*2)))? '*':' ');
1638       DEBUGOUT_LF ();
1639     }
1640   else if (msg[0] == RDR_to_PC_HardwareError)    
1641     {
1642       DEBUGOUT ("hardware error occured\n");
1643     }
1644   else
1645     {
1646       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
1647     }
1648
1649   return 0;
1650 }
1651
1652
1653 /* Note that this fucntion won't return the error codes NO_CARD or
1654    CARD_INACTIVE */
1655 int 
1656 ccid_slot_status (ccid_driver_t handle, int *statusbits)
1657 {
1658   int rc;
1659   unsigned char msg[100];
1660   size_t msglen;
1661   unsigned char seqno;
1662   int retries = 0;
1663
1664  retry:
1665   msg[0] = PC_to_RDR_GetSlotStatus;
1666   msg[5] = 0; /* slot */
1667   msg[6] = seqno = handle->seqno++;
1668   msg[7] = 0; /* RFU */
1669   msg[8] = 0; /* RFU */
1670   msg[9] = 0; /* RFU */
1671   set_msg_len (msg, 0);
1672
1673   rc = bulk_out (handle, msg, 10);
1674   if (rc)
1675     return rc;
1676   /* Note that we set the NO_DEBUG flag here, so that the logs won't
1677      get cluttered up by a ticker function checking for the slot
1678      status and debugging enabled. */
1679   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
1680                 seqno, retries? 1000 : 200, 1);
1681   if (rc == CCID_DRIVER_ERR_CARD_IO_ERROR && retries < 3)
1682     {
1683       if (!retries)
1684         {
1685           DEBUGOUT ("USB: CALLING USB_CLEAR_HALT\n");
1686           usb_clear_halt (handle->idev, handle->ep_bulk_in);
1687           usb_clear_halt (handle->idev, handle->ep_bulk_out);
1688         }
1689       else
1690           DEBUGOUT ("USB: RETRYING bulk_in AGAIN\n");
1691       retries++;
1692       goto retry;
1693     }
1694   if (rc && rc != CCID_DRIVER_ERR_NO_CARD
1695       && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
1696     return rc;
1697   *statusbits = (msg[7] & 3);
1698
1699   return 0;
1700 }
1701
1702
1703 int 
1704 ccid_get_atr (ccid_driver_t handle,
1705               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
1706 {
1707   int rc;
1708   int statusbits;
1709   unsigned char msg[100];
1710   unsigned char *tpdu;
1711   size_t msglen, tpdulen;
1712   unsigned char seqno;
1713   int use_crc = 0;
1714   unsigned int edc;
1715   int i;
1716   int tried_iso = 0;
1717   int got_param;
1718
1719   /* First check whether a card is available.  */
1720   rc = ccid_slot_status (handle, &statusbits);
1721   if (rc)
1722     return rc;
1723   if (statusbits == 2)
1724     return CCID_DRIVER_ERR_NO_CARD;
1725
1726     
1727   /* For an inactive and also for an active card, issue the PowerOn
1728      command to get the ATR.  */
1729  again:
1730   msg[0] = PC_to_RDR_IccPowerOn;
1731   msg[5] = 0; /* slot */
1732   msg[6] = seqno = handle->seqno++;
1733   msg[7] = 0; /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
1734   msg[8] = 0; /* RFU */
1735   msg[9] = 0; /* RFU */
1736   set_msg_len (msg, 0);
1737   msglen = 10;
1738
1739   rc = bulk_out (handle, msg, msglen);
1740   if (rc)
1741     return rc;
1742   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
1743                 seqno, 5000, 0);
1744   if (rc)
1745     return rc;
1746   if (!tried_iso && CCID_COMMAND_FAILED (msg) && CCID_ERROR_CODE (msg) == 0xbb
1747       && ((handle->id_vendor == VENDOR_CHERRY
1748            && handle->id_product == 0x0005)
1749           || (handle->id_vendor == VENDOR_GEMPC
1750               && handle->id_product == 0x4433)
1751           ))
1752     {
1753       tried_iso = 1;
1754       /* Try switching to ISO mode. */
1755       if (!send_escape_cmd (handle, (const unsigned char*)"\xF1\x01", 2,
1756                             NULL, 0, NULL))
1757         goto again;
1758     }
1759   else if (CCID_COMMAND_FAILED (msg))
1760     return CCID_DRIVER_ERR_CARD_IO_ERROR;
1761
1762
1763   handle->powered_off = 0;
1764   
1765   if (atr)
1766     {
1767       size_t n = msglen - 10;
1768
1769       if (n > maxatrlen)
1770         n = maxatrlen;
1771       memcpy (atr, msg+10, n);
1772       *atrlen = n;
1773     }
1774
1775   got_param = 0;
1776   msg[0] = PC_to_RDR_GetParameters;
1777   msg[5] = 0; /* slot */
1778   msg[6] = seqno = handle->seqno++;
1779   msg[7] = 0; /* RFU */
1780   msg[8] = 0; /* RFU */
1781   msg[9] = 0; /* RFU */
1782   set_msg_len (msg, 0);
1783   msglen = 10;
1784   rc = bulk_out (handle, msg, msglen);
1785   if (!rc)
1786     rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
1787                   seqno, 2000, 0);
1788   if (rc)
1789     DEBUGOUT ("GetParameters failed\n");
1790   else
1791     {
1792       DEBUGOUT ("GetParametes returned");
1793       for (i=0; i < msglen; i++)
1794         DEBUGOUT_CONT_1 (" %02X", msg[i]);
1795       DEBUGOUT_LF ();
1796       if (msglen >= 10)
1797         {
1798           DEBUGOUT_1 ("  protocol ..........: T=%d\n", msg[9]);
1799           if (msglen == 17 && msg[9] == 1)
1800             {
1801               DEBUGOUT_1 ("  bmFindexDindex ....: %02X\n", msg[10]);
1802               DEBUGOUT_1 ("  bmTCCKST1 .........: %02X\n", msg[11]);
1803               DEBUGOUT_1 ("  bGuardTimeT1 ......: %02X\n", msg[12]);
1804               DEBUGOUT_1 ("  bmWaitingIntegersT1: %02X\n", msg[13]);
1805               DEBUGOUT_1 ("  bClockStop ........: %02X\n", msg[14]);
1806               DEBUGOUT_1 ("  bIFSC .............: %d\n", msg[15]);
1807               DEBUGOUT_1 ("  bNadValue .........: %d\n", msg[16]);
1808               got_param = 1;
1809             }
1810         }
1811     }
1812
1813   /* Setup parameters to select T=1. */
1814   msg[0] = PC_to_RDR_SetParameters;
1815   msg[5] = 0; /* slot */
1816   msg[6] = seqno = handle->seqno++;
1817   msg[7] = 1; /* Select T=1. */
1818   msg[8] = 0; /* RFU */
1819   msg[9] = 0; /* RFU */
1820
1821   if (!got_param)
1822     {
1823       /* FIXME: Get those values from the ATR. */
1824       msg[10]= 0x01; /* Fi/Di */
1825       msg[11]= 0x10; /* LRC, direct convention. */
1826       msg[12]= 0;    /* Extra guardtime. */
1827       msg[13]= 0x41; /* BWI/CWI */
1828       msg[14]= 0;    /* No clock stoppping. */
1829       msg[15]= 254;  /* IFSC */
1830       msg[16]= 0;    /* Does not support non default NAD values. */
1831     }
1832   set_msg_len (msg, 7);
1833   msglen = 10 + 7;
1834
1835   DEBUGOUT ("sending");
1836   for (i=0; i < msglen; i++)
1837     DEBUGOUT_CONT_1 (" %02X", msg[i]);
1838   DEBUGOUT_LF ();
1839
1840   rc = bulk_out (handle, msg, msglen);
1841   if (rc)
1842     return rc;
1843   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
1844                 seqno, 5000, 0);
1845   if (rc)
1846     DEBUGOUT ("SetParameters failed (ignored)\n");
1847
1848   handle->t1_ns = 0;
1849   handle->t1_nr = 0;
1850
1851   /* Send an S-Block with our maximum IFSD to the CCID.  */
1852   if (!handle->apdu_level && !handle->auto_ifsd)
1853     {
1854       tpdu = msg+10;
1855       /* NAD: DAD=1, SAD=0 */
1856       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1857       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
1858       tpdu[2] = 1;
1859       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32; 
1860       tpdulen = 4;
1861       edc = compute_edc (tpdu, tpdulen, use_crc);
1862       if (use_crc)
1863         tpdu[tpdulen++] = (edc >> 8);
1864       tpdu[tpdulen++] = edc;
1865
1866       msg[0] = PC_to_RDR_XfrBlock;
1867       msg[5] = 0; /* slot */
1868       msg[6] = seqno = handle->seqno++;
1869       msg[7] = 0; 
1870       msg[8] = 0; /* RFU */
1871       msg[9] = 0; /* RFU */
1872       set_msg_len (msg, tpdulen);
1873       msglen = 10 + tpdulen;
1874
1875       DEBUGOUT ("sending");
1876       for (i=0; i < msglen; i++)
1877         DEBUGOUT_CONT_1 (" %02X", msg[i]);
1878       DEBUGOUT_LF ();
1879
1880       if (debug_level > 1)
1881         DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
1882                       ((msg[11] & 0xc0) == 0x80)? 'R' :
1883                                 (msg[11] & 0x80)? 'S' : 'I',
1884                       ((msg[11] & 0x80)? !!(msg[11]& 0x10)
1885                                        : !!(msg[11] & 0x40)),
1886                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
1887
1888       rc = bulk_out (handle, msg, msglen);
1889       if (rc)
1890         return rc;
1891
1892
1893       rc = bulk_in (handle, msg, sizeof msg, &msglen,
1894                     RDR_to_PC_DataBlock, seqno, 5000, 0);
1895       if (rc)
1896         return rc;
1897       
1898       tpdu = msg + 10;
1899       tpdulen = msglen - 10;
1900       
1901       if (tpdulen < 4) 
1902         return CCID_DRIVER_ERR_ABORTED; 
1903
1904       if (debug_level > 1)
1905         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
1906                     ((msg[11] & 0xc0) == 0x80)? 'R' :
1907                               (msg[11] & 0x80)? 'S' : 'I',
1908                     ((msg[11] & 0x80)? !!(msg[11]& 0x10)
1909                                      : !!(msg[11] & 0x40)),
1910                     ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
1911                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
1912
1913       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
1914         {
1915           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
1916           return -1;
1917         }
1918       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
1919     }
1920
1921   return 0;
1922 }
1923
1924
1925 \f
1926
1927 static unsigned int 
1928 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
1929 {
1930   if (use_crc)
1931     {
1932       return 0x42; /* Not yet implemented. */
1933     }
1934   else
1935     {
1936       unsigned char crc = 0;
1937       
1938       for (; datalen; datalen--)
1939         crc ^= *data++;
1940       return crc;
1941     }
1942 }
1943
1944
1945 /* Helper for ccid_transceive used for APDU level exchanges.  */
1946 static int
1947 ccid_transceive_apdu_level (ccid_driver_t handle,
1948                             const unsigned char *apdu_buf, size_t apdu_buflen,
1949                             unsigned char *resp, size_t maxresplen,
1950                             size_t *nresp)
1951 {
1952   int rc;
1953   unsigned char send_buffer[10+259], recv_buffer[10+259];
1954   const unsigned char *apdu;
1955   size_t apdulen;
1956   unsigned char *msg;
1957   size_t msglen;
1958   unsigned char seqno;
1959   int i;
1960
1961   msg = send_buffer;
1962
1963   apdu = apdu_buf;
1964   apdulen = apdu_buflen;
1965   assert (apdulen);
1966
1967   if (apdulen > 254)
1968     return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
1969
1970   msg[0] = PC_to_RDR_XfrBlock;
1971   msg[5] = 0; /* slot */
1972   msg[6] = seqno = handle->seqno++;
1973   msg[7] = 4; /* bBWI */
1974   msg[8] = 0; /* RFU */
1975   msg[9] = 0; /* RFU */
1976   memcpy (msg+10, apdu, apdulen);
1977   set_msg_len (msg, apdulen);
1978   msglen = 10 + apdulen;
1979
1980   DEBUGOUT ("sending");
1981   for (i=0; i < msglen; i++)
1982     DEBUGOUT_CONT_1 (" %02X", msg[i]);
1983   DEBUGOUT_LF ();
1984   
1985   rc = bulk_out (handle, msg, msglen);
1986   if (rc)
1987     return rc;
1988
1989   msg = recv_buffer;
1990   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
1991                 RDR_to_PC_DataBlock, seqno, 5000, 0);
1992   if (rc)
1993     return rc;
1994       
1995   apdu = msg + 10;
1996   apdulen = msglen - 10;
1997       
1998   if (resp)
1999     {
2000       if (apdulen > maxresplen)
2001         {
2002           DEBUGOUT_2 ("provided buffer too short for received data "
2003                       "(%u/%u)\n",
2004                       (unsigned int)apdulen, (unsigned int)maxresplen);
2005           return CCID_DRIVER_ERR_INV_VALUE;
2006         }
2007       
2008       memcpy (resp, apdu, apdulen); 
2009       *nresp = apdulen;
2010     }
2011           
2012   return 0;
2013 }
2014
2015
2016
2017 /*
2018   Protocol T=1 overview
2019
2020   Block Structure:
2021            Prologue Field:
2022    1 byte     Node Address (NAD) 
2023    1 byte     Protocol Control Byte (PCB)
2024    1 byte     Length (LEN) 
2025            Information Field:
2026    0-254 byte APDU or Control Information (INF)
2027            Epilogue Field:
2028    1 byte     Error Detection Code (EDC)
2029
2030   NAD:  
2031    bit 7     unused
2032    bit 4..6  Destination Node Address (DAD)
2033    bit 3     unused
2034    bit 2..0  Source Node Address (SAD)
2035
2036    If node adresses are not used, SAD and DAD should be set to 0 on
2037    the first block sent to the card.  If they are used they should
2038    have different values (0 for one is okay); that first block sets up
2039    the addresses of the nodes.
2040
2041   PCB:
2042    Information Block (I-Block):
2043       bit 7    0
2044       bit 6    Sequence number (yep, that is modulo 2)
2045       bit 5    Chaining flag 
2046       bit 4..0 reserved
2047    Received-Ready Block (R-Block):
2048       bit 7    1
2049       bit 6    0
2050       bit 5    0
2051       bit 4    Sequence number
2052       bit 3..0  0 = no error
2053                 1 = EDC or parity error
2054                 2 = other error
2055                 other values are reserved
2056    Supervisory Block (S-Block):
2057       bit 7    1
2058       bit 6    1
2059       bit 5    clear=request,set=response
2060       bit 4..0  0 = resyncronisation request
2061                 1 = information field size request
2062                 2 = abort request
2063                 3 = extension of BWT request
2064                 4 = VPP error
2065                 other values are reserved
2066
2067 */
2068
2069 int
2070 ccid_transceive (ccid_driver_t handle,
2071                  const unsigned char *apdu_buf, size_t apdu_buflen,
2072                  unsigned char *resp, size_t maxresplen, size_t *nresp)
2073 {
2074   int rc;
2075   unsigned char send_buffer[10+259], recv_buffer[10+259];
2076   const unsigned char *apdu;
2077   size_t apdulen;
2078   unsigned char *msg, *tpdu, *p;
2079   size_t msglen, tpdulen, last_tpdulen, n;
2080   unsigned char seqno;
2081   int i;
2082   unsigned int edc;
2083   int use_crc = 0;
2084   size_t dummy_nresp;
2085   int next_chunk = 1;
2086   int sending = 1;
2087   int retries = 0;
2088
2089   if (!nresp)
2090     nresp = &dummy_nresp;
2091   *nresp = 0;
2092
2093   /* Smarter readers allow to send APDUs directly; divert here. */
2094   if (handle->apdu_level)
2095     return ccid_transceive_apdu_level (handle, apdu_buf, apdu_buflen,
2096                                        resp, maxresplen, nresp);
2097
2098   /* The other readers we support require sending TPDUs.  */
2099
2100   tpdulen = 0; /* Avoid compiler warning about no initialization. */
2101   msg = send_buffer;
2102   for (;;)
2103     {
2104       if (next_chunk)
2105         {
2106           next_chunk = 0;
2107
2108           apdu = apdu_buf;
2109           apdulen = apdu_buflen;
2110           assert (apdulen);
2111
2112           /* Construct an I-Block. */
2113           if (apdulen > 254)
2114             return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
2115
2116           tpdu = msg+10;
2117           /* NAD: DAD=1, SAD=0 */
2118           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2119           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
2120           if (apdulen > 128 /* fixme: replace by ifsc */)
2121             {
2122               apdulen = 128;
2123               apdu_buf += 128;  
2124               apdu_buflen -= 128;
2125               tpdu[1] |= (1 << 5); /* Set more bit. */
2126             }
2127           tpdu[2] = apdulen;
2128           memcpy (tpdu+3, apdu, apdulen);
2129           tpdulen = 3 + apdulen;
2130           edc = compute_edc (tpdu, tpdulen, use_crc);
2131           if (use_crc)
2132             tpdu[tpdulen++] = (edc >> 8);
2133           tpdu[tpdulen++] = edc;
2134         }
2135
2136       msg[0] = PC_to_RDR_XfrBlock;
2137       msg[5] = 0; /* slot */
2138       msg[6] = seqno = handle->seqno++;
2139       msg[7] = 4; /* bBWI */
2140       msg[8] = 0; /* RFU */
2141       msg[9] = 0; /* RFU */
2142       set_msg_len (msg, tpdulen);
2143       msglen = 10 + tpdulen;
2144       last_tpdulen = tpdulen;
2145
2146       DEBUGOUT ("sending");
2147       for (i=0; i < msglen; i++)
2148         DEBUGOUT_CONT_1 (" %02X", msg[i]);
2149       DEBUGOUT_LF ();
2150
2151       if (debug_level > 1)
2152           DEBUGOUT_3 ("T=1: put %c-block seq=%d%s\n",
2153                       ((msg[11] & 0xc0) == 0x80)? 'R' :
2154                                 (msg[11] & 0x80)? 'S' : 'I',
2155                       ((msg[11] & 0x80)? !!(msg[11]& 0x10)
2156                                        : !!(msg[11] & 0x40)),
2157                       (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2158
2159       rc = bulk_out (handle, msg, msglen);
2160       if (rc)
2161         return rc;
2162
2163       msg = recv_buffer;
2164       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
2165                     RDR_to_PC_DataBlock, seqno, 5000, 0);
2166       if (rc)
2167         return rc;
2168       
2169       tpdu = msg + 10;
2170       tpdulen = msglen - 10;
2171       
2172       if (tpdulen < 4) 
2173         {
2174           usb_clear_halt (handle->idev, handle->ep_bulk_in);
2175           return CCID_DRIVER_ERR_ABORTED; 
2176         }
2177
2178       if (debug_level > 1)
2179         DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
2180                     ((msg[11] & 0xc0) == 0x80)? 'R' :
2181                               (msg[11] & 0x80)? 'S' : 'I',
2182                     ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
2183                     ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
2184                     (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2185
2186       if (!(tpdu[1] & 0x80))
2187         { /* This is an I-block. */
2188           retries = 0;
2189           if (sending)
2190             { /* last block sent was successful. */
2191               handle->t1_ns ^= 1;
2192               sending = 0;
2193             }
2194
2195           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
2196             { /* Reponse does not match our sequence number. */
2197               msg = send_buffer;
2198               tpdu = msg+10;
2199               /* NAD: DAD=1, SAD=0 */
2200               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2201               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
2202               tpdu[2] = 0;
2203               tpdulen = 3;
2204               edc = compute_edc (tpdu, tpdulen, use_crc);
2205               if (use_crc)
2206                 tpdu[tpdulen++] = (edc >> 8);
2207               tpdu[tpdulen++] = edc;
2208
2209               continue;
2210             }
2211
2212           handle->t1_nr ^= 1;
2213
2214           p = tpdu + 3; /* Skip the prologue field. */
2215           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
2216           /* fixme: verify the checksum. */
2217           if (resp)
2218             {
2219               if (n > maxresplen)
2220                 {
2221                   DEBUGOUT_2 ("provided buffer too short for received data "
2222                               "(%u/%u)\n",
2223                               (unsigned int)n, (unsigned int)maxresplen);
2224                   return CCID_DRIVER_ERR_INV_VALUE;
2225                 }
2226               
2227               memcpy (resp, p, n); 
2228               resp += n;
2229               *nresp += n;
2230               maxresplen -= n;
2231             }
2232           
2233           if (!(tpdu[1] & 0x20))
2234             return 0; /* No chaining requested - ready. */
2235           
2236           msg = send_buffer;
2237           tpdu = msg+10;
2238           /* NAD: DAD=1, SAD=0 */
2239           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2240           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
2241           tpdu[2] = 0;
2242           tpdulen = 3;
2243           edc = compute_edc (tpdu, tpdulen, use_crc);
2244           if (use_crc)
2245             tpdu[tpdulen++] = (edc >> 8);
2246           tpdu[tpdulen++] = edc;
2247         }
2248       else if ((tpdu[1] & 0xc0) == 0x80)
2249         { /* This is a R-block. */
2250           if ( (tpdu[1] & 0x0f)) 
2251             { /* Error: repeat last block */
2252               if (++retries > 3)
2253                 {
2254                   DEBUGOUT ("3 failed retries\n");
2255                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
2256                 }
2257               msg = send_buffer;
2258               tpdulen = last_tpdulen;
2259             }
2260           else if (sending && !!(tpdu[1] & 0x10) == handle->t1_ns)
2261             { /* Response does not match our sequence number. */
2262               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
2263               return CCID_DRIVER_ERR_CARD_IO_ERROR;
2264             }
2265           else if (sending)
2266             { /* Send next chunk. */
2267               retries = 0;
2268               msg = send_buffer;
2269               next_chunk = 1;
2270               handle->t1_ns ^= 1;
2271             }
2272           else
2273             {
2274               DEBUGOUT ("unexpected ACK R-block received\n");
2275               return CCID_DRIVER_ERR_CARD_IO_ERROR;
2276             }
2277         }
2278       else 
2279         { /* This is a S-block. */
2280           retries = 0;
2281           DEBUGOUT_2 ("T=1 S-block %s received cmd=%d\n",
2282                       (tpdu[1] & 0x20)? "response": "request",
2283                       (tpdu[1] & 0x1f));
2284           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
2285             { /* Wait time extension request. */
2286               unsigned char bwi = tpdu[3];
2287               msg = send_buffer;
2288               tpdu = msg+10;
2289               /* NAD: DAD=1, SAD=0 */
2290               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2291               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
2292               tpdu[2] = 1;
2293               tpdu[3] = bwi;
2294               tpdulen = 4;
2295               edc = compute_edc (tpdu, tpdulen, use_crc);
2296               if (use_crc)
2297                 tpdu[tpdulen++] = (edc >> 8);
2298               tpdu[tpdulen++] = edc;
2299               DEBUGOUT_1 ("T=1 waittime extension of bwi=%d\n", bwi);
2300             }
2301           else
2302             return CCID_DRIVER_ERR_CARD_IO_ERROR;
2303         }
2304     } /* end T=1 protocol loop. */
2305
2306   return 0;
2307 }
2308
2309
2310 /* Send the CCID Secure command to the reader.  APDU_BUF should
2311    contain the APDU template.  PIN_MODE defines how the pin gets
2312    formatted:
2313    
2314      1 := The PIN is ASCII encoded and of variable length.  The
2315           length of the PIN entered will be put into Lc by the reader.
2316           The APDU should me made up of 4 bytes without Lc.
2317
2318    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
2319    may be used t enable reasonable defaults.  PIN_PADLEN should be 0.
2320    
2321    When called with RESP and NRESP set to NULL, the function will
2322    merely check whether the reader supports the secure command for the
2323    given APDU and PIN_MODE. */
2324 int
2325 ccid_transceive_secure (ccid_driver_t handle,
2326                         const unsigned char *apdu_buf, size_t apdu_buflen,
2327                         int pin_mode, int pinlen_min, int pinlen_max,
2328                         int pin_padlen, 
2329                         unsigned char *resp, size_t maxresplen, size_t *nresp)
2330 {
2331   int rc;
2332   unsigned char send_buffer[10+259], recv_buffer[10+259];
2333   unsigned char *msg, *tpdu, *p;
2334   size_t msglen, tpdulen, n;
2335   unsigned char seqno;
2336   int i;
2337   size_t dummy_nresp;
2338   int testmode;
2339   int cherry_mode = 0;
2340
2341   testmode = !resp && !nresp;
2342
2343   if (!nresp)
2344     nresp = &dummy_nresp;
2345   *nresp = 0;
2346
2347   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
2348     ;
2349   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
2350     return CCID_DRIVER_ERR_NOT_SUPPORTED; /* Not yet by our code. */
2351   else
2352     return CCID_DRIVER_ERR_NO_KEYPAD;
2353     
2354   if (pin_mode != 1)
2355     return CCID_DRIVER_ERR_NOT_SUPPORTED;
2356
2357   if (pin_padlen != 0)
2358     return CCID_DRIVER_ERR_NOT_SUPPORTED;
2359
2360   if (!pinlen_min)
2361     pinlen_min = 1;
2362   if (!pinlen_max)
2363     pinlen_max = 25;
2364
2365   /* Note that the 25 is the maximum value the SPR532 allows.  */
2366   if (pinlen_min < 1 || pinlen_min > 25
2367       || pinlen_max < 1 || pinlen_max > 25 
2368       || pinlen_min > pinlen_max)
2369     return CCID_DRIVER_ERR_INV_VALUE;
2370
2371   /* We have only tested a few readers so better don't risk anything
2372      and do not allow the use with other readers. */
2373   switch (handle->id_vendor)
2374     {
2375     case VENDOR_SCM:  /* Tested with SPR 532. */
2376     case VENDOR_KAAN: /* Tested with KAAN Advanced (1.02). */
2377       break;
2378     case VENDOR_CHERRY:
2379       /* The CHERRY XX44 keyboard echos an asterisk for each entered
2380          character on the keyboard channel.  We use a special variant
2381          of PC_to_RDR_Secure which directs these characters to the
2382          smart card's bulk-in channel.  We also need to append a zero
2383          Lc byte to the APDU.  It seems that it will be replaced with
2384          the actual length instead of being appended before the APDU
2385          is send to the card. */
2386       cherry_mode = 1;
2387       break;
2388     default:
2389      return CCID_DRIVER_ERR_NOT_SUPPORTED;
2390     }
2391
2392   if (testmode)
2393     return 0; /* Success */
2394     
2395   msg = send_buffer;
2396   if (handle->id_vendor == VENDOR_SCM)
2397     {
2398       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
2399       rc = send_escape_cmd (handle, (const unsigned char*)"\x80\x02\x00", 3,
2400                             NULL, 0, NULL);
2401       if (rc)
2402         return rc;
2403     }
2404
2405   msg[0] = cherry_mode? 0x89 : PC_to_RDR_Secure;
2406   msg[5] = 0; /* slot */
2407   msg[6] = seqno = handle->seqno++;
2408   msg[7] = 0; /* bBWI */
2409   msg[8] = 0; /* RFU */
2410   msg[9] = 0; /* RFU */
2411   msg[10] = 0; /* Perform PIN verification. */
2412   msg[11] = 0; /* Timeout in seconds. */
2413   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
2414   if (handle->id_vendor == VENDOR_SCM)
2415     {
2416       /* For the SPR532 the next 2 bytes need to be zero.  We do this
2417          for all SCM products.  Kudos to Martin Paljak for this
2418          hint.  */
2419       msg[13] = msg[14] = 0;
2420     }
2421   else
2422     {
2423       msg[13] = 0x00; /* bmPINBlockString:
2424                          0 bits of pin length to insert. 
2425                          0 bytes of PIN block size.  */
2426       msg[14] = 0x00; /* bmPINLengthFormat:
2427                          Units are bytes, position is 0. */
2428     }
2429
2430   /* The following is a little endian word. */
2431   msg[15] = pinlen_max;   /* wPINMaxExtraDigit-Maximum.  */
2432   msg[16] = pinlen_min;   /* wPINMaxExtraDigit-Minimum.  */
2433
2434   msg[17] = 0x02; /* bEntryValidationCondition:
2435                      Validation key pressed */
2436   if (pinlen_min && pinlen_max && pinlen_min == pinlen_max)
2437     msg[17] |= 0x01; /* Max size reached.  */
2438   msg[18] = 0xff; /* bNumberMessage: Default. */
2439   msg[19] = 0x04; /* wLangId-High. */
2440   msg[20] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
2441   msg[21] = 0;    /* bMsgIndex. */
2442   /* bTeoProlog follows: */
2443   msg[22] = handle->nonnull_nad? ((1 << 4) | 0): 0;
2444   msg[23] = ((handle->t1_ns & 1) << 6); /* I-block */
2445   msg[24] = 0; /* The apdulen will be filled in by the reader.  */
2446   /* APDU follows:  */
2447   msg[25] = apdu_buf[0]; /* CLA */
2448   msg[26] = apdu_buf[1]; /* INS */
2449   msg[27] = apdu_buf[2]; /* P1 */
2450   msg[28] = apdu_buf[3]; /* P2 */
2451   msglen = 29;
2452   if (cherry_mode)
2453     msg[msglen++] = 0;
2454   /* An EDC is not required. */
2455   set_msg_len (msg, msglen - 10);
2456
2457   DEBUGOUT ("sending");
2458   for (i=0; i < msglen; i++)
2459     DEBUGOUT_CONT_1 (" %02X", msg[i]);
2460   DEBUGOUT_LF ();
2461   
2462   rc = bulk_out (handle, msg, msglen);
2463   if (rc)
2464     return rc;
2465   
2466   msg = recv_buffer;
2467   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
2468                 RDR_to_PC_DataBlock, seqno, 30000, 0);
2469   if (rc)
2470     return rc;
2471   
2472   tpdu = msg + 10;
2473   tpdulen = msglen - 10;
2474
2475   if (handle->apdu_level)
2476     {
2477       if (resp)
2478         {
2479           if (tpdulen > maxresplen)
2480             {
2481               DEBUGOUT_2 ("provided buffer too short for received data "
2482                           "(%u/%u)\n",
2483                           (unsigned int)tpdulen, (unsigned int)maxresplen);
2484               return CCID_DRIVER_ERR_INV_VALUE;
2485             }
2486           
2487           memcpy (resp, tpdu, tpdulen); 
2488           *nresp = tpdulen;
2489         }
2490       return 0;
2491     }
2492   
2493   if (tpdulen < 4) 
2494     {
2495       usb_clear_halt (handle->idev, handle->ep_bulk_in);
2496       return CCID_DRIVER_ERR_ABORTED; 
2497     }
2498   if (debug_level > 1)
2499     DEBUGOUT_4 ("T=1: got %c-block seq=%d err=%d%s\n",
2500                 ((msg[11] & 0xc0) == 0x80)? 'R' :
2501                           (msg[11] & 0x80)? 'S' : 'I',
2502                 ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
2503                 ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0,
2504                 (!(msg[11] & 0x80) && (msg[11] & 0x20)? " [more]":""));
2505
2506   if (!(tpdu[1] & 0x80))
2507     { /* This is an I-block. */
2508       /* Last block sent was successful. */
2509       handle->t1_ns ^= 1;
2510
2511       if (!!(tpdu[1] & 0x40) != handle->t1_nr)
2512         { /* Reponse does not match our sequence number. */
2513           DEBUGOUT ("I-block with wrong seqno received\n");
2514           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2515         }
2516
2517       handle->t1_nr ^= 1;
2518
2519       p = tpdu + 3; /* Skip the prologue field. */
2520       n = tpdulen - 3 - 1; /* Strip the epilogue field. */
2521       /* fixme: verify the checksum. */
2522       if (resp)
2523         {
2524           if (n > maxresplen)
2525             {
2526               DEBUGOUT_2 ("provided buffer too short for received data "
2527                           "(%u/%u)\n",
2528                           (unsigned int)n, (unsigned int)maxresplen);
2529               return CCID_DRIVER_ERR_INV_VALUE;
2530             }
2531               
2532           memcpy (resp, p, n); 
2533           resp += n;
2534           *nresp += n;
2535           maxresplen -= n;
2536         }
2537           
2538       if (!(tpdu[1] & 0x20))
2539         return 0; /* No chaining requested - ready. */
2540       
2541       DEBUGOUT ("chaining requested but not supported for Secure operation\n");
2542       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2543     }
2544   else if ((tpdu[1] & 0xc0) == 0x80)
2545     { /* This is a R-block. */
2546       if ( (tpdu[1] & 0x0f)) 
2547         { /* Error: repeat last block */
2548           DEBUGOUT ("No retries supported for Secure operation\n");
2549           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2550         }
2551       else if (!!(tpdu[1] & 0x10) == handle->t1_ns)
2552         { /* Reponse does not match our sequence number. */
2553           DEBUGOUT ("R-block with wrong seqno received on more bit\n");
2554           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2555         }
2556       else
2557         { /* Send next chunk. */
2558           DEBUGOUT ("chaining not supported on Secure operation\n");
2559           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2560         }
2561     }
2562   else 
2563     { /* This is a S-block. */
2564       DEBUGOUT_2 ("T=1 S-block %s received cmd=%d for Secure operation\n",
2565                   (tpdu[1] & 0x20)? "response": "request",
2566                   (tpdu[1] & 0x1f));
2567       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2568     } 
2569
2570   return 0;
2571 }
2572
2573
2574
2575
2576 #ifdef TEST
2577
2578
2579 static void
2580 print_error (int err)
2581 {
2582   const char *p;
2583   char buf[50];
2584
2585   switch (err)
2586     {
2587     case 0: p = "success";
2588     case CCID_DRIVER_ERR_OUT_OF_CORE: p = "out of core"; break;
2589     case CCID_DRIVER_ERR_INV_VALUE: p = "invalid value"; break;
2590     case CCID_DRIVER_ERR_NO_DRIVER: p = "no driver"; break;
2591     case CCID_DRIVER_ERR_NOT_SUPPORTED: p = "not supported"; break;
2592     case CCID_DRIVER_ERR_LOCKING_FAILED: p = "locking failed"; break;
2593     case CCID_DRIVER_ERR_BUSY: p = "busy"; break;
2594     case CCID_DRIVER_ERR_NO_CARD: p = "no card"; break;
2595     case CCID_DRIVER_ERR_CARD_INACTIVE: p = "card inactive"; break;
2596     case CCID_DRIVER_ERR_CARD_IO_ERROR: p = "card I/O error"; break;
2597     case CCID_DRIVER_ERR_GENERAL_ERROR: p = "general error"; break;
2598     case CCID_DRIVER_ERR_NO_READER: p = "no reader"; break;
2599     case CCID_DRIVER_ERR_ABORTED: p = "aborted"; break;
2600     default: sprintf (buf, "0x%05x", err); p = buf; break;
2601     }
2602   fprintf (stderr, "operation failed: %s\n", p);
2603 }
2604
2605 static void
2606 print_data (const unsigned char *data, size_t length)
2607 {
2608   if (length >= 2)
2609     {
2610       fprintf (stderr, "operation status: %02X%02X\n",
2611                data[length-2], data[length-1]);
2612       length -= 2;
2613     }
2614   if (length)
2615     {
2616         fputs ("   returned data:", stderr);
2617         for (; length; length--, data++)
2618           fprintf (stderr, " %02X", *data);
2619         putc ('\n', stderr);
2620     }
2621 }
2622
2623 static void
2624 print_result (int rc, const unsigned char *data, size_t length)
2625 {
2626   if (rc)
2627     print_error (rc);
2628   else if (data)
2629     print_data (data, length);
2630 }
2631
2632 int
2633 main (int argc, char **argv)
2634 {
2635   int rc;
2636   ccid_driver_t ccid;
2637   int slotstat;
2638   unsigned char result[512];
2639   size_t resultlen;
2640   int no_pinpad = 0;
2641   int verify_123456 = 0;
2642   int did_verify = 0;
2643   int no_poll = 0;
2644
2645   if (argc)
2646     {
2647       argc--;
2648       argv++;
2649     }
2650
2651   while (argc)
2652     {
2653       if ( !strcmp (*argv, "--list"))
2654         {
2655           char *p;
2656           p = ccid_get_reader_list ();
2657           if (!p)
2658             return 1;
2659           fputs (p, stderr);
2660           free (p);
2661           return 0;
2662         }
2663       else if ( !strcmp (*argv, "--debug"))
2664         {
2665           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
2666           argc--; argv++;
2667         }
2668       else if ( !strcmp (*argv, "--no-poll"))
2669         {
2670           no_poll = 1;
2671           argc--; argv++;
2672         }
2673       else if ( !strcmp (*argv, "--no-pinpad"))
2674         {
2675           no_pinpad = 1;
2676           argc--; argv++;
2677         }
2678       else if ( !strcmp (*argv, "--verify-123456"))
2679         {
2680           verify_123456 = 1;
2681           argc--; argv++;
2682         }
2683       else
2684         break;
2685     }
2686
2687   rc = ccid_open_reader (&ccid, argc? *argv:NULL);
2688   if (rc)
2689     return 1;
2690
2691   if (!no_poll)
2692     ccid_poll (ccid);
2693   fputs ("getting ATR ...\n", stderr);
2694   rc = ccid_get_atr (ccid, NULL, 0, NULL);
2695   if (rc)
2696     {
2697       print_error (rc);
2698       return 1;
2699     }
2700
2701   if (!no_poll)
2702     ccid_poll (ccid);
2703   fputs ("getting slot status ...\n", stderr);
2704   rc = ccid_slot_status (ccid, &slotstat);
2705   if (rc)
2706     {
2707       print_error (rc);
2708       return 1;
2709     }
2710
2711   if (!no_poll)
2712     ccid_poll (ccid);
2713
2714   fputs ("selecting application OpenPGP ....\n", stderr);
2715   {
2716     static unsigned char apdu[] = {
2717       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
2718     rc = ccid_transceive (ccid,
2719                           apdu, sizeof apdu,
2720                           result, sizeof result, &resultlen);
2721     print_result (rc, result, resultlen);
2722   }
2723   
2724
2725   if (!no_poll)
2726     ccid_poll (ccid);
2727
2728   fputs ("getting OpenPGP DO 0x65 ....\n", stderr);
2729   {
2730     static unsigned char apdu[] = { 0, 0xCA, 0, 0x65, 254 };
2731     rc = ccid_transceive (ccid, apdu, sizeof apdu,
2732                           result, sizeof result, &resultlen);
2733     print_result (rc, result, resultlen);
2734   }
2735
2736   if (!no_pinpad)
2737     {
2738     }
2739
2740   if (!no_pinpad)
2741     {
2742       static unsigned char apdu[] = { 0, 0x20, 0, 0x81 };
2743
2744       
2745       if (ccid_transceive_secure (ccid,
2746                                   apdu, sizeof apdu,
2747                                   1, 0, 0, 0,
2748                                   NULL, 0, NULL))
2749         fputs ("can't verify using a PIN-Pad reader\n", stderr);
2750       else
2751         {
2752           fputs ("verifying CHV1 using the PINPad ....\n", stderr);
2753           
2754           rc = ccid_transceive_secure (ccid,
2755                                        apdu, sizeof apdu,
2756                                        1, 0, 0, 0,
2757                                        result, sizeof result, &resultlen);
2758           print_result (rc, result, resultlen);
2759           did_verify = 1;
2760         }
2761     }
2762   
2763   if (verify_123456 && !did_verify)
2764     {
2765       fputs ("verifying that CHV1 is 123456....\n", stderr);
2766       {
2767         static unsigned char apdu[] = {0, 0x20, 0, 0x81,
2768                                        6, '1','2','3','4','5','6'};
2769         rc = ccid_transceive (ccid, apdu, sizeof apdu,
2770                               result, sizeof result, &resultlen);
2771         print_result (rc, result, resultlen);
2772       }
2773     }
2774
2775   if (!rc)
2776     {
2777       fputs ("getting OpenPGP DO 0x5E ....\n", stderr);
2778       {
2779         static unsigned char apdu[] = { 0, 0xCA, 0, 0x5E, 254 };
2780         rc = ccid_transceive (ccid, apdu, sizeof apdu,
2781                               result, sizeof result, &resultlen);
2782         print_result (rc, result, resultlen);
2783       }
2784     }
2785
2786   ccid_close_reader (ccid);
2787
2788   return 0;
2789 }
2790
2791 /*
2792  * Local Variables:
2793  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
2794  * End:
2795  */
2796 #endif /*TEST*/
2797 #endif /*HAVE_LIBUSB*/