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