0fc16859093e87522296e262b0d49cf33ed4fc74
[gnupg.git] / scd / ccid-driver.c
1 /* ccid-driver.c - USB ChipCardInterfaceDevices driver
2  *      Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3  *      Written by Werner Koch.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  *
21  * ALTERNATIVELY, this file may be distributed under the terms of the
22  * following license, in which case the provisions of this license are
23  * required INSTEAD OF the GNU General Public License. If you wish to
24  * allow use of your version of this file only under the terms of the
25  * GNU General Public License, and not to allow others to use your
26  * version of this file under the terms of the following license,
27  * indicate your decision by deleting this paragraph and the license
28  * below.
29  *
30  * Redistribution and use in source and binary forms, with or without
31  * modification, are permitted provided that the following conditions
32  * are met:
33  * 1. Redistributions of source code must retain the above copyright
34  *    notice, and the entire permission notice in its entirety,
35  *    including the disclaimer of warranties.
36  * 2. Redistributions in binary form must reproduce the above copyright
37  *    notice, this list of conditions and the following disclaimer in the
38  *    documentation and/or other materials provided with the distribution.
39  * 3. The name of the author may not be used to endorse or promote
40  *    products derived from this software without specific prior
41  *    written permission.
42  *
43  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
44  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
45  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
46  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
47  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
48  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
49  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
51  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
52  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
53  * OF THE POSSIBILITY OF SUCH DAMAGE.
54  */
55
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 /* Disable all debugging output for now. */
110 #undef DBG_CARD_IO
111 #define DBG_CARD_IO 0
112
113 /* Define to print information pertaining the T=1 protocol. */
114 #undef DEBUG_T1 
115
116
117 # define DEBUGOUT(t)         do { if (DBG_CARD_IO) \
118                                   log_debug (DRVNAME t); } while (0)
119 # define DEBUGOUT_1(t,a)     do { if (DBG_CARD_IO) \
120                                   log_debug (DRVNAME t,(a)); } while (0)
121 # define DEBUGOUT_2(t,a,b)   do { if (DBG_CARD_IO) \
122                                   log_debug (DRVNAME t,(a),(b)); } while (0)
123 # define DEBUGOUT_3(t,a,b,c) do { if (DBG_CARD_IO) \
124                                   log_debug (DRVNAME t,(a),(b),(c));} while (0)
125 # define DEBUGOUT_CONT(t)    do { if (DBG_CARD_IO) \
126                                   log_printf (t); } while (0)
127 # define DEBUGOUT_CONT_1(t,a)  do { if (DBG_CARD_IO) \
128                                   log_printf (t,(a)); } while (0)
129 # define DEBUGOUT_CONT_2(t,a,b)   do { if (DBG_CARD_IO) \
130                                   log_printf (t,(a),(b)); } while (0)
131 # define DEBUGOUT_CONT_3(t,a,b,c) do { if (DBG_CARD_IO) \
132                                   log_printf (t,(a),(b),(c)); } while (0)
133 # define DEBUGOUT_LF()       do { if (DBG_CARD_IO) \
134                                   log_printf ("\n"); } while (0)
135
136 #else /* Other usage of this source - don't use gnupg specifics. */
137
138 # define DEBUGOUT(t)          fprintf (stderr, DRVNAME t)
139 # define DEBUGOUT_1(t,a)      fprintf (stderr, DRVNAME t, (a))
140 # define DEBUGOUT_2(t,a,b)    fprintf (stderr, DRVNAME t, (a), (b))
141 # define DEBUGOUT_3(t,a,b,c)  fprintf (stderr, DRVNAME t, (a), (b), (c))
142 # define DEBUGOUT_CONT(t)     fprintf (stderr, t)
143 # define DEBUGOUT_CONT_1(t,a)      fprintf (stderr, t, (a))
144 # define DEBUGOUT_CONT_2(t,a,b)    fprintf (stderr, t, (a), (b))
145 # define DEBUGOUT_CONT_3(t,a,b,c)  fprintf (stderr, t, (a), (b), (c))
146 # define DEBUGOUT_LF()        putc ('\n', stderr)
147
148 #endif /* This source not used by scdaemon. */
149
150
151
152
153
154 enum {
155   RDR_to_PC_NotifySlotChange= 0x50,
156   RDR_to_PC_HardwareError   = 0x51,
157
158   PC_to_RDR_SetParameters   = 0x61,
159   PC_to_RDR_IccPowerOn      = 0x62,
160   PC_to_RDR_IccPowerOff     = 0x63,
161   PC_to_RDR_GetSlotStatus   = 0x65,
162   PC_to_RDR_Secure          = 0x69,
163   PC_to_RDR_T0APDU          = 0x6a,
164   PC_to_RDR_Escape          = 0x6b,
165   PC_to_RDR_GetParameters   = 0x6c,
166   PC_to_RDR_ResetParameters = 0x6d,
167   PC_to_RDR_IccClock        = 0x6e,
168   PC_to_RDR_XfrBlock        = 0x6f,
169   PC_to_RDR_Mechanical      = 0x71,
170   PC_to_RDR_Abort           = 0x72,
171   PC_to_RDR_SetDataRate     = 0x73,
172
173   RDR_to_PC_DataBlock       = 0x80,
174   RDR_to_PC_SlotStatus      = 0x81,
175   RDR_to_PC_Parameters      = 0x82,
176   RDR_to_PC_Escape          = 0x83,
177   RDR_to_PC_DataRate        = 0x84
178 };
179
180
181 /* Store information on the driver's state.  A pointer to such a
182    structure is used as handle for most functions. */
183 struct ccid_driver_s {
184   usb_dev_handle *idev;
185   int seqno;
186   unsigned char t1_ns;
187   unsigned char t1_nr;
188   int nonnull_nad;
189   int auto_ifsd;
190   int max_ifsd;
191   int ifsd;
192 };
193
194
195 static unsigned int compute_edc (const unsigned char *data, size_t datalen,
196                                  int use_crc);
197 static int bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen);
198 static int bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
199                     size_t *nread, int expected_type, int seqno);
200
201
202
203 /* Convert a little endian stored 4 byte value into an unsigned
204    integer. */
205 static unsigned int 
206 convert_le_u32 (const unsigned char *buf)
207 {
208   return buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24); 
209 }
210
211 static void
212 set_msg_len (unsigned char *msg, unsigned int length)
213 {
214   msg[1] = length;
215   msg[2] = length >> 8;
216   msg[3] = length >> 16;
217   msg[4] = length >> 24;
218 }
219
220
221
222
223 /* Parse a CCID descriptor, optionally print all available features
224    and test whether this reader is usable by this driver.  Returns 0
225    if it is usable.
226
227    Note, that this code is based on the one in lsusb.c of the
228    usb-utils package, I wrote on 2003-09-01. -wk. */
229 static int
230 parse_ccid_descriptor (ccid_driver_t handle,
231                        const unsigned char *buf, size_t buflen)
232 {
233   unsigned int i;
234   unsigned int us;
235   int have_t1 = 0, have_tpdu=0, have_auto_conf = 0;
236
237
238   handle->nonnull_nad = 0;
239   handle->auto_ifsd = 0;
240   handle->max_ifsd = 32;
241   handle->ifsd = 0;
242   if (buflen < 54 || buf[0] < 54)
243     {
244       DEBUGOUT ("CCID device descriptor is too short\n");
245       return -1;
246     }
247
248   DEBUGOUT   ("ChipCard Interface Descriptor:\n");
249   DEBUGOUT_1 ("  bLength             %5u\n", buf[0]);
250   DEBUGOUT_1 ("  bDescriptorType     %5u\n", buf[1]);
251   DEBUGOUT_2 ("  bcdCCID             %2x.%02x", buf[3], buf[2]);
252     if (buf[3] != 1 || buf[2] != 0) 
253       DEBUGOUT_CONT("  (Warning: Only accurate for version 1.0)");
254   DEBUGOUT_LF ();
255
256   DEBUGOUT_1 ("  nMaxSlotIndex       %5u\n", buf[4]);
257   DEBUGOUT_2 ("  bVoltageSupport     %5u  %s\n",
258               buf[5], (buf[5] == 1? "5.0V" : buf[5] == 2? "3.0V"
259                        : buf[5] == 3? "1.8V":"?"));
260
261   us = convert_le_u32 (buf+6);
262   DEBUGOUT_1 ("  dwProtocols         %5u ", us);
263   if ((us & 1))
264     DEBUGOUT_CONT (" T=0");
265   if ((us & 2))
266     {
267       DEBUGOUT_CONT (" T=1");
268       have_t1 = 1;
269     }
270   if ((us & ~3))
271     DEBUGOUT_CONT (" (Invalid values detected)");
272   DEBUGOUT_LF ();
273
274   us = convert_le_u32(buf+10);
275   DEBUGOUT_1 ("  dwDefaultClock      %5u\n", us);
276   us = convert_le_u32(buf+14);
277   DEBUGOUT_1 ("  dwMaxiumumClock     %5u\n", us);
278   DEBUGOUT_1 ("  bNumClockSupported  %5u\n", buf[18]);
279   us = convert_le_u32(buf+19);
280   DEBUGOUT_1 ("  dwDataRate        %7u bps\n", us);
281   us = convert_le_u32(buf+23);
282   DEBUGOUT_1 ("  dwMaxDataRate     %7u bps\n", us);
283   DEBUGOUT_1 ("  bNumDataRatesSupp.  %5u\n", buf[27]);
284         
285   us = convert_le_u32(buf+28);
286   DEBUGOUT_1 ("  dwMaxIFSD           %5u\n", us);
287   handle->max_ifsd = us;
288
289   us = convert_le_u32(buf+32);
290   DEBUGOUT_1 ("  dwSyncProtocols  %08X ", us);
291   if ((us&1))
292     DEBUGOUT_CONT ( " 2-wire");
293   if ((us&2))
294     DEBUGOUT_CONT ( " 3-wire");
295   if ((us&4))
296     DEBUGOUT_CONT ( " I2C");
297   DEBUGOUT_LF ();
298
299   us = convert_le_u32(buf+36);
300   DEBUGOUT_1 ("  dwMechanical     %08X ", us);
301   if ((us & 1))
302     DEBUGOUT_CONT (" accept");
303   if ((us & 2))
304     DEBUGOUT_CONT (" eject");
305   if ((us & 4))
306     DEBUGOUT_CONT (" capture");
307   if ((us & 8))
308     DEBUGOUT_CONT (" lock");
309   DEBUGOUT_LF ();
310
311   us = convert_le_u32(buf+40);
312   DEBUGOUT_1 ("  dwFeatures       %08X\n", us);
313   if ((us & 0x0002))
314     {
315       DEBUGOUT ("    Auto configuration based on ATR\n");
316       have_auto_conf = 1;
317     }
318   if ((us & 0x0004))
319     DEBUGOUT ("    Auto activation on insert\n");
320   if ((us & 0x0008))
321     DEBUGOUT ("    Auto voltage selection\n");
322   if ((us & 0x0010))
323     DEBUGOUT ("    Auto clock change\n");
324   if ((us & 0x0020))
325     DEBUGOUT ("    Auto baud rate change\n");
326   if ((us & 0x0040))
327     DEBUGOUT ("    Auto parameter negotation made by CCID\n");
328   else if ((us & 0x0080))
329     DEBUGOUT ("    Auto PPS made by CCID\n");
330   else if ((us & (0x0040 | 0x0080)))
331     DEBUGOUT ("    WARNING: conflicting negotation features\n");
332
333   if ((us & 0x0100))
334     DEBUGOUT ("    CCID can set ICC in clock stop mode\n");
335   if ((us & 0x0200))
336     {
337       DEBUGOUT ("    NAD value other than 0x00 accepted\n");
338       handle->nonnull_nad = 1;
339     }
340   if ((us & 0x0400))
341     {
342       DEBUGOUT ("    Auto IFSD exchange\n");
343       handle->auto_ifsd = 1;
344     }
345
346   if ((us & 0x00010000))
347     {
348       DEBUGOUT ("    TPDU level exchange\n");
349       have_tpdu = 1;
350     } 
351   else if ((us & 0x00020000))
352     DEBUGOUT ("    Short APDU level exchange\n");
353   else if ((us & 0x00040000))
354     DEBUGOUT ("    Short and extended APDU level exchange\n");
355   else if ((us & 0x00070000))
356     DEBUGOUT ("    WARNING: conflicting exchange levels\n");
357
358   us = convert_le_u32(buf+44);
359   DEBUGOUT_1 ("  dwMaxCCIDMsgLen     %5u\n", us);
360
361   DEBUGOUT (  "  bClassGetResponse    ");
362   if (buf[48] == 0xff)
363     DEBUGOUT_CONT ("echo\n");
364   else
365     DEBUGOUT_CONT_1 ("  %02X\n", buf[48]);
366
367   DEBUGOUT (  "  bClassEnvelope       ");
368   if (buf[49] == 0xff)
369     DEBUGOUT_CONT ("echo\n");
370   else
371     DEBUGOUT_1 ("  %02X\n", buf[48]);
372
373   DEBUGOUT (  "  wlcdLayout           ");
374   if (!buf[50] && !buf[51])
375     DEBUGOUT_CONT ("none\n");
376   else
377     DEBUGOUT_CONT_2 ("%u cols %u lines\n", buf[50], buf[51]);
378         
379   DEBUGOUT_1 ("  bPINSupport         %5u ", buf[52]);
380   if ((buf[52] & 1))
381     DEBUGOUT_CONT ( " verification");
382   if ((buf[52] & 2))
383     DEBUGOUT_CONT ( " modification");
384   DEBUGOUT_LF ();
385         
386   DEBUGOUT_1 ("  bMaxCCIDBusySlots   %5u\n", buf[53]);
387
388   if (buf[0] > 54) {
389     DEBUGOUT ("  junk             ");
390     for (i=54; i < buf[0]-54; i++)
391       DEBUGOUT_CONT_1 (" %02X", buf[i]);
392     DEBUGOUT_LF ();
393   }
394
395   if (!have_t1 || !have_tpdu || !have_auto_conf)
396     {
397       DEBUGOUT ("this drivers requires that the reader supports T=1, "
398                 "TPDU level exchange and auto configuration - "
399                 "this is not available\n");
400       return -1;
401     }
402   else
403     return 0;
404 }
405
406
407 /* Read the device information, return all required data and check
408    that the device is usable for us.  Returns 0 on success or an error
409    code. */
410 static int
411 read_device_info (ccid_driver_t handle, struct usb_device *dev)
412 {
413   int cfg_no;
414
415   for (cfg_no=0; cfg_no <
416 #ifdef HAVE_USB_CREATE_MATCH
417          dev->descriptor->bNumConfigurations
418 #else
419          dev->descriptor.bNumConfigurations
420 #endif
421          ; cfg_no++)
422     {
423       struct usb_config_descriptor *config = dev->config + cfg_no;
424       int ifc_no;
425
426       for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
427         {
428           struct usb_interface *interface = config->interface + ifc_no;
429           int set_no;
430
431           for (set_no=0; set_no < interface->num_altsetting; set_no++)
432             {
433               struct usb_interface_descriptor *ifcdesc
434                 = interface->altsetting + set_no;
435               
436               if (ifcdesc->bInterfaceClass == 11
437                   && ifcdesc->bInterfaceSubClass == 0
438                   && ifcdesc->bInterfaceProtocol == 0)
439                 {
440                   if (ifcdesc->extra)
441                     {
442                       if (!parse_ccid_descriptor (handle, 
443                                                   ifcdesc->extra,
444                                                   ifcdesc->extralen))
445                         return 0; /* okay. we can use it. */
446                     }
447                 }
448             }
449         }
450     }
451   return CCID_DRIVER_ERR_NO_READER; /* No suitable device found. */
452 }
453
454
455 /* Open the reader with the internal number READERNO and return a 
456    pointer to be used as handle in HANDLE.  Returns 0 on success. */
457 int 
458 ccid_open_reader (ccid_driver_t *handle, int readerno)
459 {
460 #ifdef HAVE_USB_CREATE_MATCH
461   /* This is the development version of libusb. */  
462   static int initialized;
463   int rc;
464   usb_match_handle *match = NULL;
465   struct usb_device *dev = NULL;
466   usb_dev_handle *idev = NULL;
467
468   *handle = NULL;
469   if (!initialized)
470     {
471       usb_init ();
472       initialized = 1;
473     }
474   
475   rc = usb_create_match (&match, -1, -1, 11, -1, -1);
476   if (rc)
477     {
478       DEBUGOUT_1 ("usb_create_match failed: %d\n", rc);
479       return CCID_DRIVER_ERR_NO_READER;
480     }
481   
482   while (usb_find_device(match, dev, &dev) >= 0) 
483     {
484       DEBUGOUT_3 ("%-40s %04X/%04X\n", dev->filename,
485                   dev->descriptor->idVendor, dev->descriptor->idProduct);
486       if (!readerno)
487         {
488           *handle = calloc (1, sizeof **handle);
489           if (!*handle)
490             {
491               DEBUGOUT ("out of memory\n");
492               rc = CCID_DRIVER_ERR_OUT_OF_CORE;
493               free (*handle);
494               *handle = NULL;
495               goto leave;
496             }
497
498           rc = read_device_info (*handle, dev);
499           if (rc)
500             {
501               DEBUGOUT ("device not supported\n");
502               free (*handle);
503               *handle = NULL;
504               goto leave;
505             }
506
507           rc = usb_open (dev, &idev);
508           if (rc)
509             {
510               DEBUGOUT_1 ("usb_open failed: %d\n", rc);
511               free (*handle);
512               *handle = NULL;
513               rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
514               goto leave;
515             }
516
517
518           /* fixme: Do we need to claim and set the interface as
519              determined by read_device_info ()? */
520           rc = usb_claim_interface (idev, 0);
521           if (rc)
522             {
523               DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
524               free (*handle);
525               *handle = NULL;
526               rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
527               goto leave;
528             }
529
530           (*handle)->idev = idev;
531           idev = NULL;
532           /* FIXME: Do we need to get the endpoint addresses from the
533              structure and store them with the handle? */
534
535           break;
536         }
537       readerno--;
538     }
539
540  leave:
541   if (idev)
542     usb_close (idev);
543   /* fixme: Do we need to release dev or is it supposed to be a
544      shallow copy of the list created internally by usb_init ? */
545   usb_free_match (match);
546
547   if (!rc && !*handle)
548     rc = -1; /* In case we didn't enter the while loop at all. */
549
550   return rc;
551 #else /* Stable 0.1 version of libusb.  */
552   static int initialized;
553   int rc = 0;
554   struct usb_bus *busses, *bus;
555   struct usb_device *dev = NULL;
556   usb_dev_handle *idev = NULL;
557
558   *handle = NULL;
559   if (!initialized)
560     {
561       usb_init ();
562       initialized = 1;
563     }
564   
565   usb_find_busses();
566   usb_find_devices();
567   busses = usb_get_busses();
568
569   for (bus = busses; bus; bus = bus->next) 
570     {
571       for (dev = bus->devices; dev; dev = dev->next)
572         {
573           DEBUGOUT_3 ("%-40s %04X/%04X\n", dev->filename,
574                       dev->descriptor.idVendor, dev->descriptor.idProduct);
575
576           if (!readerno)
577             {
578               *handle = calloc (1, sizeof **handle);
579               if (!*handle)
580                 {
581                   DEBUGOUT ("out of memory\n");
582                   rc = CCID_DRIVER_ERR_OUT_OF_CORE;
583                   free (*handle);
584                   *handle = NULL;
585                   goto leave;
586                 }
587
588               rc = read_device_info (*handle, dev);
589               if (rc)
590                 {
591                   DEBUGOUT ("device not supported\n");
592                   free (*handle);
593                   *handle = NULL;
594                   continue;
595                 }
596
597               idev = usb_open (dev);
598               if (!idev)
599                 {
600                   DEBUGOUT_1 ("usb_open failed: %s\n", strerror (errno));
601                   free (*handle);
602                   *handle = NULL;
603                   rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
604                   goto leave;
605                 }
606
607               /* fixme: Do we need to claim and set the interface as
608                  determined by read_device_info ()? */
609               rc = usb_claim_interface (idev, 0);
610               if (rc)
611                 {
612                   DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
613                   free (*handle);
614                   *handle = NULL;
615                   rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
616                   goto leave;
617                 }
618
619               (*handle)->idev = idev;
620               idev = NULL;
621               /* FIXME: Do we need to get the endpoint addresses from the
622                  structure and store them with the handle? */
623               
624               goto leave; /* ready. */
625             }
626           readerno--;
627         }
628     }
629
630  leave:
631   if (idev)
632     usb_close (idev);
633   /* fixme: Do we need to release dev or is it supposed to be a
634      shallow copy of the list created internally by usb_init ? */
635
636   if (!rc && !*handle)
637     rc = -1; /* In case we didn't enter the while loop at all. */
638
639   return rc;
640 #endif /* Stable version 0.1 of libusb.  */
641 }
642
643
644 /* Close the reader HANDLE. */
645 int 
646 ccid_close_reader (ccid_driver_t handle)
647 {
648   if (!handle || !handle->idev)
649     return 0;
650
651    {
652      int rc;
653      unsigned char msg[100];
654      size_t msglen;
655      unsigned char seqno;
656    
657      msg[0] = PC_to_RDR_IccPowerOff;
658      msg[5] = 0; /* slot */
659      msg[6] = seqno = handle->seqno++;
660      msg[7] = 0; /* RFU */
661      msg[8] = 0; /* RFU */
662      msg[9] = 0; /* RFU */
663      set_msg_len (msg, 0);
664      msglen = 10;
665    
666      rc = bulk_out (handle, msg, msglen);
667      if (!rc)
668         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus, seqno);
669    }
670    
671   usb_release_interface (handle->idev, 0);
672   usb_close (handle->idev);
673   handle->idev = NULL;
674   free (handle);
675   return 0;
676 }
677
678
679 /* Return False if a card is present and powered. */
680 int
681 ccid_check_card_presence (ccid_driver_t handle)
682 {
683
684   return -1;
685 }
686
687
688 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
689    Returns 0 on success. */
690 static int
691 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen)
692 {
693   int rc;
694
695   rc = usb_bulk_write (handle->idev, 
696                        1, /*endpoint */
697                        msg, msglen,
698                        1000 /* ms timeout */);
699   if (rc == msglen)
700     return 0;
701
702   if (rc == -1)
703     DEBUGOUT_1 ("usb_bulk_write error: %s\n", strerror (errno));
704   else
705     DEBUGOUT_1 ("usb_bulk_write failed: %d\n", rc);
706   return CCID_DRIVER_ERR_CARD_IO_ERROR;
707 }
708
709
710 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
711    BUFFER and return the actual read number if bytes in NREAD. SEQNO
712    is the sequence number used to send the request and EXPECTED_TYPE
713    the type of message we expect. Does checks on the ccid
714    header. Returns 0 on success. */
715 static int
716 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
717          size_t *nread, int expected_type, int seqno)
718 {
719   int i, rc;
720   size_t msglen;
721
722  retry:
723   rc = usb_bulk_read (handle->idev, 
724                       0x82,
725                       buffer, length,
726                       10000 /* ms timeout */ );
727   /* Fixme: instead of using a 10 second timeout we should better
728      handle the timeout here and retry if appropriate.  */
729   if (rc < 0)
730     {
731       DEBUGOUT_1 ("usb_bulk_read error: %s\n", strerror (errno));
732       return CCID_DRIVER_ERR_CARD_IO_ERROR;
733     }
734
735   *nread = msglen = rc;
736
737   if (msglen < 10)
738     {
739       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
740       return CCID_DRIVER_ERR_INV_VALUE;
741     }
742   if (buffer[0] != expected_type)
743     {
744       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
745       return CCID_DRIVER_ERR_INV_VALUE;
746     }
747   if (buffer[5] != 0)    
748     {
749       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
750       return CCID_DRIVER_ERR_INV_VALUE;
751     }
752   if (buffer[6] != seqno)    
753     {
754       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
755                   seqno, buffer[6]);
756       return CCID_DRIVER_ERR_INV_VALUE;
757     }
758
759   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
760     { 
761       /* Card present and active, time extension requested. */
762       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
763                   buffer[7], buffer[8]);
764       goto retry;
765     }
766   
767   DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n"
768               "               data:",  buffer[7], buffer[8], buffer[9] );
769   for (i=10; i < msglen; i++)
770     DEBUGOUT_CONT_1 (" %02X", buffer[i]);
771   DEBUGOUT_LF ();
772
773   switch ((buffer[7] & 0x03))
774     {
775     case 0: /* no error */ break;
776     case 1: return CCID_DRIVER_ERR_CARD_INACTIVE;
777     case 2: return CCID_DRIVER_ERR_NO_CARD;
778     case 3: /* RFU */ break;
779     }
780   return 0;
781 }
782
783
784 /* experimental */
785 int
786 ccid_poll (ccid_driver_t handle)
787 {
788   int rc;
789   unsigned char msg[10];
790   size_t msglen;
791   int i, j;
792
793   rc = usb_bulk_read (handle->idev, 
794                       0x83,
795                       msg, sizeof msg,
796                       0 /* ms timeout */ );
797   if (rc < 0 && errno == ETIMEDOUT)
798     return 0;
799
800   if (rc < 0)
801     {
802       DEBUGOUT_1 ("usb_intr_read error: %s\n", strerror (errno));
803       return CCID_DRIVER_ERR_CARD_IO_ERROR;
804     }
805
806   msglen = rc;
807   rc = 0;
808
809   if (msglen < 1)
810     {
811       DEBUGOUT ("intr-in msg too short\n");
812       return CCID_DRIVER_ERR_INV_VALUE;
813     }
814
815   if (msg[0] == RDR_to_PC_NotifySlotChange)
816     {
817       DEBUGOUT ("notify slot change:");
818       for (i=1; i < msglen; i++)
819         for (j=0; j < 4; j++)
820           DEBUGOUT_CONT_3 (" %d:%c%c",
821                            (i-1)*4+j, 
822                            (msg[i] & (1<<(j*2)))? 'p':'-',
823                            (msg[i] & (2<<(j*2)))? '*':' ');
824       DEBUGOUT_LF ();
825     }
826   else if (msg[0] == RDR_to_PC_HardwareError)    
827     {
828       DEBUGOUT ("hardware error occured\n");
829     }
830   else
831     {
832       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
833     }
834
835   return 0;
836 }
837
838
839 /* Note that this fucntion won't return the error codes NO_CARD or
840    CARD_INACTIVE */
841 int 
842 ccid_slot_status (ccid_driver_t handle, int *statusbits)
843 {
844   int rc;
845   unsigned char msg[100];
846   size_t msglen;
847   unsigned char seqno;
848
849   msg[0] = PC_to_RDR_GetSlotStatus;
850   msg[5] = 0; /* slot */
851   msg[6] = seqno = handle->seqno++;
852   msg[7] = 0; /* RFU */
853   msg[8] = 0; /* RFU */
854   msg[9] = 0; /* RFU */
855   set_msg_len (msg, 0);
856
857   rc = bulk_out (handle, msg, 10);
858   if (rc)
859     return rc;
860   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus, seqno);
861   if (rc && rc != CCID_DRIVER_ERR_NO_CARD
862       && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
863     return rc;
864   *statusbits = (msg[7] & 3);
865
866   return 0;
867 }
868
869
870 int 
871 ccid_get_atr (ccid_driver_t handle,
872               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
873 {
874   int rc;
875   unsigned char msg[100];
876   unsigned char *tpdu;
877   size_t msglen, tpdulen;
878   unsigned char seqno;
879   int use_crc = 0;
880   unsigned int edc;
881   int i;
882
883   msg[0] = PC_to_RDR_IccPowerOn;
884   msg[5] = 0; /* slot */
885   msg[6] = seqno = handle->seqno++;
886   msg[7] = 0; /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
887   msg[8] = 0; /* RFU */
888   msg[9] = 0; /* RFU */
889   set_msg_len (msg, 0);
890   msglen = 10;
891
892   rc = bulk_out (handle, msg, msglen);
893   if (rc)
894     return rc;
895   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock, seqno);
896   if (rc)
897     return rc;
898   
899   if (atr)
900     {
901       size_t n = msglen - 10;
902
903       if (n > maxatrlen)
904         n = maxatrlen;
905       memcpy (atr, msg+10, n);
906       *atrlen = n;
907     }
908
909   /* Setup parameters to select T=1. */
910   msg[0] = PC_to_RDR_SetParameters;
911   msg[5] = 0; /* slot */
912   msg[6] = seqno = handle->seqno++;
913   msg[7] = 1; /* Select T=1. */
914   msg[8] = 0; /* RFU */
915   msg[9] = 0; /* RFU */
916
917   /* FIXME: Get those values from the ATR. */
918   msg[10]= 0x01; /* Fi/Di */
919   msg[11]= 0x10; /* LRC, direct convention. */
920   msg[12]= 0;    /* Extra guardtime. */
921   msg[13]= 0x41; /* BWI/CWI */
922   msg[14]= 0;    /* No clock stoppping. */
923   msg[15]= 254;  /* IFSC */
924   msg[16]= 0;    /* Does not support non default NAD values. */
925   set_msg_len (msg, 7);
926   msglen = 10 + 7;
927
928   DEBUGOUT ("sending");
929   for (i=0; i < msglen; i++)
930     DEBUGOUT_CONT_1 (" %02X", msg[i]);
931   DEBUGOUT_LF ();
932
933   rc = bulk_out (handle, msg, msglen);
934   if (rc)
935     return rc;
936   /* Note that we ignore the error code on purpose. */
937   bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters, seqno);
938
939
940   /* Send an S-Block with our maximun IFSD to the CCID.  */
941   if (!handle->auto_ifsd)
942     {
943       tpdu = msg+10;
944       /* NAD: DAD=1, SAD=0 */
945       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
946       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
947       tpdu[2] = 1;
948       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32; 
949       tpdulen = 4;
950       edc = compute_edc (tpdu, tpdulen, use_crc);
951       if (use_crc)
952         tpdu[tpdulen++] = (edc >> 8);
953       tpdu[tpdulen++] = edc;
954
955       msg[0] = PC_to_RDR_XfrBlock;
956       msg[5] = 0; /* slot */
957       msg[6] = seqno = handle->seqno++;
958       msg[7] = 0; 
959       msg[8] = 0; /* RFU */
960       msg[9] = 0; /* RFU */
961       set_msg_len (msg, tpdulen);
962       msglen = 10 + tpdulen;
963
964       DEBUGOUT ("sending");
965       for (i=0; i < msglen; i++)
966         DEBUGOUT_CONT_1 (" %02X", msg[i]);
967       DEBUGOUT_LF ();
968
969 #ifdef DEBUG_T1      
970       fprintf (stderr, "T1: put %c-block seq=%d\n",
971                ((msg[11] & 0xc0) == 0x80)? 'R' :
972                (msg[11] & 0x80)? 'S' : 'I',
973                ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)));
974 #endif  
975
976       rc = bulk_out (handle, msg, msglen);
977       if (rc)
978         return rc;
979
980       /* Fixme: The next line for the current Valgrid without support
981          for USB IOCTLs. */
982       memset (msg, 0, sizeof msg);
983
984       rc = bulk_in (handle, msg, sizeof msg, &msglen,
985                     RDR_to_PC_DataBlock, seqno);
986       if (rc)
987         return rc;
988       
989       tpdu = msg + 10;
990       tpdulen = msglen - 10;
991       
992       if (tpdulen < 4) 
993         return CCID_DRIVER_ERR_ABORTED; 
994
995 #ifdef DEBUG_T1
996       fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
997                ((msg[11] & 0xc0) == 0x80)? 'R' :
998                (msg[11] & 0x80)? 'S' : 'I',
999                ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
1000                ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
1001                );
1002 #endif
1003       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
1004         {
1005           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
1006           return -1;
1007         }
1008       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
1009     }
1010
1011   return 0;
1012 }
1013
1014
1015 \f
1016
1017 static unsigned int 
1018 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
1019 {
1020   if (use_crc)
1021     {
1022       return 0x42; /* Not yet implemented. */
1023     }
1024   else
1025     {
1026       unsigned char crc = 0;
1027       
1028       for (; datalen; datalen--)
1029         crc ^= *data++;
1030       return crc;
1031     }
1032 }
1033
1034
1035 /*
1036   Protocol T=1 overview
1037
1038   Block Structure:
1039            Prologue Field:
1040    1 byte     Node Address (NAD) 
1041    1 byte     Protocol Control Byte (PCB)
1042    1 byte     Length (LEN) 
1043            Information Field:
1044    0-254 byte APDU or Control Information (INF)
1045            Epilogue Field:
1046    1 byte     Error Detection Code (EDC)
1047
1048   NAD:  
1049    bit 7     unused
1050    bit 4..6  Destination Node Address (DAD)
1051    bit 3     unused
1052    bit 2..0  Source Node Address (SAD)
1053
1054    If node adresses are not used, SAD and DAD should be set to 0 on
1055    the first block sent to the card.  If they are used they should
1056    have different values (0 for one is okay); that first block sets up
1057    the addresses of the nodes.
1058
1059   PCB:
1060    Information Block (I-Block):
1061       bit 7    0
1062       bit 6    Sequence number (yep, that is modulo 2)
1063       bit 5    Chaining flag 
1064       bit 4..0 reserved
1065    Received-Ready Block (R-Block):
1066       bit 7    1
1067       bit 6    0
1068       bit 5    0
1069       bit 4    Sequence number
1070       bit 3..0  0 = no error
1071                 1 = EDC or parity error
1072                 2 = other error
1073                 other values are reserved
1074    Supervisory Block (S-Block):
1075       bit 7    1
1076       bit 6    1
1077       bit 5    clear=request,set=response
1078       bit 4..0  0 = resyncronisation request
1079                 1 = information field size request
1080                 2 = abort request
1081                 3 = extension of BWT request
1082                 4 = VPP error
1083                 other values are reserved
1084
1085 */
1086
1087 int
1088 ccid_transceive (ccid_driver_t handle,
1089                  const unsigned char *apdu_buf, size_t apdu_buflen,
1090                  unsigned char *resp, size_t maxresplen, size_t *nresp)
1091 {
1092   int rc;
1093   unsigned char send_buffer[10+259], recv_buffer[10+259];
1094   const unsigned char *apdu;
1095   size_t apdulen;
1096   unsigned char *msg, *tpdu, *p;
1097   size_t msglen, tpdulen, last_tpdulen, n;
1098   unsigned char seqno;
1099   int i;
1100   unsigned int edc;
1101   int use_crc = 0;
1102   size_t dummy_nresp;
1103   int next_chunk = 1;
1104   int sending = 1;
1105   int retries = 0;
1106
1107   if (!nresp)
1108     nresp = &dummy_nresp;
1109   *nresp = 0;
1110
1111   tpdulen = 0; /* Avoid compiler warning about no initialization. */
1112   msg = send_buffer;
1113   for (;;)
1114     {
1115       if (next_chunk)
1116         {
1117           next_chunk = 0;
1118
1119           apdu = apdu_buf;
1120           apdulen = apdu_buflen;
1121           assert (apdulen);
1122
1123           /* Construct an I-Block. */
1124           if (apdulen > 254)
1125             return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
1126
1127           tpdu = msg+10;
1128           /* NAD: DAD=1, SAD=0 */
1129           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1130           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
1131           if (apdulen > 128 /* fixme: replace by ifsc */)
1132             {
1133               apdulen = 128;
1134               apdu_buf += 128;  
1135               apdu_buflen -= 128;
1136               tpdu[1] |= (1 << 5); /* Set more bit. */
1137             }
1138           tpdu[2] = apdulen;
1139           memcpy (tpdu+3, apdu, apdulen);
1140           tpdulen = 3 + apdulen;
1141           edc = compute_edc (tpdu, tpdulen, use_crc);
1142           if (use_crc)
1143             tpdu[tpdulen++] = (edc >> 8);
1144           tpdu[tpdulen++] = edc;
1145         }
1146
1147       msg[0] = PC_to_RDR_XfrBlock;
1148       msg[5] = 0; /* slot */
1149       msg[6] = seqno = handle->seqno++;
1150       msg[7] = 4; /* bBWI */
1151       msg[8] = 0; /* RFU */
1152       msg[9] = 0; /* RFU */
1153       set_msg_len (msg, tpdulen);
1154       msglen = 10 + tpdulen;
1155       last_tpdulen = tpdulen;
1156
1157       DEBUGOUT ("sending");
1158       for (i=0; i < msglen; i++)
1159         DEBUGOUT_CONT_1 (" %02X", msg[i]);
1160       DEBUGOUT_LF ();
1161
1162 #ifdef DEBUG_T1      
1163       fprintf (stderr, "T1: put %c-block seq=%d\n",
1164                ((msg[11] & 0xc0) == 0x80)? 'R' :
1165                (msg[11] & 0x80)? 'S' : 'I',
1166         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)));
1167 #endif  
1168
1169       rc = bulk_out (handle, msg, msglen);
1170       if (rc)
1171         return rc;
1172
1173       /* Fixme: The next line for the current Valgrid without support
1174          for USB IOCTLs. */
1175       memset (recv_buffer, 0, sizeof recv_buffer);
1176
1177       msg = recv_buffer;
1178       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
1179                     RDR_to_PC_DataBlock, seqno);
1180       if (rc)
1181         return rc;
1182       
1183       tpdu = msg + 10;
1184       tpdulen = msglen - 10;
1185       
1186       if (tpdulen < 4) 
1187         {
1188           usb_clear_halt (handle->idev, 0x82);
1189           return CCID_DRIVER_ERR_ABORTED; 
1190         }
1191 #ifdef DEBUG_T1
1192       fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
1193                ((msg[11] & 0xc0) == 0x80)? 'R' :
1194                (msg[11] & 0x80)? 'S' : 'I',
1195         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
1196                ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
1197                );
1198 #endif
1199
1200       if (!(tpdu[1] & 0x80))
1201         { /* This is an I-block. */
1202           retries = 0;
1203           if (sending)
1204             { /* last block sent was successful. */
1205               handle->t1_ns ^= 1;
1206               sending = 0;
1207             }
1208
1209           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
1210             { /* Reponse does not match our sequence number. */
1211               msg = send_buffer;
1212               tpdu = msg+10;
1213               /* NAD: DAD=1, SAD=0 */
1214               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1215               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
1216               tpdu[2] = 0;
1217               tpdulen = 3;
1218               edc = compute_edc (tpdu, tpdulen, use_crc);
1219               if (use_crc)
1220                 tpdu[tpdulen++] = (edc >> 8);
1221               tpdu[tpdulen++] = edc;
1222
1223               continue;
1224             }
1225
1226           handle->t1_nr ^= 1;
1227
1228           p = tpdu + 3; /* Skip the prologue field. */
1229           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
1230           /* fixme: verify the checksum. */
1231           if (resp)
1232             {
1233               if (n > maxresplen)
1234                 {
1235                   DEBUGOUT_2 ("provided buffer too short for received data "
1236                               "(%u/%u)\n",
1237                               (unsigned int)n, (unsigned int)maxresplen);
1238                   return CCID_DRIVER_ERR_INV_VALUE;
1239                 }
1240               
1241               memcpy (resp, p, n); 
1242               resp += n;
1243               *nresp += n;
1244               maxresplen -= n;
1245             }
1246           
1247           if (!(tpdu[1] & 0x20))
1248             return 0; /* No chaining requested - ready. */
1249           
1250           msg = send_buffer;
1251           tpdu = msg+10;
1252           /* NAD: DAD=1, SAD=0 */
1253           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1254           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
1255           tpdu[2] = 0;
1256           tpdulen = 3;
1257           edc = compute_edc (tpdu, tpdulen, use_crc);
1258           if (use_crc)
1259             tpdu[tpdulen++] = (edc >> 8);
1260           tpdu[tpdulen++] = edc;
1261         }
1262       else if ((tpdu[1] & 0xc0) == 0x80)
1263         { /* This is a R-block. */
1264           if ( (tpdu[1] & 0x0f)) 
1265             { /* Error: repeat last block */
1266               if (++retries > 3)
1267                 {
1268                   DEBUGOUT ("3 failed retries\n");
1269                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
1270                 }
1271               msg = send_buffer;
1272               tpdulen = last_tpdulen;
1273             }
1274           else if (sending && !!(tpdu[1] & 0x40) == handle->t1_ns)
1275             { /* Reponse does not match our sequence number. */
1276               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
1277               return CCID_DRIVER_ERR_CARD_IO_ERROR;
1278             }
1279           else if (sending)
1280             { /* Send next chunk. */
1281               retries = 0;
1282               msg = send_buffer;
1283               next_chunk = 1;
1284               handle->t1_ns ^= 1;
1285             }
1286           else
1287             {
1288               DEBUGOUT ("unexpected ACK R-block received\n");
1289               return CCID_DRIVER_ERR_CARD_IO_ERROR;
1290             }
1291         }
1292       else 
1293         { /* This is a S-block. */
1294           retries = 0;
1295           DEBUGOUT_2 ("T1 S-block %s received cmd=%d\n",
1296                       (tpdu[1] & 0x20)? "response": "request",
1297                       (tpdu[1] & 0x1f));
1298           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
1299             { /* Wait time extension request. */
1300               unsigned char bwi = tpdu[3];
1301               msg = send_buffer;
1302               tpdu = msg+10;
1303               /* NAD: DAD=1, SAD=0 */
1304               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1305               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
1306               tpdu[2] = 1;
1307               tpdu[3] = bwi;
1308               tpdulen = 4;
1309               edc = compute_edc (tpdu, tpdulen, use_crc);
1310               if (use_crc)
1311                 tpdu[tpdulen++] = (edc >> 8);
1312               tpdu[tpdulen++] = edc;
1313               DEBUGOUT_1 ("T1 waittime extension of bwi=%d\n", bwi);
1314             }
1315           else
1316             return CCID_DRIVER_ERR_CARD_IO_ERROR;
1317         }
1318     } /* end T=1 protocol loop. */
1319
1320   return 0;
1321 }
1322
1323
1324
1325
1326 #ifdef TEST
1327 int
1328 main (int argc, char **argv)
1329 {
1330   int rc;
1331   ccid_driver_t ccid;
1332   unsigned int slotstat;
1333
1334   rc = ccid_open_reader (&ccid, 0);
1335   if (rc)
1336     return 1;
1337
1338   ccid_poll (ccid);
1339   fputs ("getting ATR ...\n", stderr);
1340   rc = ccid_get_atr (ccid, NULL, 0, NULL);
1341   if (rc)
1342     return 1;
1343
1344   ccid_poll (ccid);
1345   fputs ("getting slot status ...\n", stderr);
1346   rc = ccid_slot_status (ccid, &slotstat);
1347   if (rc)
1348     return 1;
1349
1350   ccid_poll (ccid);
1351
1352   {
1353     static unsigned char apdu[] = {
1354       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
1355   rc = ccid_transceive (ccid,
1356                         apdu, sizeof apdu,
1357                         NULL, 0, NULL);
1358   }
1359   ccid_poll (ccid);
1360
1361   {
1362     static unsigned char apdu[] = {
1363       0, 0xCA, 0, 0x65, 254 };
1364   rc = ccid_transceive (ccid,
1365                         apdu, sizeof apdu,
1366                         NULL, 0, NULL);
1367   }
1368   ccid_poll (ccid);
1369
1370
1371   return 0;
1372 }
1373
1374 /*
1375  * Local Variables:
1376  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
1377  * End:
1378  */
1379 #endif /*TEST*/
1380 #endif /*HAVE_LIBUSB*/