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