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