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