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