b398e3ce35e055e67639bd5bdeebab36f079371a
[gnupg.git] / scd / ccid-driver.c
1 /* ccid-driver.c - USB ChipCardInterfaceDevices driver
2  *      Copyright (C) 2003 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
114 # define DEBUGOUT(t)         do { if (DBG_CARD_IO) \
115                                   log_debug (DRVNAME t); } while (0)
116 # define DEBUGOUT_1(t,a)     do { if (DBG_CARD_IO) \
117                                   log_debug (DRVNAME t,(a)); } while (0)
118 # define DEBUGOUT_2(t,a,b)   do { if (DBG_CARD_IO) \
119                                   log_debug (DRVNAME t,(a),(b)); } while (0)
120 # define DEBUGOUT_3(t,a,b,c) do { if (DBG_CARD_IO) \
121                                   log_debug (DRVNAME t,(a),(b),(c));} while (0)
122 # define DEBUGOUT_CONT(t)    do { if (DBG_CARD_IO) \
123                                   log_printf (t); } while (0)
124 # define DEBUGOUT_CONT_1(t,a)  do { if (DBG_CARD_IO) \
125                                   log_printf (t,(a)); } while (0)
126 # define DEBUGOUT_CONT_2(t,a,b)   do { if (DBG_CARD_IO) \
127                                   log_printf (t,(a),(b)); } while (0)
128 # define DEBUGOUT_CONT_3(t,a,b,c) do { if (DBG_CARD_IO) \
129                                   log_printf (t,(a),(b),(c)); } while (0)
130 # define DEBUGOUT_LF()       do { if (DBG_CARD_IO) \
131                                   log_printf ("\n"); } while (0)
132
133 #else /* Other usage of this source - don't use gnupg specifics. */
134
135 # define DEBUGOUT(t)          fprintf (stderr, DRVNAME t)
136 # define DEBUGOUT_1(t,a)      fprintf (stderr, DRVNAME t, (a))
137 # define DEBUGOUT_2(t,a,b)    fprintf (stderr, DRVNAME t, (a), (b))
138 # define DEBUGOUT_3(t,a,b,c)  fprintf (stderr, DRVNAME t, (a), (b), (c))
139 # define DEBUGOUT_CONT(t)     fprintf (stderr, t)
140 # define DEBUGOUT_CONT_1(t,a)      fprintf (stderr, t, (a))
141 # define DEBUGOUT_CONT_2(t,a,b)    fprintf (stderr, t, (a), (b))
142 # define DEBUGOUT_CONT_3(t,a,b,c)  fprintf (stderr, t, (a), (b), (c))
143 # define DEBUGOUT_LF()        putc ('\n', stderr)
144
145 #endif /* This source not used by scdaemon. */
146
147
148 /* Define to print information pertaining the T=1 protocol. */
149 #undef DEBUG_T1 
150
151
152
153 enum {
154   RDR_to_PC_NotifySlotChange= 0x50,
155   RDR_to_PC_HardwareError   = 0x51,
156
157   PC_to_RDR_SetParameters   = 0x61,
158   PC_to_RDR_IccPowerOn      = 0x62,
159   PC_to_RDR_IccPowerOff     = 0x63,
160   PC_to_RDR_GetSlotStatus   = 0x65,
161   PC_to_RDR_Secure          = 0x69,
162   PC_to_RDR_T0APDU          = 0x6a,
163   PC_to_RDR_Escape          = 0x6b,
164   PC_to_RDR_GetParameters   = 0x6c,
165   PC_to_RDR_ResetParameters = 0x6d,
166   PC_to_RDR_IccClock        = 0x6e,
167   PC_to_RDR_XfrBlock        = 0x6f,
168   PC_to_RDR_Mechanical      = 0x71,
169   PC_to_RDR_Abort           = 0x72,
170   PC_to_RDR_SetDataRate     = 0x73,
171
172   RDR_to_PC_DataBlock       = 0x80,
173   RDR_to_PC_SlotStatus      = 0x81,
174   RDR_to_PC_Parameters      = 0x82,
175   RDR_to_PC_Escape          = 0x83,
176   RDR_to_PC_DataRate        = 0x84
177 };
178
179
180 /* Store information on the driver's state.  A pointer to such a
181    structure is used as handle for most functions. */
182 struct ccid_driver_s {
183   usb_dev_handle *idev;
184   int seqno;
185   unsigned char t1_ns;
186   unsigned char t1_nr;
187 };
188
189
190 static int bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen);
191 static int bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
192                     size_t *nread, int expected_type, int seqno);
193
194
195
196 /* Convert a little endian stored 4 byte value into an unsigned
197    integer. */
198 static unsigned int 
199 convert_le_u32 (const unsigned char *buf)
200 {
201   return buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24); 
202 }
203
204 static void
205 set_msg_len (unsigned char *msg, unsigned int length)
206 {
207   msg[1] = length;
208   msg[2] = length >> 8;
209   msg[3] = length >> 16;
210   msg[4] = length >> 24;
211 }
212
213
214
215
216 /* Parse a CCID descriptor, optionally print all available features
217    and test whether this reader is usable by this driver.  Returns 0
218    if it is usable.
219
220    Note, that this code is based on the one in lsusb.c of the
221    usb-utils package, I wrote on 2003-09-01. -wk. */
222 static int
223 parse_ccid_descriptor (const unsigned char *buf, size_t buflen)
224 {
225   unsigned int i;
226   unsigned int us;
227   int have_t1 = 0, have_tpdu=0, have_auto_conf = 0;
228
229
230   if (buflen < 54 || buf[0] < 54)
231     {
232       DEBUGOUT ("CCID device descriptor is too short\n");
233       return -1;
234     }
235
236   DEBUGOUT   ("ChipCard Interface Descriptor:\n");
237   DEBUGOUT_1 ("  bLength             %5u\n", buf[0]);
238   DEBUGOUT_1 ("  bDescriptorType     %5u\n", buf[1]);
239   DEBUGOUT_2 ("  bcdCCID             %2x.%02x", buf[3], buf[2]);
240     if (buf[3] != 1 || buf[2] != 0) 
241       DEBUGOUT_CONT("  (Warning: Only accurate for version 1.0)");
242   DEBUGOUT_LF ();
243
244   DEBUGOUT_1 ("  nMaxSlotIndex       %5u\n", buf[4]);
245   DEBUGOUT_2 ("  bVoltageSupport     %5u  %s\n",
246               buf[5], (buf[5] == 1? "5.0V" : buf[5] == 2? "3.0V"
247                        : buf[5] == 3? "1.8V":"?"));
248
249   us = convert_le_u32 (buf+6);
250   DEBUGOUT_1 ("  dwProtocols         %5u ", us);
251   if ((us & 1))
252     DEBUGOUT_CONT (" T=0");
253   if ((us & 2))
254     {
255       DEBUGOUT_CONT (" T=1");
256       have_t1 = 1;
257     }
258   if ((us & ~3))
259     DEBUGOUT_CONT (" (Invalid values detected)");
260   DEBUGOUT_LF ();
261
262   us = convert_le_u32(buf+10);
263   DEBUGOUT_1 ("  dwDefaultClock      %5u\n", us);
264   us = convert_le_u32(buf+14);
265   DEBUGOUT_1 ("  dwMaxiumumClock     %5u\n", us);
266   DEBUGOUT_1 ("  bNumClockSupported  %5u\n", buf[18]);
267   us = convert_le_u32(buf+19);
268   DEBUGOUT_1 ("  dwDataRate        %7u bps\n", us);
269   us = convert_le_u32(buf+23);
270   DEBUGOUT_1 ("  dwMaxDataRate     %7u bps\n", us);
271   DEBUGOUT_1 ("  bNumDataRatesSupp.  %5u\n", buf[27]);
272         
273   us = convert_le_u32(buf+28);
274   DEBUGOUT_1 ("  dwMaxIFSD           %5u\n", us);
275
276   us = convert_le_u32(buf+32);
277   DEBUGOUT_1 ("  dwSyncProtocols  %08X ", us);
278   if ((us&1))
279     DEBUGOUT_CONT ( " 2-wire");
280   if ((us&2))
281     DEBUGOUT_CONT ( " 3-wire");
282   if ((us&4))
283     DEBUGOUT_CONT ( " I2C");
284   DEBUGOUT_LF ();
285
286   us = convert_le_u32(buf+36);
287   DEBUGOUT_1 ("  dwMechanical     %08X ", us);
288   if ((us & 1))
289     DEBUGOUT_CONT (" accept");
290   if ((us & 2))
291     DEBUGOUT_CONT (" eject");
292   if ((us & 4))
293     DEBUGOUT_CONT (" capture");
294   if ((us & 8))
295     DEBUGOUT_CONT (" lock");
296   DEBUGOUT_LF ();
297
298   us = convert_le_u32(buf+40);
299   DEBUGOUT_1 ("  dwFeatures       %08X\n", us);
300   if ((us & 0x0002))
301     {
302       DEBUGOUT ("    Auto configuration based on ATR\n");
303       have_auto_conf = 1;
304     }
305   if ((us & 0x0004))
306     DEBUGOUT ("    Auto activation on insert\n");
307   if ((us & 0x0008))
308     DEBUGOUT ("    Auto voltage selection\n");
309   if ((us & 0x0010))
310     DEBUGOUT ("    Auto clock change\n");
311   if ((us & 0x0020))
312     DEBUGOUT ("    Auto baud rate change\n");
313   if ((us & 0x0040))
314     DEBUGOUT ("    Auto parameter negotation made by CCID\n");
315   else if ((us & 0x0080))
316     DEBUGOUT ("    Auto PPS made by CCID\n");
317   else if ((us & (0x0040 | 0x0080)))
318     DEBUGOUT ("    WARNING: conflicting negotation features\n");
319
320   if ((us & 0x0100))
321     DEBUGOUT ("    CCID can set ICC in clock stop mode\n");
322   if ((us & 0x0200))
323     DEBUGOUT ("    NAD value other than 0x00 accpeted\n");
324   if ((us & 0x0400))
325     DEBUGOUT ("    Auto IFSD exchange\n");
326
327   if ((us & 0x00010000))
328     {
329       DEBUGOUT ("    TPDU level exchange\n");
330       have_tpdu = 1;
331     } 
332   else if ((us & 0x00020000))
333     DEBUGOUT ("    Short APDU level exchange\n");
334   else if ((us & 0x00040000))
335     DEBUGOUT ("    Short and extended APDU level exchange\n");
336   else if ((us & 0x00070000))
337     DEBUGOUT ("    WARNING: conflicting exchange levels\n");
338
339   us = convert_le_u32(buf+44);
340   DEBUGOUT_1 ("  dwMaxCCIDMsgLen     %5u\n", us);
341
342   DEBUGOUT (  "  bClassGetResponse    ");
343   if (buf[48] == 0xff)
344     DEBUGOUT_CONT ("echo\n");
345   else
346     DEBUGOUT_CONT_1 ("  %02X\n", buf[48]);
347
348   DEBUGOUT (  "  bClassEnvelope       ");
349   if (buf[49] == 0xff)
350     DEBUGOUT_CONT ("echo\n");
351   else
352     DEBUGOUT_1 ("  %02X\n", buf[48]);
353
354   DEBUGOUT (  "  wlcdLayout           ");
355   if (!buf[50] && !buf[51])
356     DEBUGOUT_CONT ("none\n");
357   else
358     DEBUGOUT_CONT_2 ("%u cols %u lines\n", buf[50], buf[51]);
359         
360   DEBUGOUT_1 ("  bPINSupport         %5u ", buf[52]);
361   if ((buf[52] & 1))
362     DEBUGOUT_CONT ( " verification");
363   if ((buf[52] & 2))
364     DEBUGOUT_CONT ( " modification");
365   DEBUGOUT_LF ();
366         
367   DEBUGOUT_1 ("  bMaxCCIDBusySlots   %5u\n", buf[53]);
368
369   if (buf[0] > 54) {
370     DEBUGOUT ("  junk             ");
371     for (i=54; i < buf[0]-54; i++)
372       DEBUGOUT_CONT_1 (" %02X", buf[i]);
373     DEBUGOUT_LF ();
374   }
375
376   if (!have_t1 || !have_tpdu || !have_auto_conf)
377     {
378       DEBUGOUT ("this drivers requires that the reader supports T=1, "
379                 "TPDU level exchange and auto configuration - "
380                 "this is not available\n");
381       return -1;
382     }
383   else
384     return 0;
385 }
386
387
388 /* Read the device information, return all required data and check
389    that the device is usable for us.  Returns 0 on success or an error
390    code. */
391 static int
392 read_device_info (struct usb_device *dev)
393 {
394   int cfg_no;
395
396   for (cfg_no=0; cfg_no < dev->descriptor->bNumConfigurations; cfg_no++)
397     {
398       struct usb_config_descriptor *config = dev->config + cfg_no;
399       int ifc_no;
400
401       for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
402         {
403           struct usb_interface *interface = config->interface + ifc_no;
404           int set_no;
405
406           for (set_no=0; set_no < interface->num_altsetting; set_no++)
407             {
408               struct usb_interface_descriptor *ifcdesc
409                 = interface->altsetting + set_no;
410               
411               if (ifcdesc->bInterfaceClass == 11
412                   && ifcdesc->bInterfaceSubClass == 0
413                   && ifcdesc->bInterfaceProtocol == 0)
414                 {
415                   if (ifcdesc->extra)
416                     {
417                       if (!parse_ccid_descriptor (ifcdesc->extra,
418                                                  ifcdesc->extralen))
419                         return 0; /* okay. we can use it. */
420                     }
421                 }
422             }
423         }
424     }
425   return -1; /* No suitable device found. */
426 }
427
428
429 /* Open the reader with the internal number READERNO and return a a
430    pointer to be used as handle in HANDLE.  Returns 0 on success. */
431 int 
432 ccid_open_reader (ccid_driver_t *handle, int readerno)
433 {
434   static int initialized;
435
436   int rc;
437   usb_match_handle *match = NULL;
438   struct usb_device *dev = NULL;
439   usb_dev_handle *idev = NULL;
440
441   *handle = NULL;
442   if (!initialized)
443     {
444       usb_init ();
445       initialized = 1;
446     }
447   
448   rc = usb_create_match (&match, -1, -1, 11, -1, -1);
449   if (rc)
450     {
451       DEBUGOUT_1 ("usb_create_match failed: %d\n", rc);
452       return -1;
453     }
454
455   while (usb_find_device(match, dev, &dev) >= 0) 
456     {
457       DEBUGOUT_3 ("%-40s %04X/%04X\n", dev->filename,
458                   dev->descriptor->idVendor, dev->descriptor->idProduct);
459       if (!readerno)
460         {
461           rc = read_device_info (dev);
462           if (rc)
463             {
464               DEBUGOUT ("device not supported\n");
465               goto leave;
466             }
467
468           rc = usb_open (dev, &idev);
469           if (rc)
470             {
471               DEBUGOUT_1 ("usb_open failed: %d\n", rc);
472               goto leave;
473             }
474
475
476           /* fixme: Do we need to claim and set the interface as
477              determined by read_device_info ()? */
478           rc = usb_claim_interface (idev, 0);
479           if (rc)
480             {
481               DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
482               goto leave;
483             }
484
485           *handle = calloc (1, sizeof **handle);
486           if (!*handle)
487             {
488               DEBUGOUT ("out of memory\n");
489               rc = -1;
490               goto leave;
491             }
492           (*handle)->idev = idev;
493           idev = NULL;
494           /* FIXME: Do we need to get the endpoint addresses from the
495              structure and store them with the handle? */
496
497           break;
498         }
499       readerno--;
500     }
501
502
503  leave:
504   if (idev)
505     usb_close (idev);
506   /* fixme: Do we need to release dev or is it supposed to be a
507      shallow copy of the list created internally by usb_init ? */
508   usb_free_match (match);
509
510   if (!rc && !*handle)
511     rc = -1; /* In case we didn't enter the while lool at all. */
512
513   return rc;
514 }
515
516
517 /* Close the reader HANDLE. */
518 int 
519 ccid_close_reader (ccid_driver_t handle)
520 {
521   if (!handle || !handle->idev)
522     return 0;
523
524    {
525      int rc;
526      unsigned char msg[100];
527      size_t msglen;
528      unsigned char seqno;
529    
530      msg[0] = PC_to_RDR_IccPowerOff;
531      msg[5] = 0; /* slot */
532      msg[6] = seqno = handle->seqno++;
533      msg[7] = 0; /* RFU */
534      msg[8] = 0; /* RFU */
535      msg[9] = 0; /* RFU */
536      set_msg_len (msg, 0);
537      msglen = 10;
538    
539      rc = bulk_out (handle, msg, msglen);
540      if (!rc)
541         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus, seqno);
542    }
543    
544   usb_release_interface (handle->idev, 0);
545   usb_close (handle->idev);
546   handle->idev = NULL;
547   free (handle);
548   return 0;
549 }
550
551
552 /* Return False if a card is present and powered. */
553 int
554 ccid_check_card_presence (ccid_driver_t handle)
555 {
556
557   return -1;
558 }
559
560
561 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
562    Returns 0 on success. */
563 static int
564 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen)
565 {
566   int rc;
567
568   rc = usb_bulk_write (handle->idev, 
569                        1, /*endpoint */
570                        msg, msglen,
571                        1000 /* ms timeout */);
572   if (rc == msglen)
573     return 0;
574
575   if (rc == -1)
576     DEBUGOUT_1 ("usb_bulk_write error: %s\n", strerror (errno));
577   else
578     DEBUGOUT_1 ("usb_bulk_write failed: %d\n", rc);
579   return -1;
580 }
581
582
583 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
584    BUFFER and return the actual read number if bytes in NREAD. SEQNO
585    is the sequence number used to send the request and EXPECTED_TYPE
586    the type of message we expect. Does checks on the ccid
587    header. Returns 0 on success. */
588 static int
589 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
590          size_t *nread, int expected_type, int seqno)
591 {
592   int i, rc;
593   size_t msglen;
594
595   rc = usb_bulk_read (handle->idev, 
596                       0x82,
597                       buffer, length,
598                       10000 /* ms timeout */ );
599   /* Fixme: instead of using a 10 second timeout we should better
600      handle the timeout here and retry if appropriate.  */
601   if (rc < 0)
602     {
603       DEBUGOUT_1 ("usb_bulk_read error: %s\n", strerror (errno));
604       return -1;
605     }
606
607   *nread = msglen = rc;
608
609   if (msglen < 10)
610     {
611       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
612       return -1;
613     }
614   if (buffer[0] != expected_type)
615     {
616       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
617       return -1;
618     }
619   if (buffer[5] != 0)    
620     {
621       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
622       return -1;
623     }
624   if (buffer[6] != seqno)    
625     {
626       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
627                   seqno, buffer[6]);
628       return -1;
629     }
630
631   DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n"
632               "               data:",  buffer[7], buffer[8], buffer[9] );
633   for (i=10; i < msglen; i++)
634     DEBUGOUT_CONT_1 (" %02X", buffer[i]);
635   DEBUGOUT_LF ();
636
637   return 0;
638 }
639
640
641 /* experimental */
642 int
643 ccid_poll (ccid_driver_t handle)
644 {
645   int rc;
646   unsigned char msg[10];
647   size_t msglen;
648   int i, j;
649
650   rc = usb_bulk_read (handle->idev, 
651                       0x83,
652                       msg, sizeof msg,
653                       0 /* ms timeout */ );
654   if (rc < 0 && errno == ETIMEDOUT)
655     return 0;
656
657   if (rc < 0)
658     {
659       DEBUGOUT_1 ("usb_intr_read error: %s\n", strerror (errno));
660       return -1;
661     }
662
663   msglen = rc;
664   rc = 0;
665
666   if (msglen < 1)
667     {
668       DEBUGOUT ("intr-in msg too short\n");
669       return -1;
670     }
671
672   if (msg[0] == RDR_to_PC_NotifySlotChange)
673     {
674       DEBUGOUT ("notify slot change:");
675       for (i=1; i < msglen; i++)
676         for (j=0; j < 4; j++)
677           DEBUGOUT_CONT_3 (" %d:%c%c",
678                            (i-1)*4+j, 
679                            (msg[i] & (1<<(j*2)))? 'p':'-',
680                            (msg[i] & (2<<(j*2)))? '*':' ');
681       DEBUGOUT_LF ();
682     }
683   else if (msg[0] == RDR_to_PC_HardwareError)    
684     {
685       DEBUGOUT ("hardware error occured\n");
686     }
687   else
688     {
689       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
690     }
691
692   return 0;
693 }
694
695
696
697 int 
698 ccid_slot_status (ccid_driver_t handle)
699 {
700   int rc;
701   unsigned char msg[100];
702   size_t msglen;
703   unsigned char seqno;
704
705   msg[0] = PC_to_RDR_GetSlotStatus;
706   msg[5] = 0; /* slot */
707   msg[6] = seqno = handle->seqno++;
708   msg[7] = 0; /* RFU */
709   msg[8] = 0; /* RFU */
710   msg[9] = 0; /* RFU */
711   set_msg_len (msg, 0);
712
713   rc = bulk_out (handle, msg, 10);
714   if (rc)
715     return rc;
716   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus, seqno);
717   if (rc)
718     return rc;
719
720   return 0;
721 }
722
723
724 int 
725 ccid_get_atr (ccid_driver_t handle,
726               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
727 {
728   int rc;
729   unsigned char msg[100];
730   size_t msglen;
731   unsigned char seqno;
732
733   msg[0] = PC_to_RDR_IccPowerOn;
734   msg[5] = 0; /* slot */
735   msg[6] = seqno = handle->seqno++;
736   msg[7] = 0; /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
737   msg[8] = 0; /* RFU */
738   msg[9] = 0; /* RFU */
739   set_msg_len (msg, 0);
740   msglen = 10;
741
742   rc = bulk_out (handle, msg, msglen);
743   if (rc)
744     return rc;
745   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock, seqno);
746   if (rc)
747     return rc;
748   
749   if (atr)
750     {
751       size_t n = msglen - 10;
752
753       if (n > maxatrlen)
754         n = maxatrlen;
755       memcpy (atr, msg+10, n);
756       *atrlen = n;
757     }
758
759   return 0;
760 }
761
762
763 \f
764 /*
765   Protocol T=1 overview
766
767   Block Structure:
768            Prologue Field:
769    1 byte     Node Address (NAD) 
770    1 byte     Protocol Control Byte (PCB)
771    1 byte     Length (LEN) 
772            Information Field:
773    0-254 byte APDU or Control Information (INF)
774            Epilogue Field:
775    1 byte     Error Detection Code (EDC)
776
777   NAD:  
778    bit 7     unused
779    bit 4..6  Destination Node Address (DAD)
780    bit 3     unused
781    bit 2..0  Source Node Address (SAD)
782
783    If node adresses are not used, SAD and DAD should be set to 0 on
784    the first block sent to the card.  If they are used they should
785    have different values (0 for one is okay); that first block sets up
786    the addresses of the nodes.
787
788   PCB:
789    Information Block (I-Block):
790       bit 7    0
791       bit 6    Sequence number (yep, that is modulo 2)
792       bit 5    Chaining flag 
793       bit 4..0 reserved
794    Received-Ready Block (R-Block):
795       bit 7    1
796       bit 6    0
797       bit 5    0
798       bit 4    Sequence number
799       bit 3..0  0 = no error
800                 1 = EDC or parity error
801                 2 = other error
802                 other values are reserved
803    Supervisory Block (S-Block):
804       bit 7    1
805       bit 6    1
806       bit 5    clear=request,set=response
807       bit 4..0  0 = resyncronisation request
808                 1 = information field size request
809                 2 = abort request
810                 3 = extension of BWT request
811                 4 = VPP error
812                 other values are reserved
813
814 */
815
816 int
817 ccid_transceive (ccid_driver_t handle,
818                  const unsigned char *apdu_buf, size_t apdu_buflen,
819                  unsigned char *resp, size_t maxresplen, size_t *nresp)
820 {
821   int rc;
822   unsigned char send_buffer[10+258], recv_buffer[10+258];
823   const unsigned char *apdu;
824   size_t apdulen;
825   unsigned char *msg, *tpdu, *p;
826   size_t msglen, tpdulen, n;
827   unsigned char seqno;
828   int i;
829   unsigned char crc;
830   size_t dummy_nresp;
831   int next_chunk = 1;
832   int sending = 1;
833
834   if (!nresp)
835     nresp = &dummy_nresp;
836   *nresp = 0;
837
838   tpdulen = 0; /* Avoid compiler warning about no initialization. */
839   msg = send_buffer;
840   for (;;)
841     {
842       if (next_chunk)
843         {
844           next_chunk = 0;
845
846           apdu = apdu_buf;
847           apdulen = apdu_buflen;
848           assert (apdulen);
849
850           /* Construct an I-Block. */
851           if (apdulen > 254)
852             return -1; /* Invalid length. */
853
854           tpdu = msg+10;
855           tpdu[0] = ((1 << 4) | 0); /* NAD: DAD=1, SAD=0 */
856           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
857           if (apdulen > 128 /* fixme: replace by ifsc */)
858             {
859               apdulen = 128;
860               apdu_buf += 128;  
861               apdu_buflen -= 128;
862               tpdu[1] |= (1 << 5); /* Set more bit. */
863             }
864           tpdu[2] = apdulen;
865           memcpy (tpdu+3, apdu, apdulen);
866           crc = 0;
867           for (i=0,p=tpdu; i < apdulen+3; i++)
868             crc ^= *p++;
869           tpdu[3+apdulen] = crc;
870           
871           tpdulen = apdulen + 4;
872         }
873
874       msg[0] = PC_to_RDR_XfrBlock;
875       msg[5] = 0; /* slot */
876       msg[6] = seqno = handle->seqno++;
877       msg[7] = 4; /* bBWI */
878       msg[8] = 0; /* RFU */
879       msg[9] = 0; /* RFU */
880       set_msg_len (msg, tpdulen);
881       msglen = 10 + tpdulen;
882
883       DEBUGOUT ("sending");
884       for (i=0; i < msglen; i++)
885         DEBUGOUT_CONT_1 (" %02X", msg[i]);
886       DEBUGOUT_LF ();
887
888 #ifdef DEBUG_T1      
889       fprintf (stderr, "T1: put %c-block seq=%d\n",
890                ((msg[11] & 0xc0) == 0x80)? 'R' :
891                (msg[11] & 0x80)? 'S' : 'I',
892         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)));
893 #endif  
894
895       rc = bulk_out (handle, msg, msglen);
896       if (rc)
897         return rc;
898
899       /* Fixme: The next line for the current Valgrid without support
900          for USB IOCTLs. */
901       memset (recv_buffer, 0, sizeof recv_buffer);
902
903       msg = recv_buffer;
904       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
905                     RDR_to_PC_DataBlock, seqno);
906       if (rc)
907         return rc;
908       
909       tpdu = msg + 10;
910       tpdulen = msglen - 10;
911       
912       if (tpdulen < 4) 
913         {
914           DEBUGOUT ("cannot yet handle short blocks!\n");
915           return -1; 
916         }
917
918 #ifdef DEBUG_T1
919       fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
920                ((msg[11] & 0xc0) == 0x80)? 'R' :
921                (msg[11] & 0x80)? 'S' : 'I',
922         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
923                ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
924                );
925 #endif
926
927       if (!(tpdu[1] & 0x80))
928         { /* This is an I-block. */
929           
930           if (sending)
931             { /* last block sent was successful. */
932               handle->t1_ns ^= 1;
933               sending = 0;
934             }
935
936           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
937             { /* Reponse does not match our sequence number. */
938               msg = send_buffer;
939               tpdu = msg+10;
940               tpdu[0] = ((1 << 4) | 0); /* NAD: DAD=1, SAD=0 */
941               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
942               tpdu[2] = 0;
943               tpdulen = 3;
944               for (crc=0,i=0,p=tpdu; i < tpdulen; i++)
945                 crc ^= *p++;
946               tpdu[tpdulen++] = crc;
947
948               continue;
949             }
950
951           handle->t1_nr ^= 1;
952
953           p = tpdu + 3; /* Skip the prologue field. */
954           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
955           /* fixme: verify the checksum. */
956           if (resp)
957             {
958               if (n > maxresplen)
959                 {
960                   DEBUGOUT_2 ("provided buffer too short for received data "
961                               "(%u/%u)\n",
962                               (unsigned int)n, (unsigned int)maxresplen);
963                   return -1;
964                 }
965               
966               memcpy (resp, p, n); 
967               resp += n;
968               *nresp += n;
969               maxresplen -= n;
970             }
971           
972           if (!(tpdu[1] & 0x20))
973             return 0; /* No chaining requested - ready. */
974           
975           msg = send_buffer;
976           tpdu = msg+10;
977           tpdu[0] = ((1 << 4) | 0); /* NAD: DAD=1, SAD=0 */
978           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
979           tpdu[2] = 0;
980           tpdulen = 3;
981           for (crc=0,i=0,p=tpdu; i < tpdulen; i++)
982             crc ^= *p++;
983           tpdu[tpdulen++] = crc;
984           
985         }
986       else if ((tpdu[1] & 0xc0) == 0x80)
987         { /* This is a R-block. */
988           if ( (tpdu[1] & 0x0f)) 
989             { /* Error: repeat last block */
990               msg = send_buffer;
991             }
992           else if (sending && !!(tpdu[1] & 0x40) == handle->t1_ns)
993             { /* Reponse does not match our sequence number. */
994               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
995               return -1;
996             }
997           else if (sending)
998             { /* Send next chunk. */
999               msg = send_buffer;
1000               next_chunk = 1;
1001               handle->t1_ns ^= 1;
1002             }
1003           else
1004             {
1005               DEBUGOUT ("unexpected ACK R-block received\n");
1006               return -1;
1007             }
1008         }
1009       else 
1010         { /* This is a S-block. */
1011           DEBUGOUT_2 ("T1 S-block %s received cmd=%d\n",
1012                       (tpdu[1] & 0x20)? "response": "request",
1013                       (tpdu[1] & 0x1f));
1014           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
1015             { /* Wait time extension request. */
1016               unsigned char bwi = tpdu[3];
1017               msg = send_buffer;
1018               tpdu = msg+10;
1019               tpdu[0] = ((1 << 4) | 0); /* NAD: DAD=1, SAD=0 */
1020               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
1021               tpdu[2] = 1;
1022               tpdu[3] = bwi;
1023               tpdulen = 4;
1024               for (crc=0,i=0,p=tpdu; i < tpdulen; i++)
1025                 crc ^= *p++;
1026               tpdu[tpdulen++] = crc;
1027               DEBUGOUT_1 ("T1 waittime extension of bwi=%d\n", bwi);
1028             }
1029           else
1030             return -1;
1031         }
1032     } /* end T=1 protocol loop. */
1033
1034   return 0;
1035 }
1036
1037
1038
1039
1040 #ifdef TEST
1041 int
1042 main (int argc, char **argv)
1043 {
1044   int rc;
1045   ccid_driver_t ccid;
1046
1047   rc = ccid_open_reader (&ccid, 0);
1048   if (rc)
1049     return 1;
1050
1051   ccid_poll (ccid);
1052   fputs ("getting ATR ...\n", stderr);
1053   rc = ccid_get_atr (ccid, NULL, 0, NULL);
1054   if (rc)
1055     return 1;
1056
1057   ccid_poll (ccid);
1058   fputs ("getting slot status ...\n", stderr);
1059   rc = ccid_slot_status (ccid);
1060   if (rc)
1061     return 1;
1062
1063   ccid_poll (ccid);
1064
1065   {
1066     static unsigned char apdu[] = {
1067       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
1068   rc = ccid_transceive (ccid,
1069                         apdu, sizeof apdu,
1070                         NULL, 0, NULL);
1071   }
1072   ccid_poll (ccid);
1073
1074   {
1075     static unsigned char apdu[] = {
1076       0, 0xCA, 0, 0x65, 254 };
1077   rc = ccid_transceive (ccid,
1078                         apdu, sizeof apdu,
1079                         NULL, 0, NULL);
1080   }
1081   ccid_poll (ccid);
1082
1083
1084   return 0;
1085 }
1086
1087 /*
1088  * Local Variables:
1089  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
1090  * End:
1091  */
1092 #endif /*TEST*/
1093 #endif /*HAVE_LIBUSB*/