* mainproc.c (symkey_decrypt_seskey): There is no need to have an
[gnupg.git] / g10 / ccid-driver.c
1 /* ccid-driver.c - USB ChipCardInterfaceDevices driver
2  *      Copyright (C) 2003, 2004, 2005 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  * $Date$
56  */
57
58
59 /* CCID (ChipCardInterfaceDevices) is a specification for accessing
60    smartcard via a reader connected to the USB.  
61
62    This is a limited driver allowing to use some CCID drivers directly
63    without any other specila drivers. This is a fallback driver to be
64    used when nothing else works or the system should be kept minimal
65    for security reasons.  It makes use of the libusb library to gain
66    portable access to USB.
67
68    This driver has been tested with the SCM SCR335 and SPR532
69    smartcard readers and requires that a reader implements the TPDU
70    level exchange and does fully automatic initialization.
71 */
72
73 #ifdef HAVE_CONFIG_H
74 # include <config.h>
75 #endif
76
77 #if defined(HAVE_LIBUSB) || defined(TEST)
78
79 #include <errno.h>
80 #include <stdio.h>
81 #include <stdlib.h>
82 #include <string.h>
83 #include <assert.h>
84
85 #include <usb.h>
86
87 #include "ccid-driver.h"
88
89 #define DRVNAME "ccid-driver: "
90
91
92 /* Depending on how this source is used we either define our error
93    output to go to stderr or to the jnlib based logging functions.  We
94    use the latter when GNUPG_MAJOR_VERSION is defines or when both,
95    GNUPG_SCD_MAIN_HEADER and HAVE_JNLIB_LOGGING are defined.
96 */
97 #if defined(GNUPG_MAJOR_VERSION) \
98     || (defined(GNUPG_SCD_MAIN_HEADER) && defined(HAVE_JNLIB_LOGGING))
99
100 #if defined(GNUPG_SCD_MAIN_HEADER)
101 #  include GNUPG_SCD_MAIN_HEADER
102 #elif GNUPG_MAJOR_VERSION == 1 /* GnuPG Version is < 1.9. */
103 #  include "options.h"
104 #  include "util.h"
105 #  include "memory.h"
106 #  include "cardglue.h"
107 # else /* This is the modularized GnuPG 1.9 or later. */
108 #  include "scdaemon.h"
109 #endif
110
111 /* Define to print information pertaining the T=1 protocol. */
112 #undef DEBUG_T1 
113
114
115 # define DEBUGOUT(t)         do { if (debug_level) \
116                                   log_debug (DRVNAME t); } while (0)
117 # define DEBUGOUT_1(t,a)     do { if (debug_level) \
118                                   log_debug (DRVNAME t,(a)); } while (0)
119 # define DEBUGOUT_2(t,a,b)   do { if (debug_level) \
120                                   log_debug (DRVNAME t,(a),(b)); } while (0)
121 # define DEBUGOUT_3(t,a,b,c) do { if (debug_level) \
122                                   log_debug (DRVNAME t,(a),(b),(c));} while (0)
123 # define DEBUGOUT_CONT(t)    do { if (debug_level) \
124                                   log_printf (t); } while (0)
125 # define DEBUGOUT_CONT_1(t,a)  do { if (debug_level) \
126                                   log_printf (t,(a)); } while (0)
127 # define DEBUGOUT_CONT_2(t,a,b)   do { if (debug_level) \
128                                   log_printf (t,(a),(b)); } while (0)
129 # define DEBUGOUT_CONT_3(t,a,b,c) do { if (debug_level) \
130                                   log_printf (t,(a),(b),(c)); } while (0)
131 # define DEBUGOUT_LF()       do { if (debug_level) \
132                                   log_printf ("\n"); } while (0)
133
134 #else /* Other usage of this source - don't use gnupg specifics. */
135
136 # define DEBUGOUT(t)          do { if (debug_level) \
137                      fprintf (stderr, DRVNAME t); } while (0)
138 # define DEBUGOUT_1(t,a)      do { if (debug_level) \
139                      fprintf (stderr, DRVNAME t, (a)); } while (0)
140 # define DEBUGOUT_2(t,a,b)    do { if (debug_level) \
141                      fprintf (stderr, DRVNAME t, (a), (b)); } while (0)
142 # define DEBUGOUT_3(t,a,b,c)  do { if (debug_level) \
143                      fprintf (stderr, DRVNAME t, (a), (b), (c)); } while (0)
144 # define DEBUGOUT_CONT(t)     do { if (debug_level) \
145                      fprintf (stderr, t); } while (0)
146 # define DEBUGOUT_CONT_1(t,a) do { if (debug_level) \
147                      fprintf (stderr, t, (a)); } while (0)
148 # define DEBUGOUT_CONT_2(t,a,b) do { if (debug_level) \
149                      fprintf (stderr, t, (a), (b)); } while (0)
150 # define DEBUGOUT_CONT_3(t,a,b,c) do { if (debug_level) \
151                      fprintf (stderr, t, (a), (b), (c)); } while (0)
152 # define DEBUGOUT_LF()        do { if (debug_level) \
153                      putc ('\n', stderr); } while (0)
154
155 #endif /* This source not used by scdaemon. */
156
157
158
159 enum {
160   RDR_to_PC_NotifySlotChange= 0x50,
161   RDR_to_PC_HardwareError   = 0x51,
162
163   PC_to_RDR_SetParameters   = 0x61,
164   PC_to_RDR_IccPowerOn      = 0x62,
165   PC_to_RDR_IccPowerOff     = 0x63,
166   PC_to_RDR_GetSlotStatus   = 0x65,
167   PC_to_RDR_Secure          = 0x69,
168   PC_to_RDR_T0APDU          = 0x6a,
169   PC_to_RDR_Escape          = 0x6b,
170   PC_to_RDR_GetParameters   = 0x6c,
171   PC_to_RDR_ResetParameters = 0x6d,
172   PC_to_RDR_IccClock        = 0x6e,
173   PC_to_RDR_XfrBlock        = 0x6f,
174   PC_to_RDR_Mechanical      = 0x71,
175   PC_to_RDR_Abort           = 0x72,
176   PC_to_RDR_SetDataRate     = 0x73,
177
178   RDR_to_PC_DataBlock       = 0x80,
179   RDR_to_PC_SlotStatus      = 0x81,
180   RDR_to_PC_Parameters      = 0x82,
181   RDR_to_PC_Escape          = 0x83,
182   RDR_to_PC_DataRate        = 0x84
183 };
184
185
186 /* We need to know the vendor to do some hacks. */
187 enum {
188   VENDOR_SCM = 0x04e6
189 };
190
191
192 /* Store information on the driver's state.  A pointer to such a
193    structure is used as handle for most functions. */
194 struct ccid_driver_s 
195 {
196   usb_dev_handle *idev;
197   char *rid;
198   unsigned short id_vendor;
199   unsigned short id_product;
200   unsigned short bcd_device;
201   int ifc_no;
202   int ep_bulk_out;
203   int ep_bulk_in;
204   int ep_intr;
205   int seqno;
206   unsigned char t1_ns;
207   unsigned char t1_nr;
208   int nonnull_nad;
209   int auto_ifsd;
210   int max_ifsd;
211   int ifsd;
212   int powered_off;
213   int has_pinpad;
214   int apdu_level;     /* Reader supports short APDU level exchange.  */
215 };
216
217
218 static int initialized_usb; /* Tracks whether USB has been initialized. */
219 static int debug_level;     /* Flag to control the debug output.  */
220
221
222 static unsigned int compute_edc (const unsigned char *data, size_t datalen,
223                                  int use_crc);
224 static int bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen);
225 static int bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
226                     size_t *nread, int expected_type, int seqno, int timeout);
227
228 /* Convert a little endian stored 4 byte value into an unsigned
229    integer. */
230 static unsigned int 
231 convert_le_u32 (const unsigned char *buf)
232 {
233   return buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24); 
234 }
235
236 static void
237 set_msg_len (unsigned char *msg, unsigned int length)
238 {
239   msg[1] = length;
240   msg[2] = length >> 8;
241   msg[3] = length >> 16;
242   msg[4] = length >> 24;
243 }
244
245
246
247
248 /* Parse a CCID descriptor, optionally print all available features
249    and test whether this reader is usable by this driver.  Returns 0
250    if it is usable.
251
252    Note, that this code is based on the one in lsusb.c of the
253    usb-utils package, I wrote on 2003-09-01. -wk. */
254 static int
255 parse_ccid_descriptor (ccid_driver_t handle,
256                        const unsigned char *buf, size_t buflen)
257 {
258   unsigned int i;
259   unsigned int us;
260   int have_t1 = 0, have_tpdu=0, have_auto_conf = 0;
261
262
263   handle->nonnull_nad = 0;
264   handle->auto_ifsd = 0;
265   handle->max_ifsd = 32;
266   handle->ifsd = 0;
267   handle->has_pinpad = 0;
268   handle->apdu_level = 0;
269   DEBUGOUT_3 ("idVendor: %04X  idProduct: %04X  bcdDevice: %04X\n",
270               handle->id_vendor, handle->id_product, handle->bcd_device);
271   if (buflen < 54 || buf[0] < 54)
272     {
273       DEBUGOUT ("CCID device descriptor is too short\n");
274       return -1;
275     }
276
277   DEBUGOUT   ("ChipCard Interface Descriptor:\n");
278   DEBUGOUT_1 ("  bLength             %5u\n", buf[0]);
279   DEBUGOUT_1 ("  bDescriptorType     %5u\n", buf[1]);
280   DEBUGOUT_2 ("  bcdCCID             %2x.%02x", buf[3], buf[2]);
281     if (buf[3] != 1 || buf[2] != 0) 
282       DEBUGOUT_CONT("  (Warning: Only accurate for version 1.0)");
283   DEBUGOUT_LF ();
284
285   DEBUGOUT_1 ("  nMaxSlotIndex       %5u\n", buf[4]);
286   DEBUGOUT_2 ("  bVoltageSupport     %5u  %s\n",
287               buf[5], (buf[5] == 1? "5.0V" : buf[5] == 2? "3.0V"
288                        : buf[5] == 3? "1.8V":"?"));
289
290   us = convert_le_u32 (buf+6);
291   DEBUGOUT_1 ("  dwProtocols         %5u ", us);
292   if ((us & 1))
293     DEBUGOUT_CONT (" T=0");
294   if ((us & 2))
295     {
296       DEBUGOUT_CONT (" T=1");
297       have_t1 = 1;
298     }
299   if ((us & ~3))
300     DEBUGOUT_CONT (" (Invalid values detected)");
301   DEBUGOUT_LF ();
302
303   us = convert_le_u32(buf+10);
304   DEBUGOUT_1 ("  dwDefaultClock      %5u\n", us);
305   us = convert_le_u32(buf+14);
306   DEBUGOUT_1 ("  dwMaxiumumClock     %5u\n", us);
307   DEBUGOUT_1 ("  bNumClockSupported  %5u\n", buf[18]);
308   us = convert_le_u32(buf+19);
309   DEBUGOUT_1 ("  dwDataRate        %7u bps\n", us);
310   us = convert_le_u32(buf+23);
311   DEBUGOUT_1 ("  dwMaxDataRate     %7u bps\n", us);
312   DEBUGOUT_1 ("  bNumDataRatesSupp.  %5u\n", buf[27]);
313         
314   us = convert_le_u32(buf+28);
315   DEBUGOUT_1 ("  dwMaxIFSD           %5u\n", us);
316   handle->max_ifsd = us;
317
318   us = convert_le_u32(buf+32);
319   DEBUGOUT_1 ("  dwSyncProtocols  %08X ", us);
320   if ((us&1))
321     DEBUGOUT_CONT ( " 2-wire");
322   if ((us&2))
323     DEBUGOUT_CONT ( " 3-wire");
324   if ((us&4))
325     DEBUGOUT_CONT ( " I2C");
326   DEBUGOUT_LF ();
327
328   us = convert_le_u32(buf+36);
329   DEBUGOUT_1 ("  dwMechanical     %08X ", us);
330   if ((us & 1))
331     DEBUGOUT_CONT (" accept");
332   if ((us & 2))
333     DEBUGOUT_CONT (" eject");
334   if ((us & 4))
335     DEBUGOUT_CONT (" capture");
336   if ((us & 8))
337     DEBUGOUT_CONT (" lock");
338   DEBUGOUT_LF ();
339
340   us = convert_le_u32(buf+40);
341   DEBUGOUT_1 ("  dwFeatures       %08X\n", us);
342   if ((us & 0x0002))
343     {
344       DEBUGOUT ("    Auto configuration based on ATR\n");
345       have_auto_conf = 1;
346     }
347   if ((us & 0x0004))
348     DEBUGOUT ("    Auto activation on insert\n");
349   if ((us & 0x0008))
350     DEBUGOUT ("    Auto voltage selection\n");
351   if ((us & 0x0010))
352     DEBUGOUT ("    Auto clock change\n");
353   if ((us & 0x0020))
354     DEBUGOUT ("    Auto baud rate change\n");
355   if ((us & 0x0040))
356     DEBUGOUT ("    Auto parameter negotation made by CCID\n");
357   else if ((us & 0x0080))
358     DEBUGOUT ("    Auto PPS made by CCID\n");
359   else if ((us & (0x0040 | 0x0080)))
360     DEBUGOUT ("    WARNING: conflicting negotation features\n");
361
362   if ((us & 0x0100))
363     DEBUGOUT ("    CCID can set ICC in clock stop mode\n");
364   if ((us & 0x0200))
365     {
366       DEBUGOUT ("    NAD value other than 0x00 accepted\n");
367       handle->nonnull_nad = 1;
368     }
369   if ((us & 0x0400))
370     {
371       DEBUGOUT ("    Auto IFSD exchange\n");
372       handle->auto_ifsd = 1;
373     }
374
375   if ((us & 0x00010000))
376     {
377       DEBUGOUT ("    TPDU level exchange\n");
378       have_tpdu = 1;
379     } 
380   else if ((us & 0x00020000))
381     {
382       DEBUGOUT ("    Short APDU level exchange\n");
383       handle->apdu_level = 1;
384     }
385   else if ((us & 0x00040000))
386     {
387       DEBUGOUT ("    Short and extended APDU level exchange\n");
388       handle->apdu_level = 1;
389     }
390   else if ((us & 0x00070000))
391     DEBUGOUT ("    WARNING: conflicting exchange levels\n");
392
393   us = convert_le_u32(buf+44);
394   DEBUGOUT_1 ("  dwMaxCCIDMsgLen     %5u\n", us);
395
396   DEBUGOUT (  "  bClassGetResponse    ");
397   if (buf[48] == 0xff)
398     DEBUGOUT_CONT ("echo\n");
399   else
400     DEBUGOUT_CONT_1 ("  %02X\n", buf[48]);
401
402   DEBUGOUT (  "  bClassEnvelope       ");
403   if (buf[49] == 0xff)
404     DEBUGOUT_CONT ("echo\n");
405   else
406     DEBUGOUT_CONT_1 ("  %02X\n", buf[48]);
407
408   DEBUGOUT (  "  wlcdLayout           ");
409   if (!buf[50] && !buf[51])
410     DEBUGOUT_CONT ("none\n");
411   else
412     DEBUGOUT_CONT_2 ("%u cols %u lines\n", buf[50], buf[51]);
413         
414   DEBUGOUT_1 ("  bPINSupport         %5u ", buf[52]);
415   if ((buf[52] & 1))
416     {
417       DEBUGOUT_CONT ( " verification");
418       handle->has_pinpad |= 1;
419     }
420   if ((buf[52] & 2))
421     {
422       DEBUGOUT_CONT ( " modification");
423       handle->has_pinpad |= 2;
424     }
425   DEBUGOUT_LF ();
426         
427   DEBUGOUT_1 ("  bMaxCCIDBusySlots   %5u\n", buf[53]);
428
429   if (buf[0] > 54) {
430     DEBUGOUT ("  junk             ");
431     for (i=54; i < buf[0]-54; i++)
432       DEBUGOUT_CONT_1 (" %02X", buf[i]);
433     DEBUGOUT_LF ();
434   }
435
436   if (!have_t1 || !(have_tpdu  || handle->apdu_level) || !have_auto_conf)
437     {
438       DEBUGOUT ("this drivers requires that the reader supports T=1, "
439                 "TPDU or APDU level exchange and auto configuration - "
440                 "this is not available\n");
441       return -1;
442     }
443
444
445   /* SCM drivers get stuck in their internal USB stack if they try to
446      send a frame of n*wMaxPacketSize back to us.  Given that
447      wMaxPacketSize is 64 for these readers we set the IFSD to a value
448      lower than that:
449         64 - 10 CCID header -  4 T1frame - 2 reserved = 48
450      Product Ids:
451          0xe001 - SCR 331 
452          0x5111 - SCR 331-DI 
453          0x5115 - SCR 335 
454          0xe003 - SPR 532 
455   */
456   if (handle->id_vendor == VENDOR_SCM
457       && handle->max_ifsd > 48      
458       && (  (handle->id_product == 0xe001 && handle->bcd_device < 0x0516)
459           ||(handle->id_product == 0x5111 && handle->bcd_device < 0x0620)
460           ||(handle->id_product == 0x5115 && handle->bcd_device < 0x0519)
461           ||(handle->id_product == 0xe003 && handle->bcd_device < 0x0504)
462           ))
463     {
464       DEBUGOUT ("enabling workaround for buggy SCM readers\n");
465       handle->max_ifsd = 48;
466     }
467
468
469   return 0;
470 }
471
472
473 static char *
474 get_escaped_usb_string (usb_dev_handle *idev, int idx,
475                         const char *prefix, const char *suffix)
476 {
477   int rc;
478   unsigned char buf[280];
479   unsigned char *s;
480   unsigned int langid;
481   size_t i, n, len;
482   char *result;
483
484   if (!idx)
485     return NULL;
486
487   /* Fixme: The next line is for the current Valgrid without support
488      for USB IOCTLs. */
489   memset (buf, 0, sizeof buf);
490
491   /* First get the list of supported languages and use the first one.
492      If we do don't find it we try to use English.  Note that this is
493      all in a 2 bute Unicode encoding using little endian. */
494   rc = usb_control_msg (idev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
495                         (USB_DT_STRING << 8), 0, 
496                         buf, sizeof buf, 1000 /* ms timeout */);
497   if (rc < 4)
498     langid = 0x0409; /* English.  */
499   else
500     langid = (buf[3] << 8) | buf[2];
501
502   rc = usb_control_msg (idev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
503                         (USB_DT_STRING << 8) + idx, langid,
504                         buf, sizeof buf, 1000 /* ms timeout */);
505   if (rc < 2 || buf[1] != USB_DT_STRING)
506     return NULL; /* Error or not a string. */
507   len = buf[0];
508   if (len > rc)
509     return NULL; /* Larger than our buffer. */
510
511   for (s=buf+2, i=2, n=0; i+1 < len; i += 2, s += 2)
512     {
513       if (s[1])
514         n++; /* High byte set. */
515       else if (*s <= 0x20 || *s >= 0x7f || *s == '%' || *s == ':')
516         n += 3 ;
517       else 
518         n++;
519     }
520
521   result = malloc (strlen (prefix) + n + strlen (suffix) + 1);
522   if (!result)
523     return NULL;
524
525   strcpy (result, prefix);
526   n = strlen (prefix);
527   for (s=buf+2, i=2; i+1 < len; i += 2, s += 2)
528     {
529       if (s[1])
530         result[n++] = '\xff'; /* High byte set. */
531       else if (*s <= 0x20 || *s >= 0x7f || *s == '%' || *s == ':')
532         {
533           sprintf (result+n, "%%%02X", *s);
534           n += 3;
535         }
536       else 
537         result[n++] = *s;
538     }
539   strcpy (result+n, suffix);
540
541   return result;
542 }
543
544 /* This function creates an reader id to be used to find the same
545    physical reader after a reset.  It returns an allocated and possibly
546    percent escaped string or NULL if not enough memory is available. */
547 static char *
548 make_reader_id (usb_dev_handle *idev,
549                 unsigned int vendor, unsigned int product,
550                 unsigned char serialno_index)
551 {
552   char *rid;
553   char prefix[20];
554
555   sprintf (prefix, "%04X:%04X:", (vendor & 0xfff), (product & 0xffff));
556   rid = get_escaped_usb_string (idev, serialno_index, prefix, ":0");
557   if (!rid)
558     {
559       rid = malloc (strlen (prefix) + 3 + 1);
560       if (!rid)
561         return NULL;
562       strcpy (rid, prefix);
563       strcat (rid, "X:0");
564     }
565   return rid;
566 }
567
568
569 /* Helper to find the endpoint from an interface descriptor.  */
570 static int
571 find_endpoint (struct usb_interface_descriptor *ifcdesc, int mode)
572 {
573   int no;
574   int want_bulk_in = 0;
575
576   if (mode == 1)
577     want_bulk_in = 0x80;
578   for (no=0; no < ifcdesc->bNumEndpoints; no++)
579     {
580       struct usb_endpoint_descriptor *ep = ifcdesc->endpoint + no;
581       if (ep->bDescriptorType != USB_DT_ENDPOINT)
582         ;
583       else if (mode == 2
584           && ((ep->bmAttributes & USB_ENDPOINT_TYPE_MASK)
585               == USB_ENDPOINT_TYPE_INTERRUPT)
586           && (ep->bEndpointAddress & 0x80))
587         return (ep->bEndpointAddress & 0x0f);
588       else if (((ep->bmAttributes & USB_ENDPOINT_TYPE_MASK)
589                 == USB_ENDPOINT_TYPE_BULK)
590                && (ep->bEndpointAddress & 0x80) == want_bulk_in)
591         return (ep->bEndpointAddress & 0x0f);
592     }
593   /* Should never happen.  */
594   return mode == 2? 0x83 : mode == 1? 0x82 :1;
595 }
596
597
598
599 /* Combination function to either scan all CCID devices or to find and
600    open one specific device. 
601
602    With READERNO = -1 and READERID is NULL, scan mode is used and
603    R_RID should be the address where to store the list of reader_ids
604    we found.  If on return this list is empty, no CCID device has been
605    found; otherwise it points to an allocated linked list of reader
606    IDs.  Note that in this mode the function always returns NULL.
607
608    With READERNO >= 0 or READERID is not NULL find mode is used.  This
609    uses the same algorithm as the scan mode but stops and returns at
610    the entry number READERNO and return the handle for the the opened
611    USB device. If R_ID is not NULL it will receive the reader ID of
612    that device.  If R_DEV is not NULL it will the device pointer of
613    that device.  If IFCDESC_EXTRA is NOT NULL it will receive a
614    malloced copy of the interfaces "extra: data filed;
615    IFCDESC_EXTRA_LEN receive the lengtyh of this field.  If there is
616    no reader with number READERNO or that reader is not usable by our
617    implementation NULL will be returned.  The caller must close a
618    returned USB device handle and free (if not passed as NULL) the
619    returned reader ID info as well as the IFCDESC_EXTRA.  On error
620    NULL will get stored at R_RID, R_DEV, IFCDESC_EXTRA and
621    IFCDESC_EXTRA_LEN.  With READERID being -1 the function stops if
622    the READERID was found.
623
624    Note that the first entry of the returned reader ID list in scan mode
625    corresponds with a READERNO of 0 in find mode.
626 */
627 static usb_dev_handle *
628 scan_or_find_devices (int readerno, const char *readerid,
629                       char **r_rid,
630                       struct usb_device **r_dev,
631                       unsigned char **ifcdesc_extra,
632                       size_t *ifcdesc_extra_len,
633                       int *interface_number,
634                       int *ep_bulk_out, int *ep_bulk_in, int *ep_intr)
635 {
636   char *rid_list = NULL;
637   int count = 0;
638   struct usb_bus *busses, *bus;
639   struct usb_device *dev = NULL;
640   usb_dev_handle *idev = NULL;
641   int scan_mode = (readerno == -1 && !readerid);
642
643    /* Set return values to a default. */
644   if (r_rid)
645     *r_rid = NULL;
646   if (r_dev)
647     *r_dev = NULL; 
648   if (ifcdesc_extra)
649     *ifcdesc_extra = NULL;
650   if (ifcdesc_extra_len)
651     *ifcdesc_extra_len = 0;
652   if (interface_number)
653     *interface_number = 0;
654
655   /* See whether we want scan or find mode. */
656   if (scan_mode) 
657     {
658       assert (r_rid);
659     }
660
661   usb_find_busses();
662   usb_find_devices();
663
664 #ifdef HAVE_USB_GET_BUSSES
665   busses = usb_get_busses();
666 #else
667   busses = usb_busses;
668 #endif
669
670   for (bus = busses; bus; bus = bus->next) 
671     {
672       for (dev = bus->devices; dev; dev = dev->next)
673         {
674           int cfg_no;
675           
676           for (cfg_no=0; cfg_no < dev->descriptor.bNumConfigurations; cfg_no++)
677             {
678               struct usb_config_descriptor *config = dev->config + cfg_no;
679               int ifc_no;
680
681               if(!config)
682                 continue;
683
684               for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
685                 {
686                   struct usb_interface *interface
687                     = config->interface + ifc_no;
688                   int set_no;
689                   
690                   if (!interface)
691                     continue;
692                   
693                   for (set_no=0; set_no < interface->num_altsetting; set_no++)
694                     {
695                       struct usb_interface_descriptor *ifcdesc
696                         = interface->altsetting + set_no;
697                       char *rid;
698                       
699                       /* The second condition is for some SCM Micro
700                          SPR 532 which does not know about the
701                          assigned CCID class. Instead of trying to
702                          interpret the strings we simply look at the
703                          product ID. */
704                       if (ifcdesc && ifcdesc->extra
705                           && (   (ifcdesc->bInterfaceClass == 11
706                                   && ifcdesc->bInterfaceSubClass == 0
707                                   && ifcdesc->bInterfaceProtocol == 0)
708                               || (ifcdesc->bInterfaceClass == 255
709                                   && dev->descriptor.idVendor == 0x04e6
710                                   && dev->descriptor.idProduct == 0xe003)))
711                         {
712                           idev = usb_open (dev);
713                           if (!idev)
714                             {
715                               DEBUGOUT_1 ("usb_open failed: %s\n",
716                                           strerror (errno));
717                               continue;
718                             }
719                               
720                           rid = make_reader_id (idev,
721                                                 dev->descriptor.idVendor,
722                                                 dev->descriptor.idProduct,
723                                                 dev->descriptor.iSerialNumber);
724                           if (rid)
725                             {
726                               if (scan_mode)
727                                 {
728                                   char *p;
729
730                                   /* We are collecting infos about all
731                                      available CCID readers.  Store
732                                      them and continue. */
733                                   DEBUGOUT_2 ("found CCID reader %d "
734                                               "(ID=%s)\n",
735                                               count, rid );
736                                   if ((p = malloc ((rid_list?
737                                                     strlen (rid_list):0)
738                                                    + 1 + strlen (rid)
739                                                    + 1)))
740                                     {
741                                       *p = 0;
742                                       if (rid_list)
743                                         {
744                                           strcat (p, rid_list);
745                                           free (rid_list);
746                                         }
747                                       strcat (p, rid);
748                                       strcat (p, "\n");
749                                       rid_list = p;
750                                     }
751                                   else /* Out of memory. */
752                                     free (rid);
753                                   rid = NULL;
754                                   count++;
755                                 }
756                               else if (!readerno
757                                        || (readerno < 0
758                                            && readerid
759                                            && !strcmp (readerid, rid)))
760                                 {
761                                   /* We found the requested reader. */
762                                   if (ifcdesc_extra && ifcdesc_extra_len)
763                                     {
764                                       *ifcdesc_extra = malloc (ifcdesc
765                                                                ->extralen);
766                                       if (!*ifcdesc_extra)
767                                         {
768                                           usb_close (idev);
769                                           free (rid);
770                                           return NULL; /* Out of core. */
771                                         }
772                                       memcpy (*ifcdesc_extra, ifcdesc->extra,
773                                               ifcdesc->extralen);
774                                       *ifcdesc_extra_len = ifcdesc->extralen;
775                                     }
776                                   if (interface_number)
777                                     *interface_number = (ifcdesc->
778                                                          bInterfaceNumber);
779                                   if (ep_bulk_out)
780                                     *ep_bulk_out = find_endpoint (ifcdesc, 0);
781                                   if (ep_bulk_in)
782                                     *ep_bulk_in = find_endpoint (ifcdesc, 1);
783                                   if (ep_intr)
784                                     *ep_intr = find_endpoint (ifcdesc, 2);
785
786
787                                   if (r_dev)
788                                     *r_dev = dev;
789                                   if (r_rid)
790                                     {
791                                       *r_rid = rid;
792                                       rid = NULL;
793                                     }
794                                   else
795                                     free (rid);
796                                   return idev; /* READY. */
797                                 }
798                               else
799                                 {
800                                   /* This is not yet the reader we
801                                      want.  fixme: We could avoid the
802                                      extra usb_open in this case. */
803                                   if (readerno >= 0)
804                                     readerno--;
805                                 }
806                               free (rid);
807                             }
808                           
809                           usb_close (idev);
810                           idev = NULL;
811                           goto next_device;
812                         }
813                     }
814                 }
815             }
816         next_device:
817           ;
818         }
819     }
820
821   if (scan_mode)
822     *r_rid = rid_list;
823
824   return NULL;
825 }
826
827
828 /* Set the level of debugging to to usea dn return the old level.  -1
829    just returns the old level.  A level of 0 disables debugging, 1
830    enables debugging, other values are not yet defined. */
831 int
832 ccid_set_debug_level (int level)
833 {
834   int old = debug_level;
835   if (level != -1)
836     debug_level = level;
837   return old;
838 }
839
840
841 char *
842 ccid_get_reader_list (void)
843 {
844   char *reader_list;
845
846   if (!initialized_usb)
847     {
848       usb_init ();
849       initialized_usb = 1;
850     }
851
852   scan_or_find_devices (-1, NULL, &reader_list, NULL, NULL, NULL, NULL,
853                         NULL, NULL, NULL);
854   return reader_list;
855 }
856
857
858 /* Open the reader with the internal number READERNO and return a 
859    pointer to be used as handle in HANDLE.  Returns 0 on success. */
860 int 
861 ccid_open_reader (ccid_driver_t *handle, const char *readerid)
862 {
863   int rc = 0;
864   struct usb_device *dev = NULL;
865   usb_dev_handle *idev = NULL;
866   char *rid = NULL;
867   unsigned char *ifcdesc_extra = NULL;
868   size_t ifcdesc_extra_len;
869   int readerno;
870   int ifc_no, ep_bulk_out, ep_bulk_in, ep_intr;
871
872   *handle = NULL;
873
874   if (!initialized_usb)
875     {
876       usb_init ();
877       initialized_usb = 1;
878     }
879
880   /* See whether we want to use the reader ID string or a reader
881      number. A readerno of -1 indicates that the reader ID string is
882      to be used. */
883   if (readerid && strchr (readerid, ':'))
884     readerno = -1; /* We want to use the readerid.  */
885   else if (readerid)
886     {
887       readerno = atoi (readerid);
888       if (readerno < 0)
889         {
890           DEBUGOUT ("no CCID readers found\n");
891           rc = CCID_DRIVER_ERR_NO_READER;
892           goto leave;
893         }
894     }
895   else
896     readerno = 0;  /* Default. */
897
898   idev = scan_or_find_devices (readerno, readerid, &rid, &dev,
899                                &ifcdesc_extra, &ifcdesc_extra_len,
900                                &ifc_no, &ep_bulk_out, &ep_bulk_in, &ep_intr);
901   if (!idev)
902     {
903       if (readerno == -1)
904         DEBUGOUT_1 ("no CCID reader with ID %s\n", readerid );
905       else
906         DEBUGOUT_1 ("no CCID reader with number %d\n", readerno );
907       rc = CCID_DRIVER_ERR_NO_READER;
908       goto leave;
909     }
910
911   /* Okay, this is a CCID reader. */
912   *handle = calloc (1, sizeof **handle);
913   if (!*handle)
914     {
915       DEBUGOUT ("out of memory\n");
916       rc = CCID_DRIVER_ERR_OUT_OF_CORE;
917       goto leave;
918     }
919   (*handle)->idev = idev;
920   (*handle)->rid = rid;
921   (*handle)->id_vendor = dev->descriptor.idVendor;
922   (*handle)->id_product = dev->descriptor.idProduct;
923   (*handle)->bcd_device = dev->descriptor.bcdDevice;
924   (*handle)->ifc_no = ifc_no;
925   (*handle)->ep_bulk_out = ep_bulk_out;
926   (*handle)->ep_bulk_in = ep_bulk_in;
927   (*handle)->ep_intr = ep_intr;
928
929   DEBUGOUT_2 ("using CCID reader %d (ID=%s)\n",  readerno, rid );
930
931
932   if (parse_ccid_descriptor (*handle, ifcdesc_extra, ifcdesc_extra_len))
933     {
934       DEBUGOUT ("device not supported\n");
935       rc = CCID_DRIVER_ERR_NO_READER;
936       goto leave;
937     }
938   
939   rc = usb_claim_interface (idev, ifc_no);
940   if (rc)
941     {
942       DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
943       rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
944       goto leave;
945     }
946   
947  leave:
948   free (ifcdesc_extra);
949   if (rc)
950     {
951       free (rid);
952       if (idev)
953         usb_close (idev);
954       free (*handle);
955       *handle = NULL;
956     }
957
958   return rc;
959 }
960
961
962 static void
963 do_close_reader (ccid_driver_t handle)
964 {
965   int rc;
966   unsigned char msg[100];
967   size_t msglen;
968   unsigned char seqno;
969   
970   if (!handle->powered_off)
971     {
972       msg[0] = PC_to_RDR_IccPowerOff;
973       msg[5] = 0; /* slot */
974       msg[6] = seqno = handle->seqno++;
975       msg[7] = 0; /* RFU */
976       msg[8] = 0; /* RFU */
977       msg[9] = 0; /* RFU */
978       set_msg_len (msg, 0);
979       msglen = 10;
980       
981       rc = bulk_out (handle, msg, msglen);
982       if (!rc)
983         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
984                  seqno, 2000);
985       handle->powered_off = 1;
986     }
987   if (handle->idev)
988     {
989       usb_reset (handle->idev);
990       usb_release_interface (handle->idev, handle->ifc_no);
991       usb_close (handle->idev);
992       handle->idev = NULL;
993     }
994 }
995
996
997 /* Reset a reader on HANDLE.  This is useful in case a reader has been
998    plugged of and inserted at a different port.  By resetting the
999    handle, the same reader will be get used.  Note, that on error the
1000    handle won't get released. 
1001
1002    This does not return an ATR, so ccid_get_atr should be called right
1003    after this one.
1004 */
1005 int 
1006 ccid_shutdown_reader (ccid_driver_t handle)
1007 {
1008   int rc = 0;
1009   struct usb_device *dev = NULL;
1010   usb_dev_handle *idev = NULL;
1011   unsigned char *ifcdesc_extra = NULL;
1012   size_t ifcdesc_extra_len;
1013   int ifc_no, ep_bulk_out, ep_bulk_in, ep_intr;
1014
1015   if (!handle || !handle->rid)
1016     return CCID_DRIVER_ERR_INV_VALUE;
1017
1018   do_close_reader (handle);
1019
1020   idev = scan_or_find_devices (-1, handle->rid, NULL, &dev,
1021                                &ifcdesc_extra, &ifcdesc_extra_len,
1022                                &ifc_no, &ep_bulk_out, &ep_bulk_in, &ep_intr);
1023   if (!idev)
1024     {
1025       DEBUGOUT_1 ("no CCID reader with ID %s\n", handle->rid);
1026       return CCID_DRIVER_ERR_NO_READER;
1027     }
1028
1029
1030   handle->idev = idev;
1031   handle->ifc_no = ifc_no;
1032   handle->ep_bulk_out = ep_bulk_out;
1033   handle->ep_bulk_in = ep_bulk_in;
1034   handle->ep_intr = ep_intr;
1035
1036   if (parse_ccid_descriptor (handle, ifcdesc_extra, ifcdesc_extra_len))
1037     {
1038       DEBUGOUT ("device not supported\n");
1039       rc = CCID_DRIVER_ERR_NO_READER;
1040       goto leave;
1041     }
1042   
1043   rc = usb_claim_interface (idev, ifc_no);
1044   if (rc)
1045     {
1046       DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
1047       rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
1048       goto leave;
1049     }
1050   
1051  leave:
1052   free (ifcdesc_extra);
1053   if (rc)
1054     {
1055       usb_close (handle->idev);
1056       handle->idev = NULL;
1057     }
1058
1059   return rc;
1060
1061 }
1062
1063
1064 /* Close the reader HANDLE. */
1065 int 
1066 ccid_close_reader (ccid_driver_t handle)
1067 {
1068   if (!handle || !handle->idev)
1069     return 0;
1070
1071   do_close_reader (handle);
1072   free (handle->rid);
1073   free (handle);
1074   return 0;
1075 }
1076
1077
1078 /* Return False if a card is present and powered. */
1079 int
1080 ccid_check_card_presence (ccid_driver_t handle)
1081 {
1082
1083   return -1;
1084 }
1085
1086
1087 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
1088    Returns 0 on success. */
1089 static int
1090 bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen)
1091 {
1092   int rc;
1093
1094   rc = usb_bulk_write (handle->idev, 
1095                        handle->ep_bulk_out,
1096                        msg, msglen,
1097                        1000 /* ms timeout */);
1098   if (rc == msglen)
1099     return 0;
1100
1101   if (rc == -1)
1102     DEBUGOUT_1 ("usb_bulk_write error: %s\n", strerror (errno));
1103   else
1104     DEBUGOUT_1 ("usb_bulk_write failed: %d\n", rc);
1105   return CCID_DRIVER_ERR_CARD_IO_ERROR;
1106 }
1107
1108
1109 /* Read a maximum of LENGTH bytes from the bulk in endpoint into
1110    BUFFER and return the actual read number if bytes in NREAD. SEQNO
1111    is the sequence number used to send the request and EXPECTED_TYPE
1112    the type of message we expect. Does checks on the ccid
1113    header. TIMEOUT is the timeout value in ms. Returns 0 on success. */
1114 static int
1115 bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
1116          size_t *nread, int expected_type, int seqno, int timeout)
1117 {
1118   int i, rc;
1119   size_t msglen;
1120
1121   /* Fixme: The next line for the current Valgrind without support
1122      for USB IOCTLs. */
1123   memset (buffer, 0, length);
1124  retry:
1125   rc = usb_bulk_read (handle->idev, 
1126                       handle->ep_bulk_in,
1127                       buffer, length,
1128                       timeout);
1129   if (rc < 0)
1130     {
1131       DEBUGOUT_1 ("usb_bulk_read error: %s\n", strerror (errno));
1132       return CCID_DRIVER_ERR_CARD_IO_ERROR;
1133     }
1134
1135   *nread = msglen = rc;
1136
1137   if (msglen < 10)
1138     {
1139       DEBUGOUT_1 ("bulk-in msg too short (%u)\n", (unsigned int)msglen);
1140       return CCID_DRIVER_ERR_INV_VALUE;
1141     }
1142   if (buffer[0] != expected_type)
1143     {
1144       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
1145       return CCID_DRIVER_ERR_INV_VALUE;
1146     }
1147   if (buffer[5] != 0)    
1148     {
1149       DEBUGOUT_1 ("unexpected bulk-in slot (%d)\n", buffer[5]);
1150       return CCID_DRIVER_ERR_INV_VALUE;
1151     }
1152   if (buffer[6] != seqno)    
1153     {
1154       DEBUGOUT_2 ("bulk-in seqno does not match (%d/%d)\n",
1155                   seqno, buffer[6]);
1156       return CCID_DRIVER_ERR_INV_VALUE;
1157     }
1158
1159   if ( !(buffer[7] & 0x03) && (buffer[7] & 0xC0) == 0x80)
1160     { 
1161       /* Card present and active, time extension requested. */
1162       DEBUGOUT_2 ("time extension requested (%02X,%02X)\n",
1163                   buffer[7], buffer[8]);
1164       goto retry;
1165     }
1166   
1167   DEBUGOUT_3 ("status: %02X  error: %02X  octet[9]: %02X\n"
1168               "               data:",  buffer[7], buffer[8], buffer[9] );
1169   for (i=10; i < msglen; i++)
1170     DEBUGOUT_CONT_1 (" %02X", buffer[i]);
1171   DEBUGOUT_LF ();
1172
1173   switch ((buffer[7] & 0x03))
1174     {
1175     case 0: /* no error */ break;
1176     case 1: return CCID_DRIVER_ERR_CARD_INACTIVE;
1177     case 2: return CCID_DRIVER_ERR_NO_CARD;
1178     case 3: /* RFU */ break;
1179     }
1180   return 0;
1181 }
1182
1183
1184 /* Note that this function won't return the error codes NO_CARD or
1185    CARD_INACTIVE */
1186 static int 
1187 send_escape_cmd (ccid_driver_t handle,
1188                  const unsigned char *data, size_t datalen)
1189 {
1190   int i, rc;
1191   unsigned char msg[100];
1192   size_t msglen;
1193   unsigned char seqno;
1194
1195   if (datalen > sizeof msg - 10)
1196     return CCID_DRIVER_ERR_INV_VALUE; /* Escape data too large.  */
1197
1198   msg[0] = PC_to_RDR_Escape;
1199   msg[5] = 0; /* slot */
1200   msg[6] = seqno = handle->seqno++;
1201   msg[7] = 0; /* RFU */
1202   msg[8] = 0; /* RFU */
1203   msg[9] = 0; /* RFU */
1204   memcpy (msg+10, data, datalen);
1205   msglen = 10 + datalen;
1206   set_msg_len (msg, datalen);
1207
1208   DEBUGOUT ("sending");
1209   for (i=0; i < msglen; i++)
1210     DEBUGOUT_CONT_1 (" %02X", msg[i]);
1211   DEBUGOUT_LF ();
1212   rc = bulk_out (handle, msg, msglen);
1213   if (rc)
1214     return rc;
1215   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Escape,
1216                 seqno, 5000);
1217
1218   return rc;
1219 }
1220
1221
1222 /* experimental */
1223 int
1224 ccid_poll (ccid_driver_t handle)
1225 {
1226   int rc;
1227   unsigned char msg[10];
1228   size_t msglen;
1229   int i, j;
1230
1231   rc = usb_bulk_read (handle->idev, 
1232                       handle->ep_intr,
1233                       msg, sizeof msg,
1234                       0 /* ms timeout */ );
1235   if (rc < 0 && errno == ETIMEDOUT)
1236     return 0;
1237
1238   if (rc < 0)
1239     {
1240       DEBUGOUT_1 ("usb_intr_read error: %s\n", strerror (errno));
1241       return CCID_DRIVER_ERR_CARD_IO_ERROR;
1242     }
1243
1244   msglen = rc;
1245   rc = 0;
1246
1247   if (msglen < 1)
1248     {
1249       DEBUGOUT ("intr-in msg too short\n");
1250       return CCID_DRIVER_ERR_INV_VALUE;
1251     }
1252
1253   if (msg[0] == RDR_to_PC_NotifySlotChange)
1254     {
1255       DEBUGOUT ("notify slot change:");
1256       for (i=1; i < msglen; i++)
1257         for (j=0; j < 4; j++)
1258           DEBUGOUT_CONT_3 (" %d:%c%c",
1259                            (i-1)*4+j, 
1260                            (msg[i] & (1<<(j*2)))? 'p':'-',
1261                            (msg[i] & (2<<(j*2)))? '*':' ');
1262       DEBUGOUT_LF ();
1263     }
1264   else if (msg[0] == RDR_to_PC_HardwareError)    
1265     {
1266       DEBUGOUT ("hardware error occured\n");
1267     }
1268   else
1269     {
1270       DEBUGOUT_1 ("unknown intr-in msg of type %02X\n", msg[0]);
1271     }
1272
1273   return 0;
1274 }
1275
1276
1277 /* Note that this fucntion won't return the error codes NO_CARD or
1278    CARD_INACTIVE */
1279 int 
1280 ccid_slot_status (ccid_driver_t handle, int *statusbits)
1281 {
1282   int rc;
1283   unsigned char msg[100];
1284   size_t msglen;
1285   unsigned char seqno;
1286   int retries = 0;
1287
1288  retry:
1289   msg[0] = PC_to_RDR_GetSlotStatus;
1290   msg[5] = 0; /* slot */
1291   msg[6] = seqno = handle->seqno++;
1292   msg[7] = 0; /* RFU */
1293   msg[8] = 0; /* RFU */
1294   msg[9] = 0; /* RFU */
1295   set_msg_len (msg, 0);
1296
1297   rc = bulk_out (handle, msg, 10);
1298   if (rc)
1299     return rc;
1300   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
1301                 seqno, retries? 1000 : 200);
1302   if (rc == CCID_DRIVER_ERR_CARD_IO_ERROR && retries < 3)
1303     {
1304       if (!retries)
1305         {
1306           DEBUGOUT ("USB: CALLING USB_CLEAR_HALT\n");
1307           usb_clear_halt (handle->idev, handle->ep_bulk_in);
1308           usb_clear_halt (handle->idev, handle->ep_bulk_out);
1309         }
1310       else
1311           DEBUGOUT ("USB: RETRYING bulk_in AGAIN\n");
1312       retries++;
1313       goto retry;
1314     }
1315   if (rc && rc != CCID_DRIVER_ERR_NO_CARD
1316       && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
1317     return rc;
1318   *statusbits = (msg[7] & 3);
1319
1320   return 0;
1321 }
1322
1323
1324 int 
1325 ccid_get_atr (ccid_driver_t handle,
1326               unsigned char *atr, size_t maxatrlen, size_t *atrlen)
1327 {
1328   int rc;
1329   int statusbits;
1330   unsigned char msg[100];
1331   unsigned char *tpdu;
1332   size_t msglen, tpdulen;
1333   unsigned char seqno;
1334   int use_crc = 0;
1335   unsigned int edc;
1336   int i;
1337
1338   /* First check whether a card is available.  */
1339   rc = ccid_slot_status (handle, &statusbits);
1340   if (rc)
1341     return rc;
1342   if (statusbits == 2)
1343     return CCID_DRIVER_ERR_NO_CARD;
1344
1345   /* For an inactive and also for an active card, issue the PowerOn
1346      command to get the ATR.  */
1347   msg[0] = PC_to_RDR_IccPowerOn;
1348   msg[5] = 0; /* slot */
1349   msg[6] = seqno = handle->seqno++;
1350   msg[7] = 0; /* power select (0=auto, 1=5V, 2=3V, 3=1.8V) */
1351   msg[8] = 0; /* RFU */
1352   msg[9] = 0; /* RFU */
1353   set_msg_len (msg, 0);
1354   msglen = 10;
1355
1356   rc = bulk_out (handle, msg, msglen);
1357   if (rc)
1358     return rc;
1359   rc = bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_DataBlock,
1360                 seqno, 5000);
1361   if (rc)
1362     return rc;
1363
1364   handle->powered_off = 0;
1365   
1366   if (atr)
1367     {
1368       size_t n = msglen - 10;
1369
1370       if (n > maxatrlen)
1371         n = maxatrlen;
1372       memcpy (atr, msg+10, n);
1373       *atrlen = n;
1374     }
1375
1376   /* Setup parameters to select T=1. */
1377   msg[0] = PC_to_RDR_SetParameters;
1378   msg[5] = 0; /* slot */
1379   msg[6] = seqno = handle->seqno++;
1380   msg[7] = 1; /* Select T=1. */
1381   msg[8] = 0; /* RFU */
1382   msg[9] = 0; /* RFU */
1383
1384   /* FIXME: Get those values from the ATR. */
1385   msg[10]= 0x01; /* Fi/Di */
1386   msg[11]= 0x10; /* LRC, direct convention. */
1387   msg[12]= 0;    /* Extra guardtime. */
1388   msg[13]= 0x41; /* BWI/CWI */
1389   msg[14]= 0;    /* No clock stoppping. */
1390   msg[15]= 254;  /* IFSC */
1391   msg[16]= 0;    /* Does not support non default NAD values. */
1392   set_msg_len (msg, 7);
1393   msglen = 10 + 7;
1394
1395   DEBUGOUT ("sending");
1396   for (i=0; i < msglen; i++)
1397     DEBUGOUT_CONT_1 (" %02X", msg[i]);
1398   DEBUGOUT_LF ();
1399
1400   rc = bulk_out (handle, msg, msglen);
1401   if (rc)
1402     return rc;
1403   /* Note that we ignore the error code on purpose. */
1404   bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_Parameters,
1405            seqno, 5000);
1406
1407   handle->t1_ns = 0;
1408   handle->t1_nr = 0;
1409
1410   /* Send an S-Block with our maximun IFSD to the CCID.  */
1411   if (!handle->auto_ifsd)
1412     {
1413       tpdu = msg+10;
1414       /* NAD: DAD=1, SAD=0 */
1415       tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1416       tpdu[1] = (0xc0 | 0 | 1); /* S-block request: change IFSD */
1417       tpdu[2] = 1;
1418       tpdu[3] = handle->max_ifsd? handle->max_ifsd : 32; 
1419       tpdulen = 4;
1420       edc = compute_edc (tpdu, tpdulen, use_crc);
1421       if (use_crc)
1422         tpdu[tpdulen++] = (edc >> 8);
1423       tpdu[tpdulen++] = edc;
1424
1425       msg[0] = PC_to_RDR_XfrBlock;
1426       msg[5] = 0; /* slot */
1427       msg[6] = seqno = handle->seqno++;
1428       msg[7] = 0; 
1429       msg[8] = 0; /* RFU */
1430       msg[9] = 0; /* RFU */
1431       set_msg_len (msg, tpdulen);
1432       msglen = 10 + tpdulen;
1433
1434       DEBUGOUT ("sending");
1435       for (i=0; i < msglen; i++)
1436         DEBUGOUT_CONT_1 (" %02X", msg[i]);
1437       DEBUGOUT_LF ();
1438
1439 #ifdef DEBUG_T1      
1440       fprintf (stderr, "T1: put %c-block seq=%d\n",
1441                ((msg[11] & 0xc0) == 0x80)? 'R' :
1442                (msg[11] & 0x80)? 'S' : 'I',
1443                ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)));
1444 #endif  
1445
1446       rc = bulk_out (handle, msg, msglen);
1447       if (rc)
1448         return rc;
1449
1450
1451       rc = bulk_in (handle, msg, sizeof msg, &msglen,
1452                     RDR_to_PC_DataBlock, seqno, 5000);
1453       if (rc)
1454         return rc;
1455       
1456       tpdu = msg + 10;
1457       tpdulen = msglen - 10;
1458       
1459       if (tpdulen < 4) 
1460         return CCID_DRIVER_ERR_ABORTED; 
1461
1462 #ifdef DEBUG_T1
1463       fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
1464                ((msg[11] & 0xc0) == 0x80)? 'R' :
1465                (msg[11] & 0x80)? 'S' : 'I',
1466                ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
1467                ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
1468                );
1469 #endif
1470       if ((tpdu[1] & 0xe0) != 0xe0 || tpdu[2] != 1)
1471         {
1472           DEBUGOUT ("invalid response for S-block (Change-IFSD)\n");
1473           return -1;
1474         }
1475       DEBUGOUT_1 ("IFSD has been set to %d\n", tpdu[3]);
1476     }
1477
1478   return 0;
1479 }
1480
1481
1482 \f
1483
1484 static unsigned int 
1485 compute_edc (const unsigned char *data, size_t datalen, int use_crc)
1486 {
1487   if (use_crc)
1488     {
1489       return 0x42; /* Not yet implemented. */
1490     }
1491   else
1492     {
1493       unsigned char crc = 0;
1494       
1495       for (; datalen; datalen--)
1496         crc ^= *data++;
1497       return crc;
1498     }
1499 }
1500
1501
1502 /* Helper for ccid_transceive used for APDU level exchanges.  */
1503 static int
1504 ccid_transceive_apdu_level (ccid_driver_t handle,
1505                             const unsigned char *apdu_buf, size_t apdu_buflen,
1506                             unsigned char *resp, size_t maxresplen,
1507                             size_t *nresp)
1508 {
1509   int rc;
1510   unsigned char send_buffer[10+259], recv_buffer[10+259];
1511   const unsigned char *apdu;
1512   size_t apdulen;
1513   unsigned char *msg;
1514   size_t msglen;
1515   unsigned char seqno;
1516   int i;
1517
1518   msg = send_buffer;
1519
1520   apdu = apdu_buf;
1521   apdulen = apdu_buflen;
1522   assert (apdulen);
1523
1524   if (apdulen > 254)
1525     return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
1526
1527   msg[0] = PC_to_RDR_XfrBlock;
1528   msg[5] = 0; /* slot */
1529   msg[6] = seqno = handle->seqno++;
1530   msg[7] = 4; /* bBWI */
1531   msg[8] = 0; /* RFU */
1532   msg[9] = 0; /* RFU */
1533   memcpy (msg+10, apdu, apdulen);
1534   set_msg_len (msg, apdulen);
1535   msglen = 10 + apdulen;
1536
1537   DEBUGOUT ("sending");
1538   for (i=0; i < msglen; i++)
1539     DEBUGOUT_CONT_1 (" %02X", msg[i]);
1540   DEBUGOUT_LF ();
1541   
1542   rc = bulk_out (handle, msg, msglen);
1543   if (rc)
1544     return rc;
1545
1546   msg = recv_buffer;
1547   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
1548                 RDR_to_PC_DataBlock, seqno, 5000);
1549   if (rc)
1550     return rc;
1551       
1552   apdu = msg + 10;
1553   apdulen = msglen - 10;
1554       
1555   if (resp)
1556     {
1557       if (apdulen > maxresplen)
1558         {
1559           DEBUGOUT_2 ("provided buffer too short for received data "
1560                       "(%u/%u)\n",
1561                       (unsigned int)apdulen, (unsigned int)maxresplen);
1562           return CCID_DRIVER_ERR_INV_VALUE;
1563         }
1564       
1565       memcpy (resp, apdu, apdulen); 
1566       *nresp = apdulen;
1567     }
1568           
1569   return 0;
1570 }
1571
1572
1573
1574 /*
1575   Protocol T=1 overview
1576
1577   Block Structure:
1578            Prologue Field:
1579    1 byte     Node Address (NAD) 
1580    1 byte     Protocol Control Byte (PCB)
1581    1 byte     Length (LEN) 
1582            Information Field:
1583    0-254 byte APDU or Control Information (INF)
1584            Epilogue Field:
1585    1 byte     Error Detection Code (EDC)
1586
1587   NAD:  
1588    bit 7     unused
1589    bit 4..6  Destination Node Address (DAD)
1590    bit 3     unused
1591    bit 2..0  Source Node Address (SAD)
1592
1593    If node adresses are not used, SAD and DAD should be set to 0 on
1594    the first block sent to the card.  If they are used they should
1595    have different values (0 for one is okay); that first block sets up
1596    the addresses of the nodes.
1597
1598   PCB:
1599    Information Block (I-Block):
1600       bit 7    0
1601       bit 6    Sequence number (yep, that is modulo 2)
1602       bit 5    Chaining flag 
1603       bit 4..0 reserved
1604    Received-Ready Block (R-Block):
1605       bit 7    1
1606       bit 6    0
1607       bit 5    0
1608       bit 4    Sequence number
1609       bit 3..0  0 = no error
1610                 1 = EDC or parity error
1611                 2 = other error
1612                 other values are reserved
1613    Supervisory Block (S-Block):
1614       bit 7    1
1615       bit 6    1
1616       bit 5    clear=request,set=response
1617       bit 4..0  0 = resyncronisation request
1618                 1 = information field size request
1619                 2 = abort request
1620                 3 = extension of BWT request
1621                 4 = VPP error
1622                 other values are reserved
1623
1624 */
1625
1626 int
1627 ccid_transceive (ccid_driver_t handle,
1628                  const unsigned char *apdu_buf, size_t apdu_buflen,
1629                  unsigned char *resp, size_t maxresplen, size_t *nresp)
1630 {
1631   int rc;
1632   unsigned char send_buffer[10+259], recv_buffer[10+259];
1633   const unsigned char *apdu;
1634   size_t apdulen;
1635   unsigned char *msg, *tpdu, *p;
1636   size_t msglen, tpdulen, last_tpdulen, n;
1637   unsigned char seqno;
1638   int i;
1639   unsigned int edc;
1640   int use_crc = 0;
1641   size_t dummy_nresp;
1642   int next_chunk = 1;
1643   int sending = 1;
1644   int retries = 0;
1645
1646   if (!nresp)
1647     nresp = &dummy_nresp;
1648   *nresp = 0;
1649
1650   /* Smarter readers allow to send APDUs directly; divert here. */
1651   if (handle->apdu_level)
1652     return ccid_transceive_apdu_level (handle, apdu_buf, apdu_buflen,
1653                                        resp, maxresplen, nresp);
1654
1655   /* The other readers we support require sending TPDUs.  */
1656
1657   tpdulen = 0; /* Avoid compiler warning about no initialization. */
1658   msg = send_buffer;
1659   for (;;)
1660     {
1661       if (next_chunk)
1662         {
1663           next_chunk = 0;
1664
1665           apdu = apdu_buf;
1666           apdulen = apdu_buflen;
1667           assert (apdulen);
1668
1669           /* Construct an I-Block. */
1670           if (apdulen > 254)
1671             return CCID_DRIVER_ERR_INV_VALUE; /* Invalid length. */
1672
1673           tpdu = msg+10;
1674           /* NAD: DAD=1, SAD=0 */
1675           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1676           tpdu[1] = ((handle->t1_ns & 1) << 6); /* I-block */
1677           if (apdulen > 128 /* fixme: replace by ifsc */)
1678             {
1679               apdulen = 128;
1680               apdu_buf += 128;  
1681               apdu_buflen -= 128;
1682               tpdu[1] |= (1 << 5); /* Set more bit. */
1683             }
1684           tpdu[2] = apdulen;
1685           memcpy (tpdu+3, apdu, apdulen);
1686           tpdulen = 3 + apdulen;
1687           edc = compute_edc (tpdu, tpdulen, use_crc);
1688           if (use_crc)
1689             tpdu[tpdulen++] = (edc >> 8);
1690           tpdu[tpdulen++] = edc;
1691         }
1692
1693       msg[0] = PC_to_RDR_XfrBlock;
1694       msg[5] = 0; /* slot */
1695       msg[6] = seqno = handle->seqno++;
1696       msg[7] = 4; /* bBWI */
1697       msg[8] = 0; /* RFU */
1698       msg[9] = 0; /* RFU */
1699       set_msg_len (msg, tpdulen);
1700       msglen = 10 + tpdulen;
1701       last_tpdulen = tpdulen;
1702
1703       DEBUGOUT ("sending");
1704       for (i=0; i < msglen; i++)
1705         DEBUGOUT_CONT_1 (" %02X", msg[i]);
1706       DEBUGOUT_LF ();
1707
1708 #ifdef DEBUG_T1      
1709       fprintf (stderr, "T1: put %c-block seq=%d\n",
1710                ((msg[11] & 0xc0) == 0x80)? 'R' :
1711                (msg[11] & 0x80)? 'S' : 'I',
1712         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)));
1713 #endif  
1714
1715       rc = bulk_out (handle, msg, msglen);
1716       if (rc)
1717         return rc;
1718
1719       msg = recv_buffer;
1720       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
1721                     RDR_to_PC_DataBlock, seqno, 5000);
1722       if (rc)
1723         return rc;
1724       
1725       tpdu = msg + 10;
1726       tpdulen = msglen - 10;
1727       
1728       if (tpdulen < 4) 
1729         {
1730           usb_clear_halt (handle->idev, handle->ep_bulk_in);
1731           return CCID_DRIVER_ERR_ABORTED; 
1732         }
1733 #ifdef DEBUG_T1
1734       fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
1735                ((msg[11] & 0xc0) == 0x80)? 'R' :
1736                (msg[11] & 0x80)? 'S' : 'I',
1737         ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
1738                ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
1739                );
1740 #endif
1741
1742       if (!(tpdu[1] & 0x80))
1743         { /* This is an I-block. */
1744           retries = 0;
1745           if (sending)
1746             { /* last block sent was successful. */
1747               handle->t1_ns ^= 1;
1748               sending = 0;
1749             }
1750
1751           if (!!(tpdu[1] & 0x40) != handle->t1_nr)
1752             { /* Reponse does not match our sequence number. */
1753               msg = send_buffer;
1754               tpdu = msg+10;
1755               /* NAD: DAD=1, SAD=0 */
1756               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1757               tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4 | 2); /* R-block */
1758               tpdu[2] = 0;
1759               tpdulen = 3;
1760               edc = compute_edc (tpdu, tpdulen, use_crc);
1761               if (use_crc)
1762                 tpdu[tpdulen++] = (edc >> 8);
1763               tpdu[tpdulen++] = edc;
1764
1765               continue;
1766             }
1767
1768           handle->t1_nr ^= 1;
1769
1770           p = tpdu + 3; /* Skip the prologue field. */
1771           n = tpdulen - 3 - 1; /* Strip the epilogue field. */
1772           /* fixme: verify the checksum. */
1773           if (resp)
1774             {
1775               if (n > maxresplen)
1776                 {
1777                   DEBUGOUT_2 ("provided buffer too short for received data "
1778                               "(%u/%u)\n",
1779                               (unsigned int)n, (unsigned int)maxresplen);
1780                   return CCID_DRIVER_ERR_INV_VALUE;
1781                 }
1782               
1783               memcpy (resp, p, n); 
1784               resp += n;
1785               *nresp += n;
1786               maxresplen -= n;
1787             }
1788           
1789           if (!(tpdu[1] & 0x20))
1790             return 0; /* No chaining requested - ready. */
1791           
1792           msg = send_buffer;
1793           tpdu = msg+10;
1794           /* NAD: DAD=1, SAD=0 */
1795           tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1796           tpdu[1] = (0x80 | (handle->t1_nr & 1) << 4); /* R-block */
1797           tpdu[2] = 0;
1798           tpdulen = 3;
1799           edc = compute_edc (tpdu, tpdulen, use_crc);
1800           if (use_crc)
1801             tpdu[tpdulen++] = (edc >> 8);
1802           tpdu[tpdulen++] = edc;
1803         }
1804       else if ((tpdu[1] & 0xc0) == 0x80)
1805         { /* This is a R-block. */
1806           if ( (tpdu[1] & 0x0f)) 
1807             { /* Error: repeat last block */
1808               if (++retries > 3)
1809                 {
1810                   DEBUGOUT ("3 failed retries\n");
1811                   return CCID_DRIVER_ERR_CARD_IO_ERROR;
1812                 }
1813               msg = send_buffer;
1814               tpdulen = last_tpdulen;
1815             }
1816           else if (sending && !!(tpdu[1] & 0x40) == handle->t1_ns)
1817             { /* Reponse does not match our sequence number. */
1818               DEBUGOUT ("R-block with wrong seqno received on more bit\n");
1819               return CCID_DRIVER_ERR_CARD_IO_ERROR;
1820             }
1821           else if (sending)
1822             { /* Send next chunk. */
1823               retries = 0;
1824               msg = send_buffer;
1825               next_chunk = 1;
1826               handle->t1_ns ^= 1;
1827             }
1828           else
1829             {
1830               DEBUGOUT ("unexpected ACK R-block received\n");
1831               return CCID_DRIVER_ERR_CARD_IO_ERROR;
1832             }
1833         }
1834       else 
1835         { /* This is a S-block. */
1836           retries = 0;
1837           DEBUGOUT_2 ("T1 S-block %s received cmd=%d\n",
1838                       (tpdu[1] & 0x20)? "response": "request",
1839                       (tpdu[1] & 0x1f));
1840           if ( !(tpdu[1] & 0x20) && (tpdu[1] & 0x1f) == 3 && tpdu[2])
1841             { /* Wait time extension request. */
1842               unsigned char bwi = tpdu[3];
1843               msg = send_buffer;
1844               tpdu = msg+10;
1845               /* NAD: DAD=1, SAD=0 */
1846               tpdu[0] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1847               tpdu[1] = (0xc0 | 0x20 | 3); /* S-block response */
1848               tpdu[2] = 1;
1849               tpdu[3] = bwi;
1850               tpdulen = 4;
1851               edc = compute_edc (tpdu, tpdulen, use_crc);
1852               if (use_crc)
1853                 tpdu[tpdulen++] = (edc >> 8);
1854               tpdu[tpdulen++] = edc;
1855               DEBUGOUT_1 ("T1 waittime extension of bwi=%d\n", bwi);
1856             }
1857           else
1858             return CCID_DRIVER_ERR_CARD_IO_ERROR;
1859         }
1860     } /* end T=1 protocol loop. */
1861
1862   return 0;
1863 }
1864
1865
1866 /* Send the CCID Secure command to the reader.  APDU_BUF should contain the APDU   template.  PIN_MODE defines now the pin gets formatted:
1867    
1868      1 := The PIN is ASCII encoded and of variable length.  The
1869           length of the PIN entered will be put into Lc by the reader.
1870           The APDU should me made up of 4 bytes without Lc.
1871
1872    PINLEN_MIN and PINLEN_MAX define the limits for the pin length. 0
1873    may be used t enable usbale defaults.  PIN_PADLEN should be 0
1874    
1875    When called with RESP and NRESP set to NULL, the function will
1876    merely check whether the reader supports the secure command for the
1877    given APDU and PIN_MODE. */
1878 int
1879 ccid_transceive_secure (ccid_driver_t handle,
1880                         const unsigned char *apdu_buf, size_t apdu_buflen,
1881                         int pin_mode, int pinlen_min, int pinlen_max,
1882                         int pin_padlen, 
1883                         unsigned char *resp, size_t maxresplen, size_t *nresp)
1884 {
1885   int rc;
1886   unsigned char send_buffer[10+259], recv_buffer[10+259];
1887   unsigned char *msg, *tpdu, *p;
1888   size_t msglen, tpdulen, n;
1889   unsigned char seqno;
1890   int i;
1891   size_t dummy_nresp;
1892   int testmode;
1893
1894   testmode = !resp && !nresp;
1895
1896   if (!nresp)
1897     nresp = &dummy_nresp;
1898   *nresp = 0;
1899
1900   if (apdu_buflen >= 4 && apdu_buf[1] == 0x20 && (handle->has_pinpad & 1))
1901     ;
1902   else if (apdu_buflen >= 4 && apdu_buf[1] == 0x24 && (handle->has_pinpad & 2))
1903     return CCID_DRIVER_ERR_NOT_SUPPORTED; /* Not yet by our code. */
1904   else
1905     return CCID_DRIVER_ERR_NOT_SUPPORTED;
1906     
1907   if (pin_mode != 1)
1908     return CCID_DRIVER_ERR_NOT_SUPPORTED;
1909
1910   if (pin_padlen != 0)
1911     return CCID_DRIVER_ERR_NOT_SUPPORTED;
1912
1913   if (!pinlen_min)
1914     pinlen_min = 1;
1915   if (!pinlen_max)
1916     pinlen_max = 25;
1917
1918   /* Note that the 25 is the maximum value the SPR532 allows.  */
1919   if (pinlen_min < 1 || pinlen_min > 25
1920       || pinlen_max < 1 || pinlen_max > 25 
1921       || pinlen_min > pinlen_max)
1922     return CCID_DRIVER_ERR_INV_VALUE;
1923
1924   /* We have only tested this with an SCM reader so better don't risk
1925      anything and do not allow the use with other readers. */
1926   if (handle->id_vendor != VENDOR_SCM)
1927     return CCID_DRIVER_ERR_NOT_SUPPORTED;
1928
1929   if (testmode)
1930     return 0; /* Success */
1931     
1932   msg = send_buffer;
1933   if (handle->id_vendor == VENDOR_SCM)
1934     {
1935       DEBUGOUT ("sending escape sequence to switch to a case 1 APDU\n");
1936       rc = send_escape_cmd (handle, "\x80\x02\x00", 3);
1937       if (rc)
1938         return rc;
1939     }
1940
1941   msg[0] = PC_to_RDR_Secure;
1942   msg[5] = 0; /* slot */
1943   msg[6] = seqno = handle->seqno++;
1944   msg[7] = 4; /* bBWI */
1945   msg[8] = 0; /* RFU */
1946   msg[9] = 0; /* RFU */
1947   msg[10] = 0; /* Perform PIN verification. */
1948   msg[11] = 0; /* Timeout in seconds. */
1949   msg[12] = 0x82; /* bmFormatString: Byte, pos=0, left, ASCII. */
1950   if (handle->id_vendor == VENDOR_SCM)
1951     {
1952       /* For the SPR532 the next 2 bytes need to be zero.  We do this
1953          for all SCM product. Kudos to to Martin Paljak for this
1954          hint.  */
1955       msg[13] = msg[14] = 0;
1956     }
1957   else
1958     {
1959       msg[13] = 0x00; /* bmPINBlockString:
1960                          0 bits of pin length to insert. 
1961                          0 bytes of PIN block size.  */
1962       msg[14] = 0x00; /* bmPINLengthFormat:
1963                          Units are bytes, position is 0. */
1964     }
1965   msg[15] = pinlen_min;   /* wPINMaxExtraDigit-Minimum.  */
1966   msg[16] = pinlen_max;   /* wPINMaxExtraDigit-Maximum.  */
1967   msg[17] = 0x02; /* bEntryValidationCondition:
1968                      Validation key pressed */
1969   if (pinlen_min && pinlen_max && pinlen_min == pinlen_max)
1970     msg[17] |= 0x01; /* Max size reached.  */
1971   msg[18] = 0xff; /* bNumberMessage: Default. */
1972   msg[19] = 0x04; /* wLangId-High. */
1973   msg[20] = 0x09; /* wLangId-Low:  English FIXME: use the first entry. */
1974   msg[21] = 0;    /* bMsgIndex. */
1975   /* bTeoProlog follows: */
1976   msg[22] = handle->nonnull_nad? ((1 << 4) | 0): 0;
1977   msg[23] = ((handle->t1_ns & 1) << 6); /* I-block */
1978   msg[24] = 4; /* apdulen.  */
1979   /* APDU follows:  */
1980   msg[25] = apdu_buf[0]; /* CLA */
1981   msg[26] = apdu_buf[1]; /* INS */
1982   msg[27] = apdu_buf[2]; /* P1 */
1983   msg[28] = apdu_buf[3]; /* P2 */
1984   msglen = 29;
1985   set_msg_len (msg, msglen - 10);
1986
1987   DEBUGOUT ("sending");
1988   for (i=0; i < msglen; i++)
1989     DEBUGOUT_CONT_1 (" %02X", msg[i]);
1990   DEBUGOUT_LF ();
1991   
1992   rc = bulk_out (handle, msg, msglen);
1993   if (rc)
1994     return rc;
1995   
1996   msg = recv_buffer;
1997   rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
1998                 RDR_to_PC_DataBlock, seqno, 5000);
1999   if (rc)
2000     return rc;
2001   
2002   tpdu = msg + 10;
2003   tpdulen = msglen - 10;
2004   
2005   if (tpdulen < 4) 
2006     {
2007       usb_clear_halt (handle->idev, handle->ep_bulk_in);
2008       return CCID_DRIVER_ERR_ABORTED; 
2009     }
2010 #ifdef DEBUG_T1
2011   fprintf (stderr, "T1: got %c-block seq=%d err=%d\n",
2012            ((msg[11] & 0xc0) == 0x80)? 'R' :
2013            (msg[11] & 0x80)? 'S' : 'I',
2014            ((msg[11] & 0x80)? !!(msg[11]& 0x10) : !!(msg[11] & 0x40)),
2015            ((msg[11] & 0xc0) == 0x80)? (msg[11] & 0x0f) : 0
2016            );
2017 #endif
2018
2019   if (!(tpdu[1] & 0x80))
2020     { /* This is an I-block. */
2021       /* Last block sent was successful. */
2022       handle->t1_ns ^= 1;
2023
2024       if (!!(tpdu[1] & 0x40) != handle->t1_nr)
2025         { /* Reponse does not match our sequence number. */
2026           DEBUGOUT ("I-block with wrong seqno received\n");
2027           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2028         }
2029
2030       handle->t1_nr ^= 1;
2031
2032       p = tpdu + 3; /* Skip the prologue field. */
2033       n = tpdulen - 3 - 1; /* Strip the epilogue field. */
2034       /* fixme: verify the checksum. */
2035       if (resp)
2036         {
2037           if (n > maxresplen)
2038             {
2039               DEBUGOUT_2 ("provided buffer too short for received data "
2040                           "(%u/%u)\n",
2041                           (unsigned int)n, (unsigned int)maxresplen);
2042               return CCID_DRIVER_ERR_INV_VALUE;
2043             }
2044               
2045           memcpy (resp, p, n); 
2046           resp += n;
2047           *nresp += n;
2048           maxresplen -= n;
2049         }
2050           
2051       if (!(tpdu[1] & 0x20))
2052         return 0; /* No chaining requested - ready. */
2053       
2054       DEBUGOUT ("chaining requested but not supported for Secure operation\n");
2055       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2056     }
2057   else if ((tpdu[1] & 0xc0) == 0x80)
2058     { /* This is a R-block. */
2059       if ( (tpdu[1] & 0x0f)) 
2060         { /* Error: repeat last block */
2061           DEBUGOUT ("No retries supported for Secure operation\n");
2062           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2063         }
2064       else if (!!(tpdu[1] & 0x40) == handle->t1_ns)
2065         { /* Reponse does not match our sequence number. */
2066           DEBUGOUT ("R-block with wrong seqno received on more bit\n");
2067           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2068         }
2069       else
2070         { /* Send next chunk. */
2071           DEBUGOUT ("chaining not supported on Secure operation\n");
2072           return CCID_DRIVER_ERR_CARD_IO_ERROR;
2073         }
2074     }
2075   else 
2076     { /* This is a S-block. */
2077       DEBUGOUT_2 ("T1 S-block %s received cmd=%d for Secure operation\n",
2078                   (tpdu[1] & 0x20)? "response": "request",
2079                   (tpdu[1] & 0x1f));
2080       return CCID_DRIVER_ERR_CARD_IO_ERROR;
2081     } 
2082
2083   return 0;
2084 }
2085
2086
2087
2088
2089 #ifdef TEST
2090
2091
2092 static void
2093 print_error (int err)
2094 {
2095   const char *p;
2096   char buf[50];
2097
2098   switch (err)
2099     {
2100     case 0: p = "success";
2101     case CCID_DRIVER_ERR_OUT_OF_CORE: p = "out of core"; break;
2102     case CCID_DRIVER_ERR_INV_VALUE: p = "invalid value"; break;
2103     case CCID_DRIVER_ERR_NO_DRIVER: p = "no driver"; break;
2104     case CCID_DRIVER_ERR_NOT_SUPPORTED: p = "not supported"; break;
2105     case CCID_DRIVER_ERR_LOCKING_FAILED: p = "locking failed"; break;
2106     case CCID_DRIVER_ERR_BUSY: p = "busy"; break;
2107     case CCID_DRIVER_ERR_NO_CARD: p = "no card"; break;
2108     case CCID_DRIVER_ERR_CARD_INACTIVE: p = "card inactive"; break;
2109     case CCID_DRIVER_ERR_CARD_IO_ERROR: p = "card I/O error"; break;
2110     case CCID_DRIVER_ERR_GENERAL_ERROR: p = "general error"; break;
2111     case CCID_DRIVER_ERR_NO_READER: p = "no reader"; break;
2112     case CCID_DRIVER_ERR_ABORTED: p = "aborted"; break;
2113     default: sprintf (buf, "0x%05x", err); p = buf; break;
2114     }
2115   fprintf (stderr, "operation failed: %s\n", p);
2116 }
2117
2118 static void
2119 print_data (const unsigned char *data, size_t length)
2120 {
2121   if (length >= 2)
2122     {
2123       fprintf (stderr, "operation status: %02X%02X\n",
2124                data[length-2], data[length-1]);
2125       length -= 2;
2126     }
2127   if (length)
2128     {
2129         fputs ("   returned data:", stderr);
2130         for (; length; length--, data++)
2131           fprintf (stderr, " %02X", *data);
2132         putc ('\n', stderr);
2133     }
2134 }
2135
2136 static void
2137 print_result (int rc, const unsigned char *data, size_t length)
2138 {
2139   if (rc)
2140     print_error (rc);
2141   else if (data)
2142     print_data (data, length);
2143 }
2144
2145 int
2146 main (int argc, char **argv)
2147 {
2148   int rc;
2149   ccid_driver_t ccid;
2150   unsigned int slotstat;
2151   unsigned char result[512];
2152   size_t resultlen;
2153   int no_pinpad = 0;
2154   int verify_123456 = 0;
2155   int did_verify = 0;
2156   int no_poll = 0;
2157
2158   if (argc)
2159     {
2160       argc--;
2161       argv++;
2162     }
2163
2164   while (argc)
2165     {
2166       if ( !strcmp (*argv, "--list"))
2167         {
2168           char *p;
2169           p = ccid_get_reader_list ();
2170           if (!p)
2171             return 1;
2172           fputs (p, stderr);
2173           free (p);
2174           return 0;
2175         }
2176       else if ( !strcmp (*argv, "--debug"))
2177         {
2178           ccid_set_debug_level (1);
2179           argc--; argv++;
2180         }
2181       else if ( !strcmp (*argv, "--no-poll"))
2182         {
2183           no_poll = 1;
2184           argc--; argv++;
2185         }
2186       else if ( !strcmp (*argv, "--no-pinpad"))
2187         {
2188           no_pinpad = 1;
2189           argc--; argv++;
2190         }
2191       else if ( !strcmp (*argv, "--verify-123456"))
2192         {
2193           verify_123456 = 1;
2194           argc--; argv++;
2195         }
2196       else
2197         break;
2198     }
2199
2200   rc = ccid_open_reader (&ccid, argc? *argv:NULL);
2201   if (rc)
2202     return 1;
2203
2204   if (!no_poll)
2205     ccid_poll (ccid);
2206   fputs ("getting ATR ...\n", stderr);
2207   rc = ccid_get_atr (ccid, NULL, 0, NULL);
2208   if (rc)
2209     {
2210       print_error (rc);
2211       return 1;
2212     }
2213
2214   if (!no_poll)
2215     ccid_poll (ccid);
2216   fputs ("getting slot status ...\n", stderr);
2217   rc = ccid_slot_status (ccid, &slotstat);
2218   if (rc)
2219     {
2220       print_error (rc);
2221       return 1;
2222     }
2223
2224   if (!no_poll)
2225     ccid_poll (ccid);
2226
2227   fputs ("selecting application OpenPGP ....\n", stderr);
2228   {
2229     static unsigned char apdu[] = {
2230       0, 0xA4, 4, 0, 6, 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01};
2231     rc = ccid_transceive (ccid,
2232                           apdu, sizeof apdu,
2233                           result, sizeof result, &resultlen);
2234     print_result (rc, result, resultlen);
2235   }
2236   
2237
2238   if (!no_poll)
2239     ccid_poll (ccid);
2240
2241   fputs ("getting OpenPGP DO 0x65 ....\n", stderr);
2242   {
2243     static unsigned char apdu[] = { 0, 0xCA, 0, 0x65, 254 };
2244     rc = ccid_transceive (ccid, apdu, sizeof apdu,
2245                           result, sizeof result, &resultlen);
2246     print_result (rc, result, resultlen);
2247   }
2248
2249   if (!no_pinpad)
2250     {
2251     }
2252
2253   if (!no_pinpad)
2254     {
2255       static unsigned char apdu[] = { 0, 0x20, 0, 0x81 };
2256
2257       
2258       if (ccid_transceive_secure (ccid,
2259                                   apdu, sizeof apdu,
2260                                   1, 0, 0, 0,
2261                                   NULL, 0, NULL))
2262         fputs ("can't verify using a PIN-Pad reader\n", stderr);
2263       else
2264         {
2265           fputs ("verifying CHV1 using the PINPad ....\n", stderr);
2266           
2267           rc = ccid_transceive_secure (ccid,
2268                                        apdu, sizeof apdu,
2269                                        1, 0, 0, 0,
2270                                        result, sizeof result, &resultlen);
2271           print_result (rc, result, resultlen);
2272           did_verify = 1;
2273         }
2274     }
2275   
2276   if (verify_123456 && !did_verify)
2277     {
2278       fputs ("verifying that CHV1 is 123456....\n", stderr);
2279       {
2280         static unsigned char apdu[] = {0, 0x20, 0, 0x81,
2281                                        6, '1','2','3','4','5','6'};
2282         rc = ccid_transceive (ccid, apdu, sizeof apdu,
2283                               result, sizeof result, &resultlen);
2284         print_result (rc, result, resultlen);
2285       }
2286     }
2287
2288   if (!rc)
2289     {
2290       fputs ("getting OpenPGP DO 0x5E ....\n", stderr);
2291       {
2292         static unsigned char apdu[] = { 0, 0xCA, 0, 0x5E, 254 };
2293         rc = ccid_transceive (ccid, apdu, sizeof apdu,
2294                               result, sizeof result, &resultlen);
2295         print_result (rc, result, resultlen);
2296       }
2297     }
2298
2299   ccid_close_reader (ccid);
2300
2301   return 0;
2302 }
2303
2304 /*
2305  * Local Variables:
2306  *  compile-command: "gcc -DTEST -Wall -I/usr/local/include -lusb -g ccid-driver.c"
2307  * End:
2308  */
2309 #endif /*TEST*/
2310 #endif /*HAVE_LIBUSB*/