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