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