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