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