* command.c (cmd_genkey, cmd_passwd): Fixed faulty use of
[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 # 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   return rc;
498 }
499
500
501 /* Close the reader HANDLE. */
502 int 
503 ccid_close_reader (ccid_driver_t handle)
504 {
505   if (!handle || !handle->idev)
506     return 0;
507
508    {
509      int rc;
510      unsigned char msg[100];
511      size_t msglen;
512      unsigned char seqno;
513    
514      msg[0] = PC_to_RDR_IccPowerOff;
515      msg[5] = 0; /* slot */
516      msg[6] = seqno = handle->seqno++;
517      msg[7] = 0; /* RFU */
518      msg[8] = 0; /* RFU */
519      msg[9] = 0; /* RFU */
520      set_msg_len (msg, 0);
521      msglen = 10;
522    
523      rc = bulk_out (handle, msg, msglen);
524      if (!rc)
525         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus, seqno);
526    }
527    
528   usb_release_interface (handle->idev, 0);
529   usb_close (handle->idev);
530   handle->idev = NULL;
531   free (handle);
532   return 0;
533 }
534
535
536 /* Return False if a card is present and powered. */
537 int
538 ccid_check_card_presence (ccid_driver_t handle)
539 {
540
541   return -1;
542 }
543
544
545 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
546    Returns 0 on success. */
547 static int
548 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen)
549 {
550   int rc;
551
552   rc = usb_bulk_write (handle->idev, 
553                        1, /*endpoint */
554                        msg, msglen,
555                        1000 /* ms timeout */);
556   if (rc == msglen)
557     return 0;
558
559   if (rc == -1)
560     DEBUGOUT_1 ("usb_bulk_write error: %s\n", strerror (errno));
561   else
562     DEBUGOUT_1 ("usb_bulk_write failed: %d\n", rc);
563   return -1;
564 }
565
566
567 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
568    BUFFER and return the actual read number if bytes in NREAD. SEQNO
569    is the sequence number used to send the request and EXPECTED_TYPE
570    the type of message we expect. Does checks on the ccid
571    header. Returns 0 on success. */
572 static int
573 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
574          size_t *nread, int expected_type, int seqno)
575 {
576   int i, rc;
577   size_t msglen;
578
579   rc = usb_bulk_read (handle->idev, 
580                       0x82,
581                       buffer, length,
582                       10000 /* ms timeout */ );
583   /* Fixme: instead of using a 10 second timeout we should better
584      handle the timeout here and retry if appropriate.  */
585   if (rc < 0)
586     {
587       DEBUGOUT_1 ("usb_bulk_read error: %s\n", strerror (errno));
588       return -1;
589     }
590
591   *nread = msglen = rc;
592
593   if (msglen < 10)
594     {
595       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
596       return -1;
597     }
598   if (buffer[0] != expected_type)
599     {
600       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
601       return -1;
602     }
603   if (buffer[5] != 0)    
604     {
605       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
606       return -1;
607     }
608   if (buffer[6] != seqno)    
609     {
610       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
611                   seqno, buffer[6]);
612       return -1;
613     }
614
615   DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n"
616               "               data:",  buffer[7], buffer[8], buffer[9] );
617   for (i=10; i < msglen; i++)
618     DEBUGOUT_CONT_1 (" %02X", buffer[i]);
619   DEBUGOUT_LF ();
620
621   return 0;
622 }
623
624
625 /* experimental */
626 int
627 ccid_poll (ccid_driver_t handle)
628 {
629   int rc;
630   unsigned char msg[10];
631   size_t msglen;
632   int i, j;
633
634   rc = usb_bulk_read (handle->idev, 
635                       0x83,
636                       msg, sizeof msg,
637                       0 /* ms timeout */ );
638   if (rc < 0 && errno == ETIMEDOUT)
639     return 0;
640
641   if (rc < 0)
642     {
643       DEBUGOUT_1 ("usb_intr_read error: %s\n", strerror (errno));
644       return -1;
645     }
646
647   msglen = rc;
648   rc = 0;
649
650   if (msglen < 1)
651     {
652       DEBUGOUT ("intr-in msg too short\n");
653       return -1;
654     }
655
656   if (msg[0] == RDR_to_PC_NotifySlotChange)
657     {
658       DEBUGOUT ("notify slot change:");
659       for (i=1; i < msglen; i++)
660         for (j=0; j < 4; j++)
661           DEBUGOUT_CONT_3 (" %d:%c%c",
662                            (i-1)*4+j, 
663                            (msg[i] & (1<<(j*2)))? 'p':'-',
664                            (msg[i] & (2<<(j*2)))? '*':' ');
665       DEBUGOUT_LF ();
666     }
667   else if (msg[0] == RDR_to_PC_HardwareError)    
668     {
669       DEBUGOUT ("hardware error occured\n");
670     }
671   else
672     {
673       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
674     }
675
676   return 0;
677 }
678
679
680
681 int 
682 ccid_slot_status (ccid_driver_t handle)
683 {
684   int rc;
685   unsigned char msg[100];
686   size_t msglen;
687   unsigned char seqno;
688
689   msg[0] = PC_to_RDR_GetSlotStatus;
690   msg[5] = 0; /* slot */
691   msg[6] = seqno = handle->seqno++;
692   msg[7] = 0; /* RFU */
693   msg[8] = 0; /* RFU */
694   msg[9] = 0; /* RFU */
695   set_msg_len (msg, 0);
696
697   rc = bulk_out (handle, msg, 10);
698   if (rc)
699     return rc;
700   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus, seqno);
701   if (rc)
702     return rc;
703
704   return 0;
705 }
706
707
708 int 
709 ccid_get_atr (ccid_driver_t handle,
710               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
711 {
712   int rc;
713   unsigned char msg[100];
714   size_t msglen;
715   unsigned char seqno;
716
717   msg[0] = PC_to_RDR_IccPowerOn;
718   msg[5] = 0; /* slot */
719   msg[6] = seqno = handle->seqno++;
720   msg[7] = 0; /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
721   msg[8] = 0; /* RFU */
722   msg[9] = 0; /* RFU */
723   set_msg_len (msg, 0);
724   msglen = 10;
725
726   rc = bulk_out (handle, msg, msglen);
727   if (rc)
728     return rc;
729   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock, seqno);
730   if (rc)
731     return rc;
732   
733   if (atr)
734     {
735       size_t n = msglen - 10;
736
737       if (n > maxatrlen)
738         n = maxatrlen;
739       memcpy (atr, msg+10, n);
740       *atrlen = n;
741     }
742
743   return 0;
744 }
745
746
747 \f
748 /*
749   Protocol T=1 overview
750
751   Block Structure:
752            Prologue Field:
753    1 byte     Node Address (NAD) 
754    1 byte     Protocol Control Byte (PCB)
755    1 byte     Length (LEN) 
756            Information Field:
757    0-254 byte APDU or Control Information (INF)
758            Epilogue Field:
759    1 byte     Error Detection Code (EDC)
760
761   NAD:  
762    bit 7     unused
763    bit 4..6  Destination Node Address (DAD)
764    bit 3     unused
765    bit 2..0  Source Node Address (SAD)
766
767    If node adresses are not used, SAD and DAD should be set to 0 on
768    the first block sent to the card.  If they are used they should
769    have different values (0 for one is okay); that first block sets up
770    the addresses of the nodes.
771
772   PCB:
773    Information Block (I-Block):
774       bit 7    0
775       bit 6    Sequence number (yep, that is modulo 2)
776       bit 5    Chaining flag 
777       bit 4..0 reserved
778    Received-Ready Block (R-Block):
779       bit 7    1
780       bit 6    0
781       bit 5    0
782       bit 4    Sequence number
783       bit 3..0  0 = no error
784                 1 = EDC or parity error
785                 2 = other error
786                 other values are reserved
787    Supervisory Block (S-Block):
788       bit 7    1
789       bit 6    1
790       bit 5    clear=request,set=response
791       bit 4..0  0 = resyncronisation request
792                 1 = information field size request
793                 2 = abort request
794                 3 = extension of BWT request
795                 4 = VPP error
796                 other values are reserved
797
798 */
799
800 int
801 ccid_transceive (ccid_driver_t handle,
802                  const unsigned char *apdu_buf, size_t apdu_buflen,
803                  unsigned char *resp, size_t maxresplen, size_t *nresp)
804 {
805   int rc;
806   unsigned char send_buffer[10+258], recv_buffer[10+258];
807   const unsigned char *apdu;
808   size_t apdulen;
809   unsigned char *msg, *tpdu, *p;
810   size_t msglen, tpdulen, n;
811   unsigned char seqno;
812   int i;
813   unsigned char crc;
814   size_t dummy_nresp;
815   int next_chunk = 1;
816   int sending = 1;
817
818   if (!nresp)
819     nresp = &dummy_nresp;
820   *nresp = 0;
821
822   tpdulen = 0; /* Avoid compiler warning about no initialization. */
823   msg = send_buffer;
824   for (;;)
825     {
826       if (next_chunk)
827         {
828           next_chunk = 0;
829
830           apdu = apdu_buf;
831           apdulen = apdu_buflen;
832           assert (apdulen);
833
834           /* Construct an I-Block. */
835           if (apdulen > 254)
836             return -1; /* Invalid length. */
837
838           tpdu = msg+10;
839           tpdu[0] = ((1 << 4) | 0); /* NAD: DAD=1, SAD=0 */
840           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
841           if (apdulen > 128 /* fixme: replace by ifsc */)
842             {
843               apdulen = 128;
844               apdu_buf += 128;  
845               apdu_buflen -= 128;
846               tpdu[1] |= (1 << 5); /* Set more bit. */
847             }
848           tpdu[2] = apdulen;
849           memcpy (tpdu+3, apdu, apdulen);
850           crc = 0;
851           for (i=0,p=tpdu; i < apdulen+3; i++)
852             crc ^= *p++;
853           tpdu[3+apdulen] = crc;
854           
855           tpdulen = apdulen + 4;
856         }
857
858       msg[0] = PC_to_RDR_XfrBlock;
859       msg[5] = 0; /* slot */
860       msg[6] = seqno = handle->seqno++;
861       msg[7] = 4; /* bBWI */
862       msg[8] = 0; /* RFU */
863       msg[9] = 0; /* RFU */
864       set_msg_len (msg, tpdulen);
865       msglen = 10 + tpdulen;
866
867       DEBUGOUT ("sending");
868       for (i=0; i < msglen; i++)
869         DEBUGOUT_CONT_1 (" %02X", msg[i]);
870       DEBUGOUT_LF ();
871
872 #ifdef DEBUG_T1      
873       fprintf (stderr, "T1: put %c-block seq=%d\n",
874                ((msg[11] & 0xc0) == 0x80)? 'R' :
875                (msg[11] & 0x80)? 'S' : 'I',
876         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)));
877 #endif  
878
879       rc = bulk_out (handle, msg, msglen);
880       if (rc)
881         return rc;
882
883       /* Fixme: The next line for the current Valgrid without support
884          for USB IOCTLs. */
885       memset (recv_buffer, 0, sizeof recv_buffer);
886
887       msg = recv_buffer;
888       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
889                     RDR_to_PC_DataBlock, seqno);
890       if (rc)
891         return rc;
892       
893       tpdu = msg + 10;
894       tpdulen = msglen - 10;
895       
896       if (tpdulen < 4) 
897         {
898           DEBUGOUT ("cannot yet handle short blocks!\n");
899           return -1; 
900         }
901
902 #ifdef DEBUG_T1
903       fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
904                ((msg[11] & 0xc0) == 0x80)? 'R' :
905                (msg[11] & 0x80)? 'S' : 'I',
906         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
907                ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
908                );
909 #endif
910
911       if (!(tpdu[1] & 0x80))
912         { /* This is an I-block. */
913           
914           if (sending)
915             { /* last block sent was successful. */
916               handle->t1_ns ^= 1;
917               sending = 0;
918             }
919
920           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
921             { /* Reponse does not match our sequence number. */
922               msg = send_buffer;
923               tpdu = msg+10;
924               tpdu[0] = ((1 << 4) | 0); /* NAD: DAD=1, SAD=0 */
925               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
926               tpdu[2] = 0;
927               tpdulen = 3;
928               for (crc=0,i=0,p=tpdu; i < tpdulen; i++)
929                 crc ^= *p++;
930               tpdu[tpdulen++] = crc;
931
932               continue;
933             }
934
935           handle->t1_nr ^= 1;
936
937           p = tpdu + 3; /* Skip the prologue field. */
938           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
939           /* fixme: verify the checksum. */
940           if (resp)
941             {
942               if (n > maxresplen)
943                 {
944                   DEBUGOUT ("provided buffer too short for received data\n");
945                   return -1;
946                 }
947               
948               memcpy (resp, p, n); 
949               resp += n;
950               *nresp += n;
951               maxresplen -= n;
952             }
953           
954           if (!(tpdu[1] & 0x20))
955             return 0; /* No chaining requested - ready. */
956           
957           msg = send_buffer;
958           tpdu = msg+10;
959           tpdu[0] = ((1 << 4) | 0); /* NAD: DAD=1, SAD=0 */
960           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
961           tpdu[2] = 0;
962           tpdulen = 3;
963           for (crc=0,i=0,p=tpdu; i < tpdulen; i++)
964             crc ^= *p++;
965           tpdu[tpdulen++] = crc;
966           
967         }
968       else if ((tpdu[1] & 0xc0) == 0x80)
969         { /* This is a R-block. */
970           if ( (tpdu[1] & 0x0f)) 
971             { /* Error: repeat last block */
972               msg = send_buffer;
973             }
974           else if (sending && !!(tpdu[1] & 0x40) == handle->t1_ns)
975             { /* Reponse does not match our sequence number. */
976               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
977               return -1;
978             }
979           else if (sending)
980             { /* Send next chunk. */
981               msg = send_buffer;
982               next_chunk = 1;
983               handle->t1_ns ^= 1;
984             }
985           else
986             {
987               DEBUGOUT ("unexpected ACK R-block received\n");
988               return -1;
989             }
990         }
991       else 
992         { /* This is a S-block. */
993           DEBUGOUT_2 ("T1 S-block %s received cmd=%d\n",
994                       (tpdu[1] & 0x20)? "response": "request",
995                       (tpdu[1] & 0x1f));
996           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
997             { /* Wait time extension request. */
998               unsigned char bwi = tpdu[3];
999               msg = send_buffer;
1000               tpdu = msg+10;
1001               tpdu[0] = ((1 << 4) | 0); /* NAD: DAD=1, SAD=0 */
1002               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
1003               tpdu[2] = 1;
1004               tpdu[3] = bwi;
1005               tpdulen = 4;
1006               for (crc=0,i=0,p=tpdu; i < tpdulen; i++)
1007                 crc ^= *p++;
1008               tpdu[tpdulen++] = crc;
1009               DEBUGOUT_1 ("T1 waittime extension of bwi=%d\n", bwi);
1010             }
1011           else
1012             return -1;
1013         }
1014     } /* end T=1 protocol loop. */
1015
1016   return 0;
1017 }
1018
1019
1020
1021
1022 #ifdef TEST
1023 int
1024 main (int argc, char **argv)
1025 {
1026   int rc;
1027   ccid_driver_t ccid;
1028
1029   rc = ccid_open_reader (&ccid, 0);
1030   if (rc)
1031     return 1;
1032
1033   ccid_poll (ccid);
1034   fputs ("getting ATR ...\n", stderr);
1035   rc = ccid_get_atr (ccid, NULL, 0, NULL);
1036   if (rc)
1037     return 1;
1038
1039   ccid_poll (ccid);
1040   fputs ("getting slot status ...\n", stderr);
1041   rc = ccid_slot_status (ccid);
1042   if (rc)
1043     return 1;
1044
1045   ccid_poll (ccid);
1046
1047   {
1048     static unsigned char apdu[] = {
1049       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
1050   rc = ccid_transceive (ccid,
1051                         apdu, sizeof apdu,
1052                         NULL, 0, NULL);
1053   }
1054   ccid_poll (ccid);
1055
1056   {
1057     static unsigned char apdu[] = {
1058       0, 0xCA, 0, 0x65, 254 };
1059   rc = ccid_transceive (ccid,
1060                         apdu, sizeof apdu,
1061                         NULL, 0, NULL);
1062   }
1063   ccid_poll (ccid);
1064
1065
1066   return 0;
1067 }
1068
1069 /*
1070  * Local Variables:
1071  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
1072  * End:
1073  */
1074 #endif /*TEST*/
1075 #endif /*HAVE_LIBUSB*/