* gpgv.c (agent_scd_getattr): Stub.
[gnupg.git] / g10 / 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
56
57 /* CCID (ChipCardInterfaceDevices) is a specification for accessing
58    smartcard via a reader connected to the USB.  
59
60    This is a limited driver allowing to use some CCID drivers directly
61    without any other specila drivers. This is a fallback driver to be
62    used when nothing else works or the system should be kept minimal
63    for security reasons.  It makes use of the libusb library to gain
64    portable access to USB.
65
66    This driver has been tested with the SCM SCR335 smartcard reader
67    and requires that reader implements the TPDU level exchange and
68    does fully automatic initialization.
69 */
70
71 #ifdef HAVE_CONFIG_H
72 # include <config.h>
73 #endif
74
75 #if defined(HAVE_LIBUSB) || defined(TEST)
76
77 #include <errno.h>
78 #include <stdio.h>
79 #include <stdlib.h>
80 #include <string.h>
81 #include <assert.h>
82
83 #include <usb.h>
84
85 #include "ccid-driver.h"
86
87 #define DRVNAME "ccid-driver: "
88
89
90 /* Depending on how this source is used we either define our error
91    output to go to stderr or to the jnlib based logging functions.  We
92    use the latter when GNUPG_MAJOR_VERSION is defines or when both,
93    GNUPG_SCD_MAIN_HEADER and HAVE_JNLIB_LOGGING are defined.
94 */
95 #if defined(GNUPG_MAJOR_VERSION) \
96     || (defined(GNUPG_SCD_MAIN_HEADER) && defined(HAVE_JNLIB_LOGGING))
97
98 #if defined(GNUPG_SCD_MAIN_HEADER)
99 #  include GNUPG_SCD_MAIN_HEADER
100 #elif GNUPG_MAJOR_VERSION == 1 /* GnuPG Version is < 1.9. */
101 #  include "options.h"
102 #  include "util.h"
103 #  include "memory.h"
104 #  include "cardglue.h"
105 # else /* This is the modularized GnuPG 1.9 or later. */
106 #  include "scdaemon.h"
107 #endif
108
109 /* Define to print information pertaining the T=1 protocol. */
110 #undef DEBUG_T1 
111
112
113 # define DEBUGOUT(t)         do { if (debug_level) \
114                                   log_debug (DRVNAME t); } while (0)
115 # define DEBUGOUT_1(t,a)     do { if (debug_level) \
116                                   log_debug (DRVNAME t,(a)); } while (0)
117 # define DEBUGOUT_2(t,a,b)   do { if (debug_level) \
118                                   log_debug (DRVNAME t,(a),(b)); } while (0)
119 # define DEBUGOUT_3(t,a,b,c) do { if (debug_level) \
120                                   log_debug (DRVNAME t,(a),(b),(c));} while (0)
121 # define DEBUGOUT_CONT(t)    do { if (debug_level) \
122                                   log_printf (t); } while (0)
123 # define DEBUGOUT_CONT_1(t,a)  do { if (debug_level) \
124                                   log_printf (t,(a)); } while (0)
125 # define DEBUGOUT_CONT_2(t,a,b)   do { if (debug_level) \
126                                   log_printf (t,(a),(b)); } while (0)
127 # define DEBUGOUT_CONT_3(t,a,b,c) do { if (debug_level) \
128                                   log_printf (t,(a),(b),(c)); } while (0)
129 # define DEBUGOUT_LF()       do { if (debug_level) \
130                                   log_printf ("\n"); } while (0)
131
132 #else /* Other usage of this source - don't use gnupg specifics. */
133
134 # define DEBUGOUT(t)          do { if (debug_level) \
135                      fprintf (stderr, DRVNAME t); } while (0)
136 # define DEBUGOUT_1(t,a)      do { if (debug_level) \
137                      fprintf (stderr, DRVNAME t, (a)); } while (0)
138 # define DEBUGOUT_2(t,a,b)    do { if (debug_level) \
139                      fprintf (stderr, DRVNAME t, (a), (b)); } while (0)
140 # define DEBUGOUT_3(t,a,b,c)  do { if (debug_level) \
141                      fprintf (stderr, DRVNAME t, (a), (b), (c)); } while (0)
142 # define DEBUGOUT_CONT(t)     do { if (debug_level) \
143                      fprintf (stderr, t); } while (0)
144 # define DEBUGOUT_CONT_1(t,a) do { if (debug_level) \
145                      fprintf (stderr, t, (a)); } while (0)
146 # define DEBUGOUT_CONT_2(t,a,b) do { if (debug_level) \
147                      fprintf (stderr, t, (a), (b)); } while (0)
148 # define DEBUGOUT_CONT_3(t,a,b,c) do { if (debug_level) \
149                      fprintf (stderr, t, (a), (b), (c)); } while (0)
150 # define DEBUGOUT_LF()        do { if (debug_level) \
151                      putc ('\n', stderr); } while (0)
152
153 #endif /* This source not used by scdaemon. */
154
155
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 /* This structure is used to keep information about a specific reader. */
187 struct ccid_reader_id_s 
188 {
189   struct ccid_reader_id_s *next;
190   char reader_id[1];
191 };
192
193 /* Store information on the driver's state.  A pointer to such a
194    structure is used as handle for most functions. */
195 struct ccid_driver_s 
196 {
197   usb_dev_handle *idev;
198   struct ccid_reader_id_s *rid;
199   int seqno;
200   unsigned char t1_ns;
201   unsigned char t1_nr;
202   int nonnull_nad;
203   int auto_ifsd;
204   int max_ifsd;
205   int ifsd;
206 };
207
208 /* Flag to control whether we we want debug output.  */
209 static int debug_level;
210
211 static unsigned int compute_edc (const unsigned char *data, size_t datalen,
212                                  int use_crc);
213 static int bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen);
214 static int bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
215                     size_t *nread, int expected_type, int seqno);
216
217 #ifndef HAVE_USB_GET_STRING_SIMPLE
218
219 /* This function adapted from the libusb 0.1.8 sources.  It's here so
220    that systems with an older libusb can still use smartcards. */
221
222 static int usb_get_string_simple(usb_dev_handle *dev, int indx, char *buf,
223                                  size_t buflen)
224 {
225   char tbuf[256];
226   int ret, langid, si, di;
227
228   /*
229    * Asking for the zero'th index is special - it returns a string
230    * descriptor that contains all the language IDs supported by the
231    * device. Typically there aren't many - often only one. The
232    * language IDs are 16 bit numbers, and they start at the third byte
233    * in the descriptor. See USB 2.0 specification, section 9.6.7, for
234    * more information on this. */
235
236   ret=usb_control_msg(dev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
237                       (USB_DT_STRING << 8), 0, tbuf, sizeof(tbuf), 1000);
238
239   if (ret < 0)
240     return ret;
241
242   if (ret < 4)
243     return -EIO;
244
245   langid = tbuf[2] | (tbuf[3] << 8);
246
247   ret=usb_control_msg(dev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
248                       (USB_DT_STRING << 8)+indx,langid,tbuf,sizeof(tbuf),1000);
249   if (ret < 0)
250     return ret;
251
252   if (tbuf[1] != USB_DT_STRING)
253     return -EIO;
254
255   if (tbuf[0] > ret)
256     return -EFBIG;
257
258   for (di = 0, si = 2; si < tbuf[0]; si += 2) {
259     if (di >= (buflen - 1))
260       break;
261
262     if (tbuf[si + 1])   /* high byte */
263       buf[di++] = '?';
264     else
265       buf[di++] = tbuf[si];
266   }
267
268   buf[di] = 0;
269
270   return di;
271 }
272
273 #endif /* !HAVE_USB_GET_STRING_SIMPLE */
274
275 /* Convert a little endian stored 4 byte value into an unsigned
276    integer. */
277 static unsigned int 
278 convert_le_u32 (const unsigned char *buf)
279 {
280   return buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24); 
281 }
282
283 static void
284 set_msg_len (unsigned char *msg, unsigned int length)
285 {
286   msg[1] = length;
287   msg[2] = length >> 8;
288   msg[3] = length >> 16;
289   msg[4] = length >> 24;
290 }
291
292
293
294
295 /* Parse a CCID descriptor, optionally print all available features
296    and test whether this reader is usable by this driver.  Returns 0
297    if it is usable.
298
299    Note, that this code is based on the one in lsusb.c of the
300    usb-utils package, I wrote on 2003-09-01. -wk. */
301 static int
302 parse_ccid_descriptor (ccid_driver_t handle,
303                        const unsigned char *buf, size_t buflen)
304 {
305   unsigned int i;
306   unsigned int us;
307   int have_t1 = 0, have_tpdu=0, have_auto_conf = 0;
308
309
310   handle->nonnull_nad = 0;
311   handle->auto_ifsd = 0;
312   handle->max_ifsd = 32;
313   handle->ifsd = 0;
314   if (buflen < 54 || buf[0] < 54)
315     {
316       DEBUGOUT ("CCID device descriptor is too short\n");
317       return -1;
318     }
319
320   DEBUGOUT   ("ChipCard Interface Descriptor:\n");
321   DEBUGOUT_1 ("  bLength             %5u\n", buf[0]);
322   DEBUGOUT_1 ("  bDescriptorType     %5u\n", buf[1]);
323   DEBUGOUT_2 ("  bcdCCID             %2x.%02x", buf[3], buf[2]);
324     if (buf[3] != 1 || buf[2] != 0) 
325       DEBUGOUT_CONT("  (Warning: Only accurate for version 1.0)");
326   DEBUGOUT_LF ();
327
328   DEBUGOUT_1 ("  nMaxSlotIndex       %5u\n", buf[4]);
329   DEBUGOUT_2 ("  bVoltageSupport     %5u  %s\n",
330               buf[5], (buf[5] == 1? "5.0V" : buf[5] == 2? "3.0V"
331                        : buf[5] == 3? "1.8V":"?"));
332
333   us = convert_le_u32 (buf+6);
334   DEBUGOUT_1 ("  dwProtocols         %5u ", us);
335   if ((us & 1))
336     DEBUGOUT_CONT (" T=0");
337   if ((us & 2))
338     {
339       DEBUGOUT_CONT (" T=1");
340       have_t1 = 1;
341     }
342   if ((us & ~3))
343     DEBUGOUT_CONT (" (Invalid values detected)");
344   DEBUGOUT_LF ();
345
346   us = convert_le_u32(buf+10);
347   DEBUGOUT_1 ("  dwDefaultClock      %5u\n", us);
348   us = convert_le_u32(buf+14);
349   DEBUGOUT_1 ("  dwMaxiumumClock     %5u\n", us);
350   DEBUGOUT_1 ("  bNumClockSupported  %5u\n", buf[18]);
351   us = convert_le_u32(buf+19);
352   DEBUGOUT_1 ("  dwDataRate        %7u bps\n", us);
353   us = convert_le_u32(buf+23);
354   DEBUGOUT_1 ("  dwMaxDataRate     %7u bps\n", us);
355   DEBUGOUT_1 ("  bNumDataRatesSupp.  %5u\n", buf[27]);
356         
357   us = convert_le_u32(buf+28);
358   DEBUGOUT_1 ("  dwMaxIFSD           %5u\n", us);
359   handle->max_ifsd = us;
360
361   us = convert_le_u32(buf+32);
362   DEBUGOUT_1 ("  dwSyncProtocols  %08X ", us);
363   if ((us&1))
364     DEBUGOUT_CONT ( " 2-wire");
365   if ((us&2))
366     DEBUGOUT_CONT ( " 3-wire");
367   if ((us&4))
368     DEBUGOUT_CONT ( " I2C");
369   DEBUGOUT_LF ();
370
371   us = convert_le_u32(buf+36);
372   DEBUGOUT_1 ("  dwMechanical     %08X ", us);
373   if ((us & 1))
374     DEBUGOUT_CONT (" accept");
375   if ((us & 2))
376     DEBUGOUT_CONT (" eject");
377   if ((us & 4))
378     DEBUGOUT_CONT (" capture");
379   if ((us & 8))
380     DEBUGOUT_CONT (" lock");
381   DEBUGOUT_LF ();
382
383   us = convert_le_u32(buf+40);
384   DEBUGOUT_1 ("  dwFeatures       %08X\n", us);
385   if ((us & 0x0002))
386     {
387       DEBUGOUT ("    Auto configuration based on ATR\n");
388       have_auto_conf = 1;
389     }
390   if ((us & 0x0004))
391     DEBUGOUT ("    Auto activation on insert\n");
392   if ((us & 0x0008))
393     DEBUGOUT ("    Auto voltage selection\n");
394   if ((us & 0x0010))
395     DEBUGOUT ("    Auto clock change\n");
396   if ((us & 0x0020))
397     DEBUGOUT ("    Auto baud rate change\n");
398   if ((us & 0x0040))
399     DEBUGOUT ("    Auto parameter negotation made by CCID\n");
400   else if ((us & 0x0080))
401     DEBUGOUT ("    Auto PPS made by CCID\n");
402   else if ((us & (0x0040 | 0x0080)))
403     DEBUGOUT ("    WARNING: conflicting negotation features\n");
404
405   if ((us & 0x0100))
406     DEBUGOUT ("    CCID can set ICC in clock stop mode\n");
407   if ((us & 0x0200))
408     {
409       DEBUGOUT ("    NAD value other than 0x00 accepted\n");
410       handle->nonnull_nad = 1;
411     }
412   if ((us & 0x0400))
413     {
414       DEBUGOUT ("    Auto IFSD exchange\n");
415       handle->auto_ifsd = 1;
416     }
417
418   if ((us & 0x00010000))
419     {
420       DEBUGOUT ("    TPDU level exchange\n");
421       have_tpdu = 1;
422     } 
423   else if ((us & 0x00020000))
424     DEBUGOUT ("    Short APDU level exchange\n");
425   else if ((us & 0x00040000))
426     DEBUGOUT ("    Short and extended APDU level exchange\n");
427   else if ((us & 0x00070000))
428     DEBUGOUT ("    WARNING: conflicting exchange levels\n");
429
430   us = convert_le_u32(buf+44);
431   DEBUGOUT_1 ("  dwMaxCCIDMsgLen     %5u\n", us);
432
433   DEBUGOUT (  "  bClassGetResponse    ");
434   if (buf[48] == 0xff)
435     DEBUGOUT_CONT ("echo\n");
436   else
437     DEBUGOUT_CONT_1 ("  %02X\n", buf[48]);
438
439   DEBUGOUT (  "  bClassEnvelope       ");
440   if (buf[49] == 0xff)
441     DEBUGOUT_CONT ("echo\n");
442   else
443     DEBUGOUT_1 ("  %02X\n", buf[48]);
444
445   DEBUGOUT (  "  wlcdLayout           ");
446   if (!buf[50] && !buf[51])
447     DEBUGOUT_CONT ("none\n");
448   else
449     DEBUGOUT_CONT_2 ("%u cols %u lines\n", buf[50], buf[51]);
450         
451   DEBUGOUT_1 ("  bPINSupport         %5u ", buf[52]);
452   if ((buf[52] & 1))
453     DEBUGOUT_CONT ( " verification");
454   if ((buf[52] & 2))
455     DEBUGOUT_CONT ( " modification");
456   DEBUGOUT_LF ();
457         
458   DEBUGOUT_1 ("  bMaxCCIDBusySlots   %5u\n", buf[53]);
459
460   if (buf[0] > 54) {
461     DEBUGOUT ("  junk             ");
462     for (i=54; i < buf[0]-54; i++)
463       DEBUGOUT_CONT_1 (" %02X", buf[i]);
464     DEBUGOUT_LF ();
465   }
466
467   if (!have_t1 || !have_tpdu || !have_auto_conf)
468     {
469       DEBUGOUT ("this drivers requires that the reader supports T=1, "
470                 "TPDU level exchange and auto configuration - "
471                 "this is not available\n");
472       return -1;
473     }
474   else
475     return 0;
476 }
477
478
479 /* This function creates an reader id to be used to find the same
480    physical reader after a reset.  It returns an allocated and possibly
481    percent escaped string in the reader_id element of the returned
482    structure or NULL if not enough memory is available. */
483 static struct ccid_reader_id_s *
484 make_reader_id (usb_dev_handle *idev,
485                 unsigned int vendor, unsigned int product,
486                 unsigned char serialno_index)
487 {
488   char serialno[257];
489   unsigned char *s;
490   size_t n;
491   struct ccid_reader_id_s *rid;
492   char *buf;
493
494   /* NOTE: valgrind will complain here becuase it does not know about
495      the USB IOCTLs. */
496
497   if (!serialno_index)
498     *serialno = 0;
499   else if (usb_get_string_simple (idev, serialno_index,
500                                   serialno, sizeof (serialno) -1) < 0)
501     strcpy (serialno, "X"); /* Error. */
502            
503   for (n=0,s=serialno; *s; s++)
504     if (*s <= 0x20 || *s >= 0x7f || *s == '%' || *s == ':')
505       n += 3;
506     else
507       n++;
508
509   n += 4+1+4+1+2; /* (vendor : product : :0 ) */
510   rid = malloc (sizeof *rid + n);
511   if (!rid)
512     return NULL;
513   rid->next = NULL;
514   buf = rid->reader_id;
515   sprintf (buf, "%04X:%04X:", (vendor & 0xfff), (product & 0xffff));
516   for (n=strlen (buf),s=serialno; *s; s++)
517     if (*s <= 0x20 || *s >= 0x7f || *s == '%' || *s == ':')
518       {
519         sprintf (buf+n, "%%%02X", *s);
520         n += 3;
521       }
522     else
523       buf[n++] = *s;
524   buf[n++] = ':';
525   buf[n++] = '0'; /* Reserved. */
526   buf[n] = 0;
527   
528   return rid;
529 }
530
531
532 /* Combination function to either scan all CCID devices or to find and
533    open one specific device. 
534
535    With READERNO = -1 scan mode is used and R_RID should be the
536    address where to store the list of reader_ids we found.  If on
537    return this list is empty, no CCID device has been found; otherwise
538    it points to an allocated linked list of reader IDs.  Note that in
539    this mode the function always returns NULL.
540
541    With READERNO >= 0 find mode is used.  This uses the same algorithm
542    as the scan mode but stops and returns at the entry number READERNO
543    and return the handle for the the opened USB device. If R_ID is not
544    NULL it will receive the reader ID of that device.  If R_DEV is not
545    NULL it will the device pointer of that device.  If IFCDESC_EXTRA is
546    NOT NULL it will receive a malloced copy of the interfaces "extra:
547    data filed; IFCDESC_EXTRA_LEN receive the lengtyh of this field.  If
548    there is no reader with number READERNO or that reader is not
549    usable by our implementation NULL will be returned.  The caller
550    must close a returned USB device handle and free (if not passed as
551    NULL) the returned reader ID info as well as the IFCDESC_EXTRA.  On
552    error NULL will get stored at R_RID, R_DEV, IFCDESC_EXTRA and
553    IFCDESC_EXTRA_LEN.
554
555    Note that the first entry of the returned reader ID list in scan mode
556    corresponds with a READERNO of 0 in find mode.
557 */
558 static usb_dev_handle *
559 scan_or_find_devices (int readerno,
560                       struct ccid_reader_id_s **r_rid,
561                       struct usb_device **r_dev,
562                       unsigned char **ifcdesc_extra,
563                       size_t *ifcdesc_extra_len)
564 {
565   struct ccid_reader_id_s *rid_list = NULL;
566   struct ccid_reader_id_s **rid_tail = NULL;
567   int count = 0;
568   struct usb_bus *busses, *bus;
569   struct usb_device *dev = NULL;
570   usb_dev_handle *idev = NULL;
571
572    /* Set return values to a default. */
573   if (r_rid)
574     *r_rid = NULL;
575   if (r_dev)
576     *r_dev = NULL; 
577   if (ifcdesc_extra)
578     *ifcdesc_extra = NULL;
579   if (ifcdesc_extra_len)
580     *ifcdesc_extra_len = 0;
581
582   /* See whether we want scan or find mode. */
583   if (readerno < 0) /* Scan mode. */
584     {
585       assert (r_rid);
586       rid_tail = &rid_list;
587     }
588
589   usb_find_busses();
590   usb_find_devices();
591
592 #ifdef HAVE_USB_GET_BUSSES
593   busses = usb_get_busses();
594 #else
595   busses = usb_busses;
596 #endif
597
598   for (bus = busses; bus; bus = bus->next) 
599     {
600       for (dev = bus->devices; dev; dev = dev->next)
601         {
602           int cfg_no;
603           
604           for (cfg_no=0; cfg_no < dev->descriptor.bNumConfigurations; cfg_no++)
605             {
606               struct usb_config_descriptor *config = dev->config + cfg_no;
607               int ifc_no;
608
609               if(!config)
610                 continue;
611
612               for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
613                 {
614                   struct usb_interface *interface
615                     = config->interface + ifc_no;
616                   int set_no;
617                   
618                   if (!interface)
619                     continue;
620                   
621                   for (set_no=0; set_no < interface->num_altsetting; set_no++)
622                     {
623                       struct usb_interface_descriptor *ifcdesc
624                         = interface->altsetting + set_no;
625                       struct ccid_reader_id_s *rid;
626                       
627                       if (ifcdesc
628                           && ifcdesc->bInterfaceClass == 11
629                           && ifcdesc->bInterfaceSubClass == 0
630                           && ifcdesc->bInterfaceProtocol == 0
631                           && ifcdesc->extra)
632                         {
633                           idev = usb_open (dev);
634                           if (!idev)
635                             {
636                               DEBUGOUT_1 ("usb_open failed: %s\n",
637                                           strerror (errno));
638                               continue;
639                             }
640                               
641                           rid = make_reader_id (idev,
642                                                 dev->descriptor.idVendor,
643                                                 dev->descriptor.idProduct,
644                                                 dev->descriptor.iSerialNumber);
645                           if (rid)
646                             {
647                               if (readerno < 0)
648                                 {
649                                   /* We are collecting infos about all
650                                      available CCID readers.  Store
651                                      them and continue. */
652                                   DEBUGOUT_2 ("found CCID reader %d "
653                                               "(ID=%s)\n",
654                                               count, rid->reader_id );
655                                   *rid_tail = rid;
656                                   rid_tail = &rid->next;
657                                   rid = NULL;
658                                 }
659                               else if (!readerno)
660                                 {
661                                   /* We found the requested reader. */
662                                   if (ifcdesc_extra && ifcdesc_extra_len)
663                                     {
664                                       *ifcdesc_extra = malloc (ifcdesc
665                                                                ->extralen);
666                                       if (!*ifcdesc_extra)
667                                         {
668                                           usb_close (idev);
669                                           free (rid);
670                                           return NULL; /* Out of core. */
671                                         }
672                                       memcpy (*ifcdesc_extra, ifcdesc->extra,
673                                               ifcdesc->extralen);
674                                       *ifcdesc_extra_len = ifcdesc->extralen;
675                                     }
676
677                                   if (r_dev)
678                                     *r_dev = dev;
679                                   if (r_rid)
680                                     {
681                                       *r_rid = rid;
682                                       rid = NULL;
683                                     }
684                                   else
685                                     free (rid);
686                                   return idev; /* READY. */
687                                 }
688                               else
689                                 {
690                                   /* This is not yet the reader we
691                                      want.  fixme: We could avoid the
692                                      extra usb_open in this case. */
693                                   readerno--;
694                                 }
695                               free (rid);
696                             }
697                           
698                           usb_close (idev);
699                           idev = NULL;
700                           goto next_device;
701                         }
702                     }
703                 }
704             }
705         next_device:
706           ;
707         }
708     }
709
710   if (readerno < 0)
711     *r_rid = rid_list;
712
713   return NULL;
714 }
715
716 /* Open the reader with the internal number READERNO and return a 
717    pointer to be used as handle in HANDLE.  Returns 0 on success. */
718 int 
719 ccid_open_reader (ccid_driver_t *handle, int readerno)
720 {
721 #ifdef HAVE_USB_CREATE_MATCH
722   /* This is the development version of libusb. */  
723   static int initialized;
724   int rc;
725   usb_match_handle *match = NULL;
726   struct usb_device *dev = NULL;
727   usb_dev_handle *idev = NULL;
728
729   *handle = NULL;
730   if (!initialized)
731     {
732       usb_init ();
733       initialized = 1;
734     }
735   
736   rc = usb_create_match (&match, -1, -1, 11, -1, -1);
737   if (rc)
738     {
739       DEBUGOUT_1 ("usb_create_match failed: %d\n", rc);
740       return CCID_DRIVER_ERR_NO_READER;
741     }
742   
743   while (usb_find_device(match, dev, &dev) >= 0) 
744     {
745       DEBUGOUT_3 ("%-40s %04X/%04X\n", dev->filename,
746                   dev->descriptor->idVendor, dev->descriptor->idProduct);
747       if (!readerno)
748         {
749           *handle = calloc (1, sizeof **handle);
750           if (!*handle)
751             {
752               DEBUGOUT ("out of memory\n");
753               rc = CCID_DRIVER_ERR_OUT_OF_CORE;
754               free (*handle);
755               *handle = NULL;
756               goto leave;
757             }
758
759           rc = read_device_info (*handle, dev);
760           if (rc)
761             {
762               DEBUGOUT ("device not supported\n");
763               free (*handle);
764               *handle = NULL;
765               goto leave;
766             }
767
768           rc = usb_open (dev, &idev);
769           if (rc)
770             {
771               DEBUGOUT_1 ("usb_open failed: %d\n", rc);
772               free (*handle);
773               *handle = NULL;
774               rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
775               goto leave;
776             }
777
778
779           /* fixme: Do we need to claim and set the interface as
780              determined by read_device_info ()? */
781           rc = usb_claim_interface (idev, 0);
782           if (rc)
783             {
784               DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
785               free (*handle);
786               *handle = NULL;
787               rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
788               goto leave;
789             }
790
791           (*handle)->idev = idev;
792           idev = NULL;
793           /* FIXME: Do we need to get the endpoint addresses from the
794              structure and store them with the handle? */
795
796           break;
797         }
798       readerno--;
799     }
800
801  leave:
802   if (idev)
803     usb_close (idev);
804   /* fixme: Do we need to release dev or is it supposed to be a
805      shallow copy of the list created internally by usb_init ? */
806   usb_free_match (match);
807
808   if (!rc && !*handle)
809     rc = -1; /* In case we didn't enter the while loop at all. */
810
811   return rc;
812 #else /* Stable 0.1 version of libusb.  */
813   static int initialized;
814   static struct ccid_reader_id_s *reader_list;
815   int rc = 0;
816   struct usb_device *dev = NULL;
817   usb_dev_handle *idev = NULL;
818   struct ccid_reader_id_s *rid = NULL;
819   unsigned char *ifcdesc_extra = NULL;
820   size_t ifcdesc_extra_len;
821
822   *handle = NULL;
823
824   if (!initialized)
825     {
826       usb_init ();
827       /* Now scan all CCID device.  I am not sure whether this is
828          really required, but anyway, it is good for debugging. */
829       scan_or_find_devices (-1, &reader_list, NULL, NULL, NULL);
830       initialized = 1;
831     }
832
833   if (!reader_list || readerno < 0)
834     {
835       DEBUGOUT ("no CCID readers found\n");
836       rc = CCID_DRIVER_ERR_NO_READER;
837       goto leave;
838     }
839
840   idev = scan_or_find_devices (readerno, &rid, &dev,
841                                &ifcdesc_extra, &ifcdesc_extra_len);
842   if (!idev)
843     {
844       DEBUGOUT_1 ("no CCID reader with number %d\n", readerno );
845       rc = CCID_DRIVER_ERR_NO_READER;
846       goto leave;
847     }
848
849   /* Okay, this is a CCID reader. */
850   *handle = calloc (1, sizeof **handle);
851   if (!*handle)
852     {
853       DEBUGOUT ("out of memory\n");
854       rc = CCID_DRIVER_ERR_OUT_OF_CORE;
855       goto leave;
856     }
857   (*handle)->idev = idev;
858   (*handle)->rid = rid;
859
860   DEBUGOUT_2 ("using CCID reader %d (ID=%s)\n", 
861               readerno, rid->reader_id );
862
863
864
865   if (parse_ccid_descriptor (*handle, ifcdesc_extra, ifcdesc_extra_len))
866     {
867       DEBUGOUT ("device not supported\n");
868       rc = CCID_DRIVER_ERR_NO_READER;
869       goto leave;
870     }
871   
872   /* fixme: Do we need to claim and set the interface as
873      determined above? */
874   rc = usb_claim_interface (idev, 0);
875   if (rc)
876     {
877       DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
878       rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
879       goto leave;
880     }
881   
882   /* FIXME: Do we need to get the endpoint addresses from the
883      structure and store them with the handle? */
884               
885  leave:
886   free (ifcdesc_extra);
887   if (rc)
888     {
889       free (rid);
890       if (idev)
891         usb_close (idev);
892       free (*handle);
893       *handle = NULL;
894     }
895
896   return rc;
897 #endif /* Stable version 0.1 of libusb.  */
898 }
899
900
901 /* Close the reader HANDLE. */
902 int 
903 ccid_close_reader (ccid_driver_t handle)
904 {
905   if (!handle || !handle->idev)
906     return 0;
907
908    {
909      int rc;
910      unsigned char msg[100];
911      size_t msglen;
912      unsigned char seqno;
913    
914      msg[0] = PC_to_RDR_IccPowerOff;
915      msg[5] = 0; /* slot */
916      msg[6] = seqno = handle->seqno++;
917      msg[7] = 0; /* RFU */
918      msg[8] = 0; /* RFU */
919      msg[9] = 0; /* RFU */
920      set_msg_len (msg, 0);
921      msglen = 10;
922    
923      rc = bulk_out (handle, msg, msglen);
924      if (!rc)
925         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus, seqno);
926    }
927    
928   usb_release_interface (handle->idev, 0);
929   usb_close (handle->idev);
930   handle->idev = NULL;
931   free (handle->rid);
932   free (handle);
933   return 0;
934 }
935
936 /* Set the level of debugging to to usea dn return the old level.  -1
937    just returns the old level.  A level of 0 disables debugging, 1
938    enables debugging, other values are not yet defined. */
939 int
940 ccid_set_debug_level (int level)
941 {
942   int old = debug_level;
943   if (level != -1)
944     debug_level = level;
945   return old;
946 }
947
948 /* Return False if a card is present and powered. */
949 int
950 ccid_check_card_presence (ccid_driver_t handle)
951 {
952
953   return -1;
954 }
955
956
957 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
958    Returns 0 on success. */
959 static int
960 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen)
961 {
962   int rc;
963
964   rc = usb_bulk_write (handle->idev, 
965                        1, /*endpoint */
966                        msg, msglen,
967                        1000 /* ms timeout */);
968   if (rc == msglen)
969     return 0;
970
971   if (rc == -1)
972     DEBUGOUT_1 ("usb_bulk_write error: %s\n", strerror (errno));
973   else
974     DEBUGOUT_1 ("usb_bulk_write failed: %d\n", rc);
975   return CCID_DRIVER_ERR_CARD_IO_ERROR;
976 }
977
978
979 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
980    BUFFER and return the actual read number if bytes in NREAD. SEQNO
981    is the sequence number used to send the request and EXPECTED_TYPE
982    the type of message we expect. Does checks on the ccid
983    header. Returns 0 on success. */
984 static int
985 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
986          size_t *nread, int expected_type, int seqno)
987 {
988   int i, rc;
989   size_t msglen;
990
991  retry:
992   rc = usb_bulk_read (handle->idev, 
993                       0x82,
994                       buffer, length,
995                       10000 /* ms timeout */ );
996   /* Fixme: instead of using a 10 second timeout we should better
997      handle the timeout here and retry if appropriate.  */
998   if (rc < 0)
999     {
1000       DEBUGOUT_1 ("usb_bulk_read error: %s\n", strerror (errno));
1001       return CCID_DRIVER_ERR_CARD_IO_ERROR;
1002     }
1003
1004   *nread = msglen = rc;
1005
1006   if (msglen < 10)
1007     {
1008       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
1009       return CCID_DRIVER_ERR_INV_VALUE;
1010     }
1011   if (buffer[0] != expected_type)
1012     {
1013       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
1014       return CCID_DRIVER_ERR_INV_VALUE;
1015     }
1016   if (buffer[5] != 0)    
1017     {
1018       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
1019       return CCID_DRIVER_ERR_INV_VALUE;
1020     }
1021   if (buffer[6] != seqno)    
1022     {
1023       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
1024                   seqno, buffer[6]);
1025       return CCID_DRIVER_ERR_INV_VALUE;
1026     }
1027
1028   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
1029     { 
1030       /* Card present and active, time extension requested. */
1031       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
1032                   buffer[7], buffer[8]);
1033       goto retry;
1034     }
1035   
1036   DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n"
1037               "               data:",  buffer[7], buffer[8], buffer[9] );
1038   for (i=10; i < msglen; i++)
1039     DEBUGOUT_CONT_1 (" %02X", buffer[i]);
1040   DEBUGOUT_LF ();
1041
1042   switch ((buffer[7] & 0x03))
1043     {
1044     case 0: /* no error */ break;
1045     case 1: return CCID_DRIVER_ERR_CARD_INACTIVE;
1046     case 2: return CCID_DRIVER_ERR_NO_CARD;
1047     case 3: /* RFU */ break;
1048     }
1049   return 0;
1050 }
1051
1052
1053 /* experimental */
1054 int
1055 ccid_poll (ccid_driver_t handle)
1056 {
1057   int rc;
1058   unsigned char msg[10];
1059   size_t msglen;
1060   int i, j;
1061
1062   rc = usb_bulk_read (handle->idev, 
1063                       0x83,
1064                       msg, sizeof msg,
1065                       0 /* ms timeout */ );
1066   if (rc < 0 && errno == ETIMEDOUT)
1067     return 0;
1068
1069   if (rc < 0)
1070     {
1071       DEBUGOUT_1 ("usb_intr_read error: %s\n", strerror (errno));
1072       return CCID_DRIVER_ERR_CARD_IO_ERROR;
1073     }
1074
1075   msglen = rc;
1076   rc = 0;
1077
1078   if (msglen < 1)
1079     {
1080       DEBUGOUT ("intr-in msg too short\n");
1081       return CCID_DRIVER_ERR_INV_VALUE;
1082     }
1083
1084   if (msg[0] == RDR_to_PC_NotifySlotChange)
1085     {
1086       DEBUGOUT ("notify slot change:");
1087       for (i=1; i < msglen; i++)
1088         for (j=0; j < 4; j++)
1089           DEBUGOUT_CONT_3 (" %d:%c%c",
1090                            (i-1)*4+j, 
1091                            (msg[i] & (1<<(j*2)))? 'p':'-',
1092                            (msg[i] & (2<<(j*2)))? '*':' ');
1093       DEBUGOUT_LF ();
1094     }
1095   else if (msg[0] == RDR_to_PC_HardwareError)    
1096     {
1097       DEBUGOUT ("hardware error occured\n");
1098     }
1099   else
1100     {
1101       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
1102     }
1103
1104   return 0;
1105 }
1106
1107
1108 /* Note that this fucntion won't return the error codes NO_CARD or
1109    CARD_INACTIVE */
1110 int 
1111 ccid_slot_status (ccid_driver_t handle, int *statusbits)
1112 {
1113   int rc;
1114   unsigned char msg[100];
1115   size_t msglen;
1116   unsigned char seqno;
1117
1118   msg[0] = PC_to_RDR_GetSlotStatus;
1119   msg[5] = 0; /* slot */
1120   msg[6] = seqno = handle->seqno++;
1121   msg[7] = 0; /* RFU */
1122   msg[8] = 0; /* RFU */
1123   msg[9] = 0; /* RFU */
1124   set_msg_len (msg, 0);
1125
1126   rc = bulk_out (handle, msg, 10);
1127   if (rc)
1128     return rc;
1129   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus, seqno);
1130   if (rc && rc != CCID_DRIVER_ERR_NO_CARD
1131       && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
1132     return rc;
1133   *statusbits = (msg[7] & 3);
1134
1135   return 0;
1136 }
1137
1138
1139 int 
1140 ccid_get_atr (ccid_driver_t handle,
1141               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
1142 {
1143   int rc;
1144   unsigned char msg[100];
1145   unsigned char *tpdu;
1146   size_t msglen, tpdulen;
1147   unsigned char seqno;
1148   int use_crc = 0;
1149   unsigned int edc;
1150   int i;
1151
1152   msg[0] = PC_to_RDR_IccPowerOn;
1153   msg[5] = 0; /* slot */
1154   msg[6] = seqno = handle->seqno++;
1155   msg[7] = 0; /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
1156   msg[8] = 0; /* RFU */
1157   msg[9] = 0; /* RFU */
1158   set_msg_len (msg, 0);
1159   msglen = 10;
1160
1161   rc = bulk_out (handle, msg, msglen);
1162   if (rc)
1163     return rc;
1164   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock, seqno);
1165   if (rc)
1166     return rc;
1167   
1168   if (atr)
1169     {
1170       size_t n = msglen - 10;
1171
1172       if (n > maxatrlen)
1173         n = maxatrlen;
1174       memcpy (atr, msg+10, n);
1175       *atrlen = n;
1176     }
1177
1178   /* Setup parameters to select T=1. */
1179   msg[0] = PC_to_RDR_SetParameters;
1180   msg[5] = 0; /* slot */
1181   msg[6] = seqno = handle->seqno++;
1182   msg[7] = 1; /* Select T=1. */
1183   msg[8] = 0; /* RFU */
1184   msg[9] = 0; /* RFU */
1185
1186   /* FIXME: Get those values from the ATR. */
1187   msg[10]= 0x01; /* Fi/Di */
1188   msg[11]= 0x10; /* LRC, direct convention. */
1189   msg[12]= 0;    /* Extra guardtime. */
1190   msg[13]= 0x41; /* BWI/CWI */
1191   msg[14]= 0;    /* No clock stoppping. */
1192   msg[15]= 254;  /* IFSC */
1193   msg[16]= 0;    /* Does not support non default NAD values. */
1194   set_msg_len (msg, 7);
1195   msglen = 10 + 7;
1196
1197   DEBUGOUT ("sending");
1198   for (i=0; i < msglen; i++)
1199     DEBUGOUT_CONT_1 (" %02X", msg[i]);
1200   DEBUGOUT_LF ();
1201
1202   rc = bulk_out (handle, msg, msglen);
1203   if (rc)
1204     return rc;
1205   /* Note that we ignore the error code on purpose. */
1206   bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters, seqno);
1207
1208
1209   /* Send an S-Block with our maximun IFSD to the CCID.  */
1210   if (!handle->auto_ifsd)
1211     {
1212       tpdu = msg+10;
1213       /* NAD: DAD=1, SAD=0 */
1214       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1215       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
1216       tpdu[2] = 1;
1217       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32; 
1218       tpdulen = 4;
1219       edc = compute_edc (tpdu, tpdulen, use_crc);
1220       if (use_crc)
1221         tpdu[tpdulen++] = (edc >> 8);
1222       tpdu[tpdulen++] = edc;
1223
1224       msg[0] = PC_to_RDR_XfrBlock;
1225       msg[5] = 0; /* slot */
1226       msg[6] = seqno = handle->seqno++;
1227       msg[7] = 0; 
1228       msg[8] = 0; /* RFU */
1229       msg[9] = 0; /* RFU */
1230       set_msg_len (msg, tpdulen);
1231       msglen = 10 + tpdulen;
1232
1233       DEBUGOUT ("sending");
1234       for (i=0; i < msglen; i++)
1235         DEBUGOUT_CONT_1 (" %02X", msg[i]);
1236       DEBUGOUT_LF ();
1237
1238 #ifdef DEBUG_T1      
1239       fprintf (stderr, "T1: put %c-block seq=%d\n",
1240                ((msg[11] & 0xc0) == 0x80)? 'R' :
1241                (msg[11] & 0x80)? 'S' : 'I',
1242                ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)));
1243 #endif  
1244
1245       rc = bulk_out (handle, msg, msglen);
1246       if (rc)
1247         return rc;
1248
1249       /* Fixme: The next line for the current Valgrid without support
1250          for USB IOCTLs. */
1251       memset (msg, 0, sizeof msg);
1252
1253       rc = bulk_in (handle, msg, sizeof msg, &msglen,
1254                     RDR_to_PC_DataBlock, seqno);
1255       if (rc)
1256         return rc;
1257       
1258       tpdu = msg + 10;
1259       tpdulen = msglen - 10;
1260       
1261       if (tpdulen < 4) 
1262         return CCID_DRIVER_ERR_ABORTED; 
1263
1264 #ifdef DEBUG_T1
1265       fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
1266                ((msg[11] & 0xc0) == 0x80)? 'R' :
1267                (msg[11] & 0x80)? 'S' : 'I',
1268                ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
1269                ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
1270                );
1271 #endif
1272       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
1273         {
1274           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
1275           return -1;
1276         }
1277       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
1278     }
1279
1280   return 0;
1281 }
1282
1283
1284 \f
1285
1286 static unsigned int 
1287 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
1288 {
1289   if (use_crc)
1290     {
1291       return 0x42; /* Not yet implemented. */
1292     }
1293   else
1294     {
1295       unsigned char crc = 0;
1296       
1297       for (; datalen; datalen--)
1298         crc ^= *data++;
1299       return crc;
1300     }
1301 }
1302
1303
1304 /*
1305   Protocol T=1 overview
1306
1307   Block Structure:
1308            Prologue Field:
1309    1 byte     Node Address (NAD) 
1310    1 byte     Protocol Control Byte (PCB)
1311    1 byte     Length (LEN) 
1312            Information Field:
1313    0-254 byte APDU or Control Information (INF)
1314            Epilogue Field:
1315    1 byte     Error Detection Code (EDC)
1316
1317   NAD:  
1318    bit 7     unused
1319    bit 4..6  Destination Node Address (DAD)
1320    bit 3     unused
1321    bit 2..0  Source Node Address (SAD)
1322
1323    If node adresses are not used, SAD and DAD should be set to 0 on
1324    the first block sent to the card.  If they are used they should
1325    have different values (0 for one is okay); that first block sets up
1326    the addresses of the nodes.
1327
1328   PCB:
1329    Information Block (I-Block):
1330       bit 7    0
1331       bit 6    Sequence number (yep, that is modulo 2)
1332       bit 5    Chaining flag 
1333       bit 4..0 reserved
1334    Received-Ready Block (R-Block):
1335       bit 7    1
1336       bit 6    0
1337       bit 5    0
1338       bit 4    Sequence number
1339       bit 3..0  0 = no error
1340                 1 = EDC or parity error
1341                 2 = other error
1342                 other values are reserved
1343    Supervisory Block (S-Block):
1344       bit 7    1
1345       bit 6    1
1346       bit 5    clear=request,set=response
1347       bit 4..0  0 = resyncronisation request
1348                 1 = information field size request
1349                 2 = abort request
1350                 3 = extension of BWT request
1351                 4 = VPP error
1352                 other values are reserved
1353
1354 */
1355
1356 int
1357 ccid_transceive (ccid_driver_t handle,
1358                  const unsigned char *apdu_buf, size_t apdu_buflen,
1359                  unsigned char *resp, size_t maxresplen, size_t *nresp)
1360 {
1361   int rc;
1362   unsigned char send_buffer[10+259], recv_buffer[10+259];
1363   const unsigned char *apdu;
1364   size_t apdulen;
1365   unsigned char *msg, *tpdu, *p;
1366   size_t msglen, tpdulen, last_tpdulen, n;
1367   unsigned char seqno;
1368   int i;
1369   unsigned int edc;
1370   int use_crc = 0;
1371   size_t dummy_nresp;
1372   int next_chunk = 1;
1373   int sending = 1;
1374   int retries = 0;
1375
1376   if (!nresp)
1377     nresp = &dummy_nresp;
1378   *nresp = 0;
1379
1380   tpdulen = 0; /* Avoid compiler warning about no initialization. */
1381   msg = send_buffer;
1382   for (;;)
1383     {
1384       if (next_chunk)
1385         {
1386           next_chunk = 0;
1387
1388           apdu = apdu_buf;
1389           apdulen = apdu_buflen;
1390           assert (apdulen);
1391
1392           /* Construct an I-Block. */
1393           if (apdulen > 254)
1394             return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
1395
1396           tpdu = msg+10;
1397           /* NAD: DAD=1, SAD=0 */
1398           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1399           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
1400           if (apdulen > 128 /* fixme: replace by ifsc */)
1401             {
1402               apdulen = 128;
1403               apdu_buf += 128;  
1404               apdu_buflen -= 128;
1405               tpdu[1] |= (1 << 5); /* Set more bit. */
1406             }
1407           tpdu[2] = apdulen;
1408           memcpy (tpdu+3, apdu, apdulen);
1409           tpdulen = 3 + apdulen;
1410           edc = compute_edc (tpdu, tpdulen, use_crc);
1411           if (use_crc)
1412             tpdu[tpdulen++] = (edc >> 8);
1413           tpdu[tpdulen++] = edc;
1414         }
1415
1416       msg[0] = PC_to_RDR_XfrBlock;
1417       msg[5] = 0; /* slot */
1418       msg[6] = seqno = handle->seqno++;
1419       msg[7] = 4; /* bBWI */
1420       msg[8] = 0; /* RFU */
1421       msg[9] = 0; /* RFU */
1422       set_msg_len (msg, tpdulen);
1423       msglen = 10 + tpdulen;
1424       last_tpdulen = tpdulen;
1425
1426       DEBUGOUT ("sending");
1427       for (i=0; i < msglen; i++)
1428         DEBUGOUT_CONT_1 (" %02X", msg[i]);
1429       DEBUGOUT_LF ();
1430
1431 #ifdef DEBUG_T1      
1432       fprintf (stderr, "T1: put %c-block seq=%d\n",
1433                ((msg[11] & 0xc0) == 0x80)? 'R' :
1434                (msg[11] & 0x80)? 'S' : 'I',
1435         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)));
1436 #endif  
1437
1438       rc = bulk_out (handle, msg, msglen);
1439       if (rc)
1440         return rc;
1441
1442       /* Fixme: The next line for the current Valgrid without support
1443          for USB IOCTLs. */
1444       memset (recv_buffer, 0, sizeof recv_buffer);
1445
1446       msg = recv_buffer;
1447       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
1448                     RDR_to_PC_DataBlock, seqno);
1449       if (rc)
1450         return rc;
1451       
1452       tpdu = msg + 10;
1453       tpdulen = msglen - 10;
1454       
1455       if (tpdulen < 4) 
1456         {
1457           usb_clear_halt (handle->idev, 0x82);
1458           return CCID_DRIVER_ERR_ABORTED; 
1459         }
1460 #ifdef DEBUG_T1
1461       fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
1462                ((msg[11] & 0xc0) == 0x80)? 'R' :
1463                (msg[11] & 0x80)? 'S' : 'I',
1464         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
1465                ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
1466                );
1467 #endif
1468
1469       if (!(tpdu[1] & 0x80))
1470         { /* This is an I-block. */
1471           retries = 0;
1472           if (sending)
1473             { /* last block sent was successful. */
1474               handle->t1_ns ^= 1;
1475               sending = 0;
1476             }
1477
1478           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
1479             { /* Reponse does not match our sequence number. */
1480               msg = send_buffer;
1481               tpdu = msg+10;
1482               /* NAD: DAD=1, SAD=0 */
1483               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1484               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
1485               tpdu[2] = 0;
1486               tpdulen = 3;
1487               edc = compute_edc (tpdu, tpdulen, use_crc);
1488               if (use_crc)
1489                 tpdu[tpdulen++] = (edc >> 8);
1490               tpdu[tpdulen++] = edc;
1491
1492               continue;
1493             }
1494
1495           handle->t1_nr ^= 1;
1496
1497           p = tpdu + 3; /* Skip the prologue field. */
1498           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
1499           /* fixme: verify the checksum. */
1500           if (resp)
1501             {
1502               if (n > maxresplen)
1503                 {
1504                   DEBUGOUT_2 ("provided buffer too short for received data "
1505                               "(%u/%u)\n",
1506                               (unsigned int)n, (unsigned int)maxresplen);
1507                   return CCID_DRIVER_ERR_INV_VALUE;
1508                 }
1509               
1510               memcpy (resp, p, n); 
1511               resp += n;
1512               *nresp += n;
1513               maxresplen -= n;
1514             }
1515           
1516           if (!(tpdu[1] & 0x20))
1517             return 0; /* No chaining requested - ready. */
1518           
1519           msg = send_buffer;
1520           tpdu = msg+10;
1521           /* NAD: DAD=1, SAD=0 */
1522           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1523           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
1524           tpdu[2] = 0;
1525           tpdulen = 3;
1526           edc = compute_edc (tpdu, tpdulen, use_crc);
1527           if (use_crc)
1528             tpdu[tpdulen++] = (edc >> 8);
1529           tpdu[tpdulen++] = edc;
1530         }
1531       else if ((tpdu[1] & 0xc0) == 0x80)
1532         { /* This is a R-block. */
1533           if ( (tpdu[1] & 0x0f)) 
1534             { /* Error: repeat last block */
1535               if (++retries > 3)
1536                 {
1537                   DEBUGOUT ("3 failed retries\n");
1538                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
1539                 }
1540               msg = send_buffer;
1541               tpdulen = last_tpdulen;
1542             }
1543           else if (sending && !!(tpdu[1] & 0x40) == handle->t1_ns)
1544             { /* Reponse does not match our sequence number. */
1545               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
1546               return CCID_DRIVER_ERR_CARD_IO_ERROR;
1547             }
1548           else if (sending)
1549             { /* Send next chunk. */
1550               retries = 0;
1551               msg = send_buffer;
1552               next_chunk = 1;
1553               handle->t1_ns ^= 1;
1554             }
1555           else
1556             {
1557               DEBUGOUT ("unexpected ACK R-block received\n");
1558               return CCID_DRIVER_ERR_CARD_IO_ERROR;
1559             }
1560         }
1561       else 
1562         { /* This is a S-block. */
1563           retries = 0;
1564           DEBUGOUT_2 ("T1 S-block %s received cmd=%d\n",
1565                       (tpdu[1] & 0x20)? "response": "request",
1566                       (tpdu[1] & 0x1f));
1567           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
1568             { /* Wait time extension request. */
1569               unsigned char bwi = tpdu[3];
1570               msg = send_buffer;
1571               tpdu = msg+10;
1572               /* NAD: DAD=1, SAD=0 */
1573               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1574               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
1575               tpdu[2] = 1;
1576               tpdu[3] = bwi;
1577               tpdulen = 4;
1578               edc = compute_edc (tpdu, tpdulen, use_crc);
1579               if (use_crc)
1580                 tpdu[tpdulen++] = (edc >> 8);
1581               tpdu[tpdulen++] = edc;
1582               DEBUGOUT_1 ("T1 waittime extension of bwi=%d\n", bwi);
1583             }
1584           else
1585             return CCID_DRIVER_ERR_CARD_IO_ERROR;
1586         }
1587     } /* end T=1 protocol loop. */
1588
1589   return 0;
1590 }
1591
1592
1593
1594
1595 #ifdef TEST
1596 int
1597 main (int argc, char **argv)
1598 {
1599   int rc;
1600   ccid_driver_t ccid;
1601   unsigned int slotstat;
1602
1603   ccid_set_debug_level (1);
1604
1605   rc = ccid_open_reader (&ccid, 0);
1606   if (rc)
1607     return 1;
1608
1609   ccid_poll (ccid);
1610   fputs ("getting ATR ...\n", stderr);
1611   rc = ccid_get_atr (ccid, NULL, 0, NULL);
1612   if (rc)
1613     return 1;
1614
1615   ccid_poll (ccid);
1616   fputs ("getting slot status ...\n", stderr);
1617   rc = ccid_slot_status (ccid, &slotstat);
1618   if (rc)
1619     return 1;
1620
1621   ccid_poll (ccid);
1622
1623   {
1624     static unsigned char apdu[] = {
1625       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
1626   rc = ccid_transceive (ccid,
1627                         apdu, sizeof apdu,
1628                         NULL, 0, NULL);
1629   }
1630   ccid_poll (ccid);
1631
1632   {
1633     static unsigned char apdu[] = {
1634       0, 0xCA, 0, 0x65, 254 };
1635   rc = ccid_transceive (ccid,
1636                         apdu, sizeof apdu,
1637                         NULL, 0, NULL);
1638   }
1639   ccid_poll (ccid);
1640
1641
1642   return 0;
1643 }
1644
1645 /*
1646  * Local Variables:
1647  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
1648  * End:
1649  */
1650 #endif /*TEST*/
1651 #endif /*HAVE_LIBUSB*/