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