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