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