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