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