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