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