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