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