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