4751b8cdb328627790cdbfa3e3eaacdab22e81e2
[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 < dev->descriptor->bNumConfigurations; cfg_no++)
416     {
417       struct usb_config_descriptor *config = dev->config + cfg_no;
418       int ifc_no;
419
420       for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
421         {
422           struct usb_interface *interface = config->interface + ifc_no;
423           int set_no;
424
425           for (set_no=0; set_no < interface->num_altsetting; set_no++)
426             {
427               struct usb_interface_descriptor *ifcdesc
428                 = interface->altsetting + set_no;
429               
430               if (ifcdesc->bInterfaceClass == 11
431                   && ifcdesc->bInterfaceSubClass == 0
432                   && ifcdesc->bInterfaceProtocol == 0)
433                 {
434                   if (ifcdesc->extra)
435                     {
436                       if (!parse_ccid_descriptor (handle, 
437                                                   ifcdesc->extra,
438                                                   ifcdesc->extralen))
439                         return 0; /* okay. we can use it. */
440                     }
441                 }
442             }
443         }
444     }
445   return CCID_DRIVER_ERR_NO_READER; /* No suitable device found. */
446 }
447
448
449 /* Open the reader with the internal number READERNO and return a 
450    pointer to be used as handle in HANDLE.  Returns 0 on success. */
451 int 
452 ccid_open_reader (ccid_driver_t *handle, int readerno)
453 {
454   static int initialized;
455
456   int rc;
457   usb_match_handle *match = NULL;
458   struct usb_device *dev = NULL;
459   usb_dev_handle *idev = NULL;
460
461   *handle = NULL;
462   if (!initialized)
463     {
464       usb_init ();
465       initialized = 1;
466     }
467   
468   rc = usb_create_match (&match, -1, -1, 11, -1, -1);
469   if (rc)
470     {
471       DEBUGOUT_1 ("usb_create_match failed: %d\n", rc);
472       return CCID_DRIVER_ERR_NO_READER;
473     }
474
475   while (usb_find_device(match, dev, &dev) >= 0) 
476     {
477       DEBUGOUT_3 ("%-40s %04X/%04X\n", dev->filename,
478                   dev->descriptor->idVendor, dev->descriptor->idProduct);
479       if (!readerno)
480         {
481           *handle = calloc (1, sizeof **handle);
482           if (!*handle)
483             {
484               DEBUGOUT ("out of memory\n");
485               rc = CCID_DRIVER_ERR_OUT_OF_CORE;
486               free (*handle);
487               *handle = NULL;
488               goto leave;
489             }
490
491           rc = read_device_info (*handle, dev);
492           if (rc)
493             {
494               DEBUGOUT ("device not supported\n");
495               free (*handle);
496               *handle = NULL;
497               goto leave;
498             }
499
500           rc = usb_open (dev, &idev);
501           if (rc)
502             {
503               DEBUGOUT_1 ("usb_open failed: %d\n", rc);
504               free (*handle);
505               *handle = NULL;
506               rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
507               goto leave;
508             }
509
510
511           /* fixme: Do we need to claim and set the interface as
512              determined by read_device_info ()? */
513           rc = usb_claim_interface (idev, 0);
514           if (rc)
515             {
516               DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
517               free (*handle);
518               *handle = NULL;
519               rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
520               goto leave;
521             }
522
523           (*handle)->idev = idev;
524           idev = NULL;
525           /* FIXME: Do we need to get the endpoint addresses from the
526              structure and store them with the handle? */
527
528           break;
529         }
530       readerno--;
531     }
532
533
534  leave:
535   if (idev)
536     usb_close (idev);
537   /* fixme: Do we need to release dev or is it supposed to be a
538      shallow copy of the list created internally by usb_init ? */
539   usb_free_match (match);
540
541   if (!rc && !*handle)
542     rc = -1; /* In case we didn't enter the while loop at all. */
543
544   return rc;
545 }
546
547
548 /* Close the reader HANDLE. */
549 int 
550 ccid_close_reader (ccid_driver_t handle)
551 {
552   if (!handle || !handle->idev)
553     return 0;
554
555    {
556      int rc;
557      unsigned char msg[100];
558      size_t msglen;
559      unsigned char seqno;
560    
561      msg[0] = PC_to_RDR_IccPowerOff;
562      msg[5] = 0; /* slot */
563      msg[6] = seqno = handle->seqno++;
564      msg[7] = 0; /* RFU */
565      msg[8] = 0; /* RFU */
566      msg[9] = 0; /* RFU */
567      set_msg_len (msg, 0);
568      msglen = 10;
569    
570      rc = bulk_out (handle, msg, msglen);
571      if (!rc)
572         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus, seqno);
573    }
574    
575   usb_release_interface (handle->idev, 0);
576   usb_close (handle->idev);
577   handle->idev = NULL;
578   free (handle);
579   return 0;
580 }
581
582
583 /* Return False if a card is present and powered. */
584 int
585 ccid_check_card_presence (ccid_driver_t handle)
586 {
587
588   return -1;
589 }
590
591
592 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
593    Returns 0 on success. */
594 static int
595 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen)
596 {
597   int rc;
598
599   rc = usb_bulk_write (handle->idev, 
600                        1, /*endpoint */
601                        msg, msglen,
602                        1000 /* ms timeout */);
603   if (rc == msglen)
604     return 0;
605
606   if (rc == -1)
607     DEBUGOUT_1 ("usb_bulk_write error: %s\n", strerror (errno));
608   else
609     DEBUGOUT_1 ("usb_bulk_write failed: %d\n", rc);
610   return CCID_DRIVER_ERR_CARD_IO_ERROR;
611 }
612
613
614 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
615    BUFFER and return the actual read number if bytes in NREAD. SEQNO
616    is the sequence number used to send the request and EXPECTED_TYPE
617    the type of message we expect. Does checks on the ccid
618    header. Returns 0 on success. */
619 static int
620 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
621          size_t *nread, int expected_type, int seqno)
622 {
623   int i, rc;
624   size_t msglen;
625
626  retry:
627   rc = usb_bulk_read (handle->idev, 
628                       0x82,
629                       buffer, length,
630                       10000 /* ms timeout */ );
631   /* Fixme: instead of using a 10 second timeout we should better
632      handle the timeout here and retry if appropriate.  */
633   if (rc < 0)
634     {
635       DEBUGOUT_1 ("usb_bulk_read error: %s\n", strerror (errno));
636       return CCID_DRIVER_ERR_CARD_IO_ERROR;
637     }
638
639   *nread = msglen = rc;
640
641   if (msglen < 10)
642     {
643       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
644       return CCID_DRIVER_ERR_INV_VALUE;
645     }
646   if (buffer[0] != expected_type)
647     {
648       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
649       return CCID_DRIVER_ERR_INV_VALUE;
650     }
651   if (buffer[5] != 0)    
652     {
653       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
654       return CCID_DRIVER_ERR_INV_VALUE;
655     }
656   if (buffer[6] != seqno)    
657     {
658       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
659                   seqno, buffer[6]);
660       return CCID_DRIVER_ERR_INV_VALUE;
661     }
662
663   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
664     { 
665       /* Card present and active, time extension requested. */
666       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
667                   buffer[7], buffer[8]);
668       goto retry;
669     }
670   
671   DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n"
672               "               data:",  buffer[7], buffer[8], buffer[9] );
673   for (i=10; i < msglen; i++)
674     DEBUGOUT_CONT_1 (" %02X", buffer[i]);
675   DEBUGOUT_LF ();
676
677   switch ((buffer[7] & 0x03))
678     {
679     case 0: /* no error */ break;
680     case 1: return CCID_DRIVER_ERR_CARD_INACTIVE;
681     case 2: return CCID_DRIVER_ERR_NO_CARD;
682     case 3: /* RFU */ break;
683     }
684   return 0;
685 }
686
687
688 /* experimental */
689 int
690 ccid_poll (ccid_driver_t handle)
691 {
692   int rc;
693   unsigned char msg[10];
694   size_t msglen;
695   int i, j;
696
697   rc = usb_bulk_read (handle->idev, 
698                       0x83,
699                       msg, sizeof msg,
700                       0 /* ms timeout */ );
701   if (rc < 0 && errno == ETIMEDOUT)
702     return 0;
703
704   if (rc < 0)
705     {
706       DEBUGOUT_1 ("usb_intr_read error: %s\n", strerror (errno));
707       return CCID_DRIVER_ERR_CARD_IO_ERROR;
708     }
709
710   msglen = rc;
711   rc = 0;
712
713   if (msglen < 1)
714     {
715       DEBUGOUT ("intr-in msg too short\n");
716       return CCID_DRIVER_ERR_INV_VALUE;
717     }
718
719   if (msg[0] == RDR_to_PC_NotifySlotChange)
720     {
721       DEBUGOUT ("notify slot change:");
722       for (i=1; i < msglen; i++)
723         for (j=0; j < 4; j++)
724           DEBUGOUT_CONT_3 (" %d:%c%c",
725                            (i-1)*4+j, 
726                            (msg[i] & (1<<(j*2)))? 'p':'-',
727                            (msg[i] & (2<<(j*2)))? '*':' ');
728       DEBUGOUT_LF ();
729     }
730   else if (msg[0] == RDR_to_PC_HardwareError)    
731     {
732       DEBUGOUT ("hardware error occured\n");
733     }
734   else
735     {
736       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
737     }
738
739   return 0;
740 }
741
742
743 /* Note that this fucntion won't return the error codes NO_CARD or
744    CARD_INACTIVE */
745 int 
746 ccid_slot_status (ccid_driver_t handle, int *statusbits)
747 {
748   int rc;
749   unsigned char msg[100];
750   size_t msglen;
751   unsigned char seqno;
752
753   msg[0] = PC_to_RDR_GetSlotStatus;
754   msg[5] = 0; /* slot */
755   msg[6] = seqno = handle->seqno++;
756   msg[7] = 0; /* RFU */
757   msg[8] = 0; /* RFU */
758   msg[9] = 0; /* RFU */
759   set_msg_len (msg, 0);
760
761   rc = bulk_out (handle, msg, 10);
762   if (rc)
763     return rc;
764   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus, seqno);
765   if (rc && rc != CCID_DRIVER_ERR_NO_CARD
766       && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
767     return rc;
768   *statusbits = (msg[7] & 3);
769
770   return 0;
771 }
772
773
774 int 
775 ccid_get_atr (ccid_driver_t handle,
776               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
777 {
778   int rc;
779   unsigned char msg[100];
780   unsigned char *tpdu;
781   size_t msglen, tpdulen;
782   unsigned char seqno;
783   int use_crc = 0;
784   unsigned int edc;
785   int i;
786
787   msg[0] = PC_to_RDR_IccPowerOn;
788   msg[5] = 0; /* slot */
789   msg[6] = seqno = handle->seqno++;
790   msg[7] = 0; /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
791   msg[8] = 0; /* RFU */
792   msg[9] = 0; /* RFU */
793   set_msg_len (msg, 0);
794   msglen = 10;
795
796   rc = bulk_out (handle, msg, msglen);
797   if (rc)
798     return rc;
799   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock, seqno);
800   if (rc)
801     return rc;
802   
803   if (atr)
804     {
805       size_t n = msglen - 10;
806
807       if (n > maxatrlen)
808         n = maxatrlen;
809       memcpy (atr, msg+10, n);
810       *atrlen = n;
811     }
812
813   /* Setup parameters to select T=1. */
814   msg[0] = PC_to_RDR_SetParameters;
815   msg[5] = 0; /* slot */
816   msg[6] = seqno = handle->seqno++;
817   msg[7] = 1; /* Select T=1. */
818   msg[8] = 0; /* RFU */
819   msg[9] = 0; /* RFU */
820
821   /* FIXME: Get those values from the ATR. */
822   msg[10]= 0x01; /* Fi/Di */
823   msg[11]= 0x10; /* LRC, direct convention. */
824   msg[12]= 0;    /* Extra guardtime. */
825   msg[13]= 0x41; /* BWI/CWI */
826   msg[14]= 0;    /* No clock stoppping. */
827   msg[15]= 254;  /* IFSC */
828   msg[16]= 0;    /* Does not support non default NAD values. */
829   set_msg_len (msg, 7);
830   msglen = 10 + 7;
831
832   DEBUGOUT ("sending");
833   for (i=0; i < msglen; i++)
834     DEBUGOUT_CONT_1 (" %02X", msg[i]);
835   DEBUGOUT_LF ();
836
837   rc = bulk_out (handle, msg, msglen);
838   if (rc)
839     return rc;
840   /* Note that we ignore the error code on purpose. */
841   bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters, seqno);
842
843
844   /* Send an S-Block with our maximun IFSD to the CCID.  */
845   if (!handle->auto_ifsd)
846     {
847       tpdu = msg+10;
848       /* NAD: DAD=1, SAD=0 */
849       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
850       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
851       tpdu[2] = 1;
852       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32; 
853       tpdulen = 4;
854       edc = compute_edc (tpdu, tpdulen, use_crc);
855       if (use_crc)
856         tpdu[tpdulen++] = (edc >> 8);
857       tpdu[tpdulen++] = edc;
858
859       msg[0] = PC_to_RDR_XfrBlock;
860       msg[5] = 0; /* slot */
861       msg[6] = seqno = handle->seqno++;
862       msg[7] = 0; 
863       msg[8] = 0; /* RFU */
864       msg[9] = 0; /* RFU */
865       set_msg_len (msg, tpdulen);
866       msglen = 10 + tpdulen;
867
868       DEBUGOUT ("sending");
869       for (i=0; i < msglen; i++)
870         DEBUGOUT_CONT_1 (" %02X", msg[i]);
871       DEBUGOUT_LF ();
872
873 #ifdef DEBUG_T1      
874       fprintf (stderr, "T1: put %c-block seq=%d\n",
875                ((msg[11] & 0xc0) == 0x80)? 'R' :
876                (msg[11] & 0x80)? 'S' : 'I',
877                ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)));
878 #endif  
879
880       rc = bulk_out (handle, msg, msglen);
881       if (rc)
882         return rc;
883
884       /* Fixme: The next line for the current Valgrid without support
885          for USB IOCTLs. */
886       memset (msg, 0, sizeof msg);
887
888       rc = bulk_in (handle, msg, sizeof msg, &msglen,
889                     RDR_to_PC_DataBlock, seqno);
890       if (rc)
891         return rc;
892       
893       tpdu = msg + 10;
894       tpdulen = msglen - 10;
895       
896       if (tpdulen < 4) 
897         {
898           DEBUGOUT ("cannot yet handle short blocks!\n");
899           return -1; 
900         }
901
902 #ifdef DEBUG_T1
903       fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
904                ((msg[11] & 0xc0) == 0x80)? 'R' :
905                (msg[11] & 0x80)? 'S' : 'I',
906                ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
907                ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
908                );
909 #endif
910       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
911         {
912           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
913           return -1;
914         }
915       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
916     }
917
918   return 0;
919 }
920
921
922 \f
923
924 static unsigned int 
925 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
926 {
927   if (use_crc)
928     {
929       return 0x42; /* Not yet implemented. */
930     }
931   else
932     {
933       unsigned char crc = 0;
934       
935       for (; datalen; datalen--)
936         crc ^= *data++;
937       return crc;
938     }
939 }
940
941
942 /*
943   Protocol T=1 overview
944
945   Block Structure:
946            Prologue Field:
947    1 byte     Node Address (NAD) 
948    1 byte     Protocol Control Byte (PCB)
949    1 byte     Length (LEN) 
950            Information Field:
951    0-254 byte APDU or Control Information (INF)
952            Epilogue Field:
953    1 byte     Error Detection Code (EDC)
954
955   NAD:  
956    bit 7     unused
957    bit 4..6  Destination Node Address (DAD)
958    bit 3     unused
959    bit 2..0  Source Node Address (SAD)
960
961    If node adresses are not used, SAD and DAD should be set to 0 on
962    the first block sent to the card.  If they are used they should
963    have different values (0 for one is okay); that first block sets up
964    the addresses of the nodes.
965
966   PCB:
967    Information Block (I-Block):
968       bit 7    0
969       bit 6    Sequence number (yep, that is modulo 2)
970       bit 5    Chaining flag 
971       bit 4..0 reserved
972    Received-Ready Block (R-Block):
973       bit 7    1
974       bit 6    0
975       bit 5    0
976       bit 4    Sequence number
977       bit 3..0  0 = no error
978                 1 = EDC or parity error
979                 2 = other error
980                 other values are reserved
981    Supervisory Block (S-Block):
982       bit 7    1
983       bit 6    1
984       bit 5    clear=request,set=response
985       bit 4..0  0 = resyncronisation request
986                 1 = information field size request
987                 2 = abort request
988                 3 = extension of BWT request
989                 4 = VPP error
990                 other values are reserved
991
992 */
993
994 int
995 ccid_transceive (ccid_driver_t handle,
996                  const unsigned char *apdu_buf, size_t apdu_buflen,
997                  unsigned char *resp, size_t maxresplen, size_t *nresp)
998 {
999   int rc;
1000   unsigned char send_buffer[10+259], recv_buffer[10+259];
1001   const unsigned char *apdu;
1002   size_t apdulen;
1003   unsigned char *msg, *tpdu, *p;
1004   size_t msglen, tpdulen, last_tpdulen, n;
1005   unsigned char seqno;
1006   int i;
1007   unsigned int edc;
1008   int use_crc = 0;
1009   size_t dummy_nresp;
1010   int next_chunk = 1;
1011   int sending = 1;
1012   int retries = 0;
1013
1014   if (!nresp)
1015     nresp = &dummy_nresp;
1016   *nresp = 0;
1017
1018   tpdulen = 0; /* Avoid compiler warning about no initialization. */
1019   msg = send_buffer;
1020   for (;;)
1021     {
1022       if (next_chunk)
1023         {
1024           next_chunk = 0;
1025
1026           apdu = apdu_buf;
1027           apdulen = apdu_buflen;
1028           assert (apdulen);
1029
1030           /* Construct an I-Block. */
1031           if (apdulen > 254)
1032             return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
1033
1034           tpdu = msg+10;
1035           /* NAD: DAD=1, SAD=0 */
1036           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1037           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
1038           if (apdulen > 128 /* fixme: replace by ifsc */)
1039             {
1040               apdulen = 128;
1041               apdu_buf += 128;  
1042               apdu_buflen -= 128;
1043               tpdu[1] |= (1 << 5); /* Set more bit. */
1044             }
1045           tpdu[2] = apdulen;
1046           memcpy (tpdu+3, apdu, apdulen);
1047           tpdulen = 3 + apdulen;
1048           edc = compute_edc (tpdu, tpdulen, use_crc);
1049           if (use_crc)
1050             tpdu[tpdulen++] = (edc >> 8);
1051           tpdu[tpdulen++] = edc;
1052         }
1053
1054       msg[0] = PC_to_RDR_XfrBlock;
1055       msg[5] = 0; /* slot */
1056       msg[6] = seqno = handle->seqno++;
1057       msg[7] = 4; /* bBWI */
1058       msg[8] = 0; /* RFU */
1059       msg[9] = 0; /* RFU */
1060       set_msg_len (msg, tpdulen);
1061       msglen = 10 + tpdulen;
1062       last_tpdulen = tpdulen;
1063
1064       DEBUGOUT ("sending");
1065       for (i=0; i < msglen; i++)
1066         DEBUGOUT_CONT_1 (" %02X", msg[i]);
1067       DEBUGOUT_LF ();
1068
1069 #ifdef DEBUG_T1      
1070       fprintf (stderr, "T1: put %c-block seq=%d\n",
1071                ((msg[11] & 0xc0) == 0x80)? 'R' :
1072                (msg[11] & 0x80)? 'S' : 'I',
1073         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)));
1074 #endif  
1075
1076       rc = bulk_out (handle, msg, msglen);
1077       if (rc)
1078         return rc;
1079
1080       /* Fixme: The next line for the current Valgrid without support
1081          for USB IOCTLs. */
1082       memset (recv_buffer, 0, sizeof recv_buffer);
1083
1084       msg = recv_buffer;
1085       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
1086                     RDR_to_PC_DataBlock, seqno);
1087       if (rc)
1088         return rc;
1089       
1090       tpdu = msg + 10;
1091       tpdulen = msglen - 10;
1092       
1093       if (tpdulen < 4) 
1094         {
1095           DEBUGOUT ("cannot yet handle short blocks!\n");
1096           return CCID_DRIVER_ERR_NOT_SUPPORTED; 
1097         }
1098
1099 #ifdef DEBUG_T1
1100       fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
1101                ((msg[11] & 0xc0) == 0x80)? 'R' :
1102                (msg[11] & 0x80)? 'S' : 'I',
1103         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
1104                ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
1105                );
1106 #endif
1107
1108       if (!(tpdu[1] & 0x80))
1109         { /* This is an I-block. */
1110           retries = 0;
1111           if (sending)
1112             { /* last block sent was successful. */
1113               handle->t1_ns ^= 1;
1114               sending = 0;
1115             }
1116
1117           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
1118             { /* Reponse does not match our sequence number. */
1119               msg = send_buffer;
1120               tpdu = msg+10;
1121               /* NAD: DAD=1, SAD=0 */
1122               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1123               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
1124               tpdu[2] = 0;
1125               tpdulen = 3;
1126               edc = compute_edc (tpdu, tpdulen, use_crc);
1127               if (use_crc)
1128                 tpdu[tpdulen++] = (edc >> 8);
1129               tpdu[tpdulen++] = edc;
1130
1131               continue;
1132             }
1133
1134           handle->t1_nr ^= 1;
1135
1136           p = tpdu + 3; /* Skip the prologue field. */
1137           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
1138           /* fixme: verify the checksum. */
1139           if (resp)
1140             {
1141               if (n > maxresplen)
1142                 {
1143                   DEBUGOUT_2 ("provided buffer too short for received data "
1144                               "(%u/%u)\n",
1145                               (unsigned int)n, (unsigned int)maxresplen);
1146                   return CCID_DRIVER_ERR_INV_VALUE;
1147                 }
1148               
1149               memcpy (resp, p, n); 
1150               resp += n;
1151               *nresp += n;
1152               maxresplen -= n;
1153             }
1154           
1155           if (!(tpdu[1] & 0x20))
1156             return 0; /* No chaining requested - ready. */
1157           
1158           msg = send_buffer;
1159           tpdu = msg+10;
1160           /* NAD: DAD=1, SAD=0 */
1161           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1162           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
1163           tpdu[2] = 0;
1164           tpdulen = 3;
1165           edc = compute_edc (tpdu, tpdulen, use_crc);
1166           if (use_crc)
1167             tpdu[tpdulen++] = (edc >> 8);
1168           tpdu[tpdulen++] = edc;
1169         }
1170       else if ((tpdu[1] & 0xc0) == 0x80)
1171         { /* This is a R-block. */
1172           if ( (tpdu[1] & 0x0f)) 
1173             { /* Error: repeat last block */
1174               if (++retries > 3)
1175                 {
1176                   DEBUGOUT ("3 failed retries\n");
1177                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
1178                 }
1179               msg = send_buffer;
1180               tpdulen = last_tpdulen;
1181             }
1182           else if (sending && !!(tpdu[1] & 0x40) == handle->t1_ns)
1183             { /* Reponse does not match our sequence number. */
1184               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
1185               return CCID_DRIVER_ERR_CARD_IO_ERROR;
1186             }
1187           else if (sending)
1188             { /* Send next chunk. */
1189               retries = 0;
1190               msg = send_buffer;
1191               next_chunk = 1;
1192               handle->t1_ns ^= 1;
1193             }
1194           else
1195             {
1196               DEBUGOUT ("unexpected ACK R-block received\n");
1197               return CCID_DRIVER_ERR_CARD_IO_ERROR;
1198             }
1199         }
1200       else 
1201         { /* This is a S-block. */
1202           retries = 0;
1203           DEBUGOUT_2 ("T1 S-block %s received cmd=%d\n",
1204                       (tpdu[1] & 0x20)? "response": "request",
1205                       (tpdu[1] & 0x1f));
1206           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
1207             { /* Wait time extension request. */
1208               unsigned char bwi = tpdu[3];
1209               msg = send_buffer;
1210               tpdu = msg+10;
1211               /* NAD: DAD=1, SAD=0 */
1212               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1213               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
1214               tpdu[2] = 1;
1215               tpdu[3] = bwi;
1216               tpdulen = 4;
1217               edc = compute_edc (tpdu, tpdulen, use_crc);
1218               if (use_crc)
1219                 tpdu[tpdulen++] = (edc >> 8);
1220               tpdu[tpdulen++] = edc;
1221               DEBUGOUT_1 ("T1 waittime extension of bwi=%d\n", bwi);
1222             }
1223           else
1224             return CCID_DRIVER_ERR_CARD_IO_ERROR;
1225         }
1226     } /* end T=1 protocol loop. */
1227
1228   return 0;
1229 }
1230
1231
1232
1233
1234 #ifdef TEST
1235 int
1236 main (int argc, char **argv)
1237 {
1238   int rc;
1239   ccid_driver_t ccid;
1240   unsigned int slotstat;
1241
1242   rc = ccid_open_reader (&ccid, 0);
1243   if (rc)
1244     return 1;
1245
1246   ccid_poll (ccid);
1247   fputs ("getting ATR ...\n", stderr);
1248   rc = ccid_get_atr (ccid, NULL, 0, NULL);
1249   if (rc)
1250     return 1;
1251
1252   ccid_poll (ccid);
1253   fputs ("getting slot status ...\n", stderr);
1254   rc = ccid_slot_status (ccid, &slotstat);
1255   if (rc)
1256     return 1;
1257
1258   ccid_poll (ccid);
1259
1260   {
1261     static unsigned char apdu[] = {
1262       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
1263   rc = ccid_transceive (ccid,
1264                         apdu, sizeof apdu,
1265                         NULL, 0, NULL);
1266   }
1267   ccid_poll (ccid);
1268
1269   {
1270     static unsigned char apdu[] = {
1271       0, 0xCA, 0, 0x65, 254 };
1272   rc = ccid_transceive (ccid,
1273                         apdu, sizeof apdu,
1274                         NULL, 0, NULL);
1275   }
1276   ccid_poll (ccid);
1277
1278
1279   return 0;
1280 }
1281
1282 /*
1283  * Local Variables:
1284  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
1285  * End:
1286  */
1287 #endif /*TEST*/
1288 #endif /*HAVE_LIBUSB*/