* misc.c (optsep): Add the ability to understand keyword="quoted arg with
[gnupg.git] / g10 / apdu.c
1 /* apdu.c - ISO 7816 APDU functions and low level I/O
2  *      Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27 #ifdef USE_GNU_PTH
28 # include <pth.h>
29 # include <unistd.h>
30 # include <fcntl.h>
31 #endif
32 #ifdef HAVE_OPENSC
33 # include <opensc/opensc.h>
34 #endif
35
36 #if defined(GNUPG_SCD_MAIN_HEADER)
37 #include GNUPG_SCD_MAIN_HEADER
38 #elif GNUPG_MAJOR_VERSION == 1
39 /* This is used with GnuPG version < 1.9.  The code has been source
40    copied from the current GnuPG >= 1.9  and is maintained over
41    there. */
42 #include "options.h"
43 #include "errors.h"
44 #include "memory.h"
45 #include "util.h"
46 #include "i18n.h"
47 #include "cardglue.h"
48 #else /* GNUPG_MAJOR_VERSION != 1 */
49 #include "scdaemon.h"
50 #endif /* GNUPG_MAJOR_VERSION != 1 */
51
52 #include "apdu.h"
53 #include "dynload.h"
54 #include "ccid-driver.h"
55
56 #ifdef USE_GNU_PTH
57 #define NEED_PCSC_WRAPPER 1
58 #endif
59
60
61 #define MAX_READER 4 /* Number of readers we support concurrently. */
62 #define CARD_CONNECT_TIMEOUT 1 /* Number of seconds to wait for
63                                   insertion of the card (1 = don't wait). */
64
65
66 #ifdef _WIN32
67 #define DLSTDCALL __stdcall
68 #else
69 #define DLSTDCALL
70 #endif
71
72 #ifdef _POSIX_OPEN_MAX
73 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
74 #else
75 #define MAX_OPEN_FDS 20
76 #endif
77
78
79 /* A structure to collect information pertaining to one reader
80    slot. */
81 struct reader_table_s {
82   int used;            /* True if slot is used. */
83   unsigned short port; /* Port number:  0 = unused, 1 - dev/tty */
84   int is_ccid;         /* Uses the internal CCID driver. */
85   struct {
86     ccid_driver_t handle;
87   } ccid;
88   int is_ctapi;        /* This is a ctAPI driver. */
89   struct {
90     unsigned long context;
91     unsigned long card;
92     unsigned long protocol;
93 #ifdef NEED_PCSC_WRAPPER
94     int req_fd;
95     int rsp_fd;
96     pid_t pid;
97 #endif /*NEED_PCSC_WRAPPER*/
98   } pcsc;
99 #ifdef HAVE_OPENSC
100   int is_osc;          /* We are using the OpenSC driver layer. */
101   struct {
102     struct sc_context *ctx;
103     struct sc_card *scard;
104   } osc;
105 #endif /*HAVE_OPENSC*/
106   int status;
107   unsigned char atr[33];
108   size_t atrlen;
109   unsigned int change_counter;
110 #ifdef USE_GNU_PTH
111   int lock_initialized;
112   pth_mutex_t lock;
113 #endif
114 };
115 typedef struct reader_table_s *reader_table_t;
116
117 /* A global table to keep track of active readers. */
118 static struct reader_table_s reader_table[MAX_READER];
119
120
121 /* ct API function pointer. */
122 static char (* DLSTDCALL CT_init) (unsigned short ctn, unsigned short Pn);
123 static char (* DLSTDCALL CT_data) (unsigned short ctn, unsigned char *dad,
124                                    unsigned char *sad, unsigned short lc,
125                                    unsigned char *cmd, unsigned short *lr,
126                                    unsigned char *rsp);
127 static char (* DLSTDCALL CT_close) (unsigned short ctn);
128
129 /* PC/SC constants and function pointer. */
130 #define PCSC_SCOPE_USER      0 
131 #define PCSC_SCOPE_TERMINAL  1 
132 #define PCSC_SCOPE_SYSTEM    2 
133 #define PCSC_SCOPE_GLOBAL    3 
134
135 #define PCSC_PROTOCOL_T0     1 
136 #define PCSC_PROTOCOL_T1     2 
137 #define PCSC_PROTOCOL_RAW    4 
138
139 #define PCSC_SHARE_EXCLUSIVE 1
140 #define PCSC_SHARE_SHARED    2
141 #define PCSC_SHARE_DIRECT    3
142
143 #define PCSC_LEAVE_CARD      0
144 #define PCSC_RESET_CARD      1
145 #define PCSC_UNPOWER_CARD    2
146 #define PCSC_EJECT_CARD      3
147
148 struct pcsc_io_request_s {
149   unsigned long protocol; 
150   unsigned long pci_len;
151 };
152
153 typedef struct pcsc_io_request_s *pcsc_io_request_t;
154
155 long (* DLSTDCALL pcsc_establish_context) (unsigned long scope,
156                                            const void *reserved1,
157                                            const void *reserved2,
158                                            unsigned long *r_context);
159 long (* DLSTDCALL pcsc_release_context) (unsigned long context);
160 long (* DLSTDCALL pcsc_list_readers) (unsigned long context,
161                                       const char *groups,
162                                       char *readers, unsigned long*readerslen);
163 long (* DLSTDCALL pcsc_connect) (unsigned long context,
164                                  const char *reader,
165                                  unsigned long share_mode,
166                                  unsigned long preferred_protocols,
167                                  unsigned long *r_card,
168                                  unsigned long *r_active_protocol);
169 long (* DLSTDCALL pcsc_disconnect) (unsigned long card,
170                                     unsigned long disposition);
171 long (* DLSTDCALL pcsc_status) (unsigned long card,
172                                 char *reader, unsigned long *readerlen,
173                                 unsigned long *r_state,
174                                 unsigned long *r_protocol,
175                                 unsigned char *atr, unsigned long *atrlen);
176 long (* DLSTDCALL pcsc_begin_transaction) (unsigned long card);
177 long (* DLSTDCALL pcsc_end_transaction) (unsigned long card);
178 long (* DLSTDCALL pcsc_transmit) (unsigned long card,
179                                   const pcsc_io_request_t send_pci,
180                                   const unsigned char *send_buffer,
181                                   unsigned long send_len,
182                                   pcsc_io_request_t recv_pci,
183                                   unsigned char *recv_buffer,
184                                   unsigned long *recv_len);
185 long (* DLSTDCALL pcsc_set_timeout) (unsigned long context,
186                                      unsigned long timeout);
187
188
189
190
191 \f
192 /* 
193       Helper
194  */
195  
196
197 /* Find an unused reader slot for PORTSTR and put it into the reader
198    table.  Return -1 on error or the index into the reader table. */
199 static int 
200 new_reader_slot (void)    
201 {
202   int i, reader = -1;
203
204   for (i=0; i < MAX_READER; i++)
205     {
206       if (!reader_table[i].used && reader == -1)
207         reader = i;
208     }
209   if (reader == -1)
210     {
211       log_error ("new_reader_slot: out of slots\n");
212       return -1;
213     }
214 #ifdef USE_GNU_PTH
215   if (!reader_table[reader].lock_initialized)
216     {
217       if (!pth_mutex_init (&reader_table[reader].lock))
218         {
219           log_error ("error initializing mutex: %s\n", strerror (errno));
220           return -1;
221         }
222       reader_table[reader].lock_initialized = 1;
223     }
224 #endif /*USE_GNU_PTH*/
225   reader_table[reader].used = 1;
226   reader_table[reader].is_ccid = 0;
227   reader_table[reader].is_ctapi = 0;
228 #ifdef HAVE_OPENSC
229   reader_table[reader].is_osc = 0;
230 #endif
231 #ifdef NEED_PCSC_WRAPPER
232   reader_table[reader].pcsc.req_fd = -1;
233   reader_table[reader].pcsc.rsp_fd = -1;
234   reader_table[reader].pcsc.pid = (pid_t)(-1);
235 #endif
236   return reader;
237 }
238
239
240 static void
241 dump_reader_status (int reader)
242 {
243   if (reader_table[reader].is_ccid)
244     log_info ("reader slot %d: using ccid driver\n", reader);
245   else if (reader_table[reader].is_ctapi)
246     {
247       log_info ("reader slot %d: %s\n", reader,
248                 reader_table[reader].status == 1? "Processor ICC present" :
249                 reader_table[reader].status == 0? "Memory ICC present" :
250                 "ICC not present" );
251     }
252   else
253     {
254       log_info ("reader slot %d: active protocol:", reader);
255       if ((reader_table[reader].pcsc.protocol & PCSC_PROTOCOL_T0))
256         log_printf (" T0");
257       else if ((reader_table[reader].pcsc.protocol & PCSC_PROTOCOL_T1))
258         log_printf (" T1");
259       else if ((reader_table[reader].pcsc.protocol & PCSC_PROTOCOL_RAW))
260         log_printf (" raw");
261       log_printf ("\n");
262     }
263
264   if (reader_table[reader].status != -1)
265     {
266       log_info ("reader %d: ATR=", reader);
267       log_printhex ("", reader_table[reader].atr,
268                     reader_table[reader].atrlen);
269     }
270 }
271
272
273 \f
274 /* 
275        ct API Interface 
276  */
277
278 static const char *
279 ct_error_string (long err)
280 {
281   switch (err)
282     {
283     case 0: return "okay";
284     case -1: return "invalid data";
285     case -8: return "ct error";
286     case -10: return "transmission error";
287     case -11: return "memory allocation error";
288     case -128: return "HTSI error";
289     default: return "unknown CT-API error";
290     }
291 }
292
293 /* Wait for the card in READER and activate it.  Return -1 on error or
294    0 on success. */
295 static int
296 ct_activate_card (int reader)
297 {
298   int rc, count;
299
300   for (count = 0; count < CARD_CONNECT_TIMEOUT; count++)
301     {
302       unsigned char dad[1], sad[1], cmd[11], buf[256];
303       unsigned short buflen;
304
305       if (count)
306         ; /* FIXME: we should use a more reliable timer than sleep. */
307
308       /* Check whether card has been inserted. */
309       dad[0] = 1;     /* Destination address: CT. */    
310       sad[0] = 2;     /* Source address: Host. */
311
312       cmd[0] = 0x20;  /* Class byte. */
313       cmd[1] = 0x13;  /* Request status. */
314       cmd[2] = 0x00;  /* From kernel. */
315       cmd[3] = 0x80;  /* Return card's DO. */
316       cmd[4] = 0x00;
317
318       buflen = DIM(buf);
319
320       rc = CT_data (reader, dad, sad, 5, cmd, &buflen, buf);
321       if (rc || buflen < 2 || buf[buflen-2] != 0x90)
322         {
323           log_error ("ct_activate_card: can't get status of reader %d: %s\n",
324                      reader, ct_error_string (rc));
325           return -1;
326         }
327
328       /* Connected, now activate the card. */           
329       dad[0] = 1;    /* Destination address: CT. */    
330       sad[0] = 2;    /* Source address: Host. */
331
332       cmd[0] = 0x20;  /* Class byte. */
333       cmd[1] = 0x12;  /* Request ICC. */
334       cmd[2] = 0x01;  /* From first interface. */
335       cmd[3] = 0x01;  /* Return card's ATR. */
336       cmd[4] = 0x00;
337
338       buflen = DIM(buf);
339
340       rc = CT_data (reader, dad, sad, 5, cmd, &buflen, buf);
341       if (rc || buflen < 2 || buf[buflen-2] != 0x90)
342         {
343           log_error ("ct_activate_card(%d): activation failed: %s\n",
344                      reader, ct_error_string (rc));
345           if (!rc)
346             log_printhex ("  received data:", buf, buflen);
347           return -1;
348         }
349
350       /* Store the type and the ATR. */
351       if (buflen - 2 > DIM (reader_table[0].atr))
352         {
353           log_error ("ct_activate_card(%d): ATR too long\n", reader);
354           return -1;
355         }
356
357       reader_table[reader].status = buf[buflen - 1];
358       memcpy (reader_table[reader].atr, buf, buflen - 2);
359       reader_table[reader].atrlen = buflen - 2;
360       return 0;
361     }
362  
363   log_info ("ct_activate_card(%d): timeout waiting for card\n", reader);
364   return -1;
365 }
366
367
368 /* Open a reader and return an internal handle for it.  PORT is a
369    non-negative value with the port number of the reader. USB readers
370    do have port numbers starting at 32769. */
371 static int
372 open_ct_reader (int port)
373 {
374   int rc, reader;
375
376   if (port < 0 || port > 0xffff)
377     {
378       log_error ("open_ct_reader: invalid port %d requested\n", port);
379       return -1;
380     }
381   reader = new_reader_slot ();
382   if (reader == -1)
383     return reader;
384   reader_table[reader].port = port;
385
386   rc = CT_init (reader, (unsigned short)port);
387   if (rc)
388     {
389       log_error ("apdu_open_ct_reader failed on port %d: %s\n",
390                  port, ct_error_string (rc));
391       reader_table[reader].used = 0;
392       return -1;
393     }
394
395   rc = ct_activate_card (reader);
396   if (rc)
397     {
398       reader_table[reader].used = 0;
399       return -1;
400     }
401
402   reader_table[reader].is_ctapi = 1;
403   dump_reader_status (reader);
404   return reader;
405 }
406
407 static int
408 close_ct_reader (int slot)
409 {
410   CT_close (slot);
411   reader_table[slot].used = 0;
412   return 0;
413 }
414
415 static int
416 reset_ct_reader (int slot)
417 {
418   return SW_HOST_NOT_SUPPORTED;
419 }
420
421
422 static int
423 ct_get_status (int slot, unsigned int *status)
424 {
425   return SW_HOST_NOT_SUPPORTED;
426 }
427
428 /* Actually send the APDU of length APDULEN to SLOT and return a
429    maximum of *BUFLEN data in BUFFER, the actual retruned size will be
430    set to BUFLEN.  Returns: CT API error code. */
431 static int
432 ct_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
433               unsigned char *buffer, size_t *buflen)
434 {
435   int rc;
436   unsigned char dad[1], sad[1];
437   unsigned short ctbuflen;
438   
439   dad[0] = 0;     /* Destination address: Card. */    
440   sad[0] = 2;     /* Source address: Host. */
441   ctbuflen = *buflen;
442   if (DBG_CARD_IO)
443     log_printhex ("  CT_data:", apdu, apdulen);
444   rc = CT_data (slot, dad, sad, apdulen, apdu, &ctbuflen, buffer);
445   *buflen = ctbuflen;
446
447   /* FIXME: map the errorcodes to GNUPG ones, so that they can be
448      shared between CTAPI and PCSC. */
449   return rc;
450 }
451
452
453 \f
454 #ifdef NEED_PCSC_WRAPPER
455 static int
456 writen (int fd, const void *buf, size_t nbytes)
457 {
458   size_t nleft = nbytes;
459   int nwritten;
460
461 /*   log_printhex (" writen:", buf, nbytes); */
462
463   while (nleft > 0)
464     {
465 #ifdef USE_GNU_PTH
466       nwritten = pth_write (fd, buf, nleft);
467 #else
468       nwritten = write (fd, buf, nleft);
469 #endif
470       if (nwritten < 0 && errno == EINTR)
471         continue;
472       if (nwritten < 0)
473         return -1;
474       nleft -= nwritten;
475       buf = (const char*)buf + nwritten;
476     }
477   return 0;
478 }
479
480 /* Read up to BUFLEN bytes from FD and return the number of bytes
481    actually read in NREAD.  Returns -1 on error or 0 on success. */
482 static int
483 readn (int fd, void *buf, size_t buflen, size_t *nread)
484 {
485   size_t nleft = buflen;
486   int n;
487 /*   void *orig_buf = buf; */
488
489   while (nleft > 0)
490     {
491 #ifdef USE_GNU_PTH
492       n = pth_read (fd, buf, nleft);
493 #else
494       n = read (fd, buf, nleft);
495 #endif
496       if (n < 0 && errno == EINTR) 
497         continue;
498       if (n < 0)
499         return -1; /* read error. */
500       if (!n)
501         break; /* EOF */
502       nleft -= n;
503       buf = (char*)buf + n;
504     }
505   if (nread)
506     *nread = buflen - nleft;
507
508 /*   log_printhex ("  readn:", orig_buf, *nread); */
509     
510   return 0;
511 }
512 #endif /*NEED_PCSC_WRAPPER*/
513
514 static const char *
515 pcsc_error_string (long err)
516 {
517   const char *s;
518
519   if (!err)
520     return "okay";
521   if ((err & 0x80100000) != 0x80100000)
522     return "invalid PC/SC error code";
523   err &= 0xffff;
524   switch (err)
525     {
526     case 0x0002: s = "cancelled"; break;
527     case 0x000e: s = "can't dispose"; break;
528     case 0x0008: s = "insufficient buffer"; break;   
529     case 0x0015: s = "invalid ATR"; break;
530     case 0x0003: s = "invalid handle"; break;
531     case 0x0004: s = "invalid parameter"; break; 
532     case 0x0005: s = "invalid target"; break;
533     case 0x0011: s = "invalid value"; break; 
534     case 0x0006: s = "no memory"; break;  
535     case 0x0013: s = "comm error"; break;      
536     case 0x0001: s = "internal error"; break;     
537     case 0x0014: s = "unknown error"; break; 
538     case 0x0007: s = "waited too long"; break;  
539     case 0x0009: s = "unknown reader"; break;
540     case 0x000a: s = "timeout"; break; 
541     case 0x000b: s = "sharing violation"; break;       
542     case 0x000c: s = "no smartcard"; break;
543     case 0x000d: s = "unknown card"; break;   
544     case 0x000f: s = "proto mismatch"; break;          
545     case 0x0010: s = "not ready"; break;               
546     case 0x0012: s = "system cancelled"; break;        
547     case 0x0016: s = "not transacted"; break;
548     case 0x0017: s = "reader unavailable"; break; 
549     case 0x0065: s = "unsupported card"; break;        
550     case 0x0066: s = "unresponsive card"; break;       
551     case 0x0067: s = "unpowered card"; break;          
552     case 0x0068: s = "reset card"; break;              
553     case 0x0069: s = "removed card"; break;            
554     case 0x006a: s = "inserted card"; break;           
555     case 0x001f: s = "unsupported feature"; break;     
556     case 0x0019: s = "PCI too small"; break;           
557     case 0x001a: s = "reader unsupported"; break;      
558     case 0x001b: s = "duplicate reader"; break;        
559     case 0x001c: s = "card unsupported"; break;        
560     case 0x001d: s = "no service"; break;              
561     case 0x001e: s = "service stopped"; break;      
562     default:     s = "unknown PC/SC error code"; break;
563     }
564   return s;
565 }
566
567 /* 
568        PC/SC Interface
569  */
570
571 static int
572 open_pcsc_reader (const char *portstr)
573 {
574 #ifdef NEED_PCSC_WRAPPER
575 /* Open the PC/SC reader using the pcsc_wrapper program.  This is
576    needed to cope with different thread models and other peculiarities
577    of libpcsclite. */
578   int slot;
579   reader_table_t slotp;
580   int fd, rp[2], wp[2];
581   int n, i;
582   pid_t pid;
583   size_t len;
584   unsigned char msgbuf[9];
585   int err;
586
587   slot = new_reader_slot ();
588   if (slot == -1)
589     return -1;
590   slotp = reader_table + slot;
591
592   /* Fire up the pcsc wrapper.  We don't use any fork/exec code from
593      the common directy but implement it direclty so that this file
594      may still be source copied. */
595   
596   if (pipe (rp) == -1)
597     {
598       log_error ("error creating a pipe: %s\n", strerror (errno));
599       slotp->used = 0;
600       return -1;
601     }
602   if (pipe (wp) == -1)
603     {
604       log_error ("error creating a pipe: %s\n", strerror (errno));
605       close (rp[0]);
606       close (rp[1]);
607       slotp->used = 0;
608       return -1;
609     }
610       
611   pid = fork ();
612   if (pid == -1)
613     {
614       log_error ("error forking process: %s\n", strerror (errno));
615       close (rp[0]);
616       close (rp[1]);
617       close (wp[0]);
618       close (wp[1]);
619       slotp->used = 0;
620       return -1;
621     }
622   slotp->pcsc.pid = pid;
623
624   if (!pid)
625     { /*
626          === Child ===
627        */
628
629       /* Double fork. */
630       pid = fork ();
631       if (pid == -1)
632         _exit (31); 
633       if (pid)
634         _exit (0); /* Immediate exit this parent, so that the child
635                       gets cleaned up by the init process. */
636
637       /* Connect our pipes. */
638       if (wp[0] != 0 && dup2 (wp[0], 0) == -1)
639         log_fatal ("dup2 stdin failed: %s\n", strerror (errno));
640       if (rp[1] != 1 && dup2 (rp[1], 1) == -1)
641         log_fatal ("dup2 stdout failed: %s\n", strerror (errno));
642       
643       /* Send stderr to the bit bucket. */
644       fd = open ("/dev/null", O_WRONLY);
645       if (fd == -1)
646         log_fatal ("can't open `/dev/null': %s", strerror (errno));
647       if (fd != 2 && dup2 (fd, 2) == -1)
648         log_fatal ("dup2 stderr failed: %s\n", strerror (errno));
649
650       /* Close all other files. */
651       n = sysconf (_SC_OPEN_MAX);
652       if (n < 0)
653         n = MAX_OPEN_FDS;
654       for (i=3; i < n; i++)
655         close(i);
656       errno = 0;
657
658       execl (GNUPG_LIBDIR "/pcsc-wrapper",
659              "pcsc-wrapper",
660              "--",
661              "1", /* API version */
662              opt.pcsc_driver, /* Name of the PC/SC library. */
663               NULL);
664       _exit (31);
665     }
666
667   /* 
668      === Parent ===
669    */
670   close (wp[0]);
671   close (rp[1]);
672   slotp->pcsc.req_fd = wp[1];
673   slotp->pcsc.rsp_fd = rp[0];
674
675   /* Wait for the intermediate child to terminate. */
676   while ( (i=pth_waitpid (pid, NULL, 0)) == -1 && errno == EINTR)
677     ;
678
679   /* Now send the open request. */
680   msgbuf[0] = 0x01; /* OPEN command. */
681   len = portstr? strlen (portstr):0;
682   msgbuf[1] = (len >> 24);
683   msgbuf[2] = (len >> 16);
684   msgbuf[3] = (len >>  8);
685   msgbuf[4] = (len      );
686   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
687        || (portstr && writen (slotp->pcsc.req_fd, portstr, len)))
688     {
689       log_error ("error sending PC/SC OPEN request: %s\n",
690                  strerror (errno));
691       goto command_failed;
692     }
693   /* Read the response. */
694   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
695     {
696       log_error ("error receiving PC/SC OPEN response: %s\n",
697                  i? strerror (errno) : "premature EOF");
698       goto command_failed;
699     }
700   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
701   if (msgbuf[0] != 0x81 || len < 4)
702     {
703       log_error ("invalid response header from PC/SC received\n");
704       goto command_failed;
705     }
706   len -= 4; /* Already read the error code. */
707   if (len > DIM (slotp->atr))
708     {
709       log_error ("PC/SC returned a too large ATR (len=%x)\n", len);
710       goto command_failed;
711     }
712   err = (msgbuf[5] << 24) | (msgbuf[6] << 16) | (msgbuf[7] << 8 ) | msgbuf[8];
713   if (err)
714     {
715       log_error ("PC/SC OPEN failed: %s\n", pcsc_error_string (err));
716       goto command_failed;
717     }
718   n = len;
719   if ((i=readn (slotp->pcsc.rsp_fd, slotp->atr, n, &len)) || len != n)
720     {
721       log_error ("error receiving PC/SC OPEN response: %s\n",
722                  i? strerror (errno) : "premature EOF");
723       goto command_failed;
724     }
725   slotp->atrlen = len;
726
727   dump_reader_status (slot); 
728   return slot;
729
730  command_failed:
731   close (slotp->pcsc.req_fd);
732   close (slotp->pcsc.rsp_fd);
733   slotp->pcsc.req_fd = -1;
734   slotp->pcsc.rsp_fd = -1;
735   kill (slotp->pcsc.pid, SIGTERM);
736   slotp->pcsc.pid = (pid_t)(-1);
737   slotp->used = 0;
738   return -1;
739 #else /*!NEED_PCSC_WRAPPER */
740   long err;
741   int slot;
742   char *list = NULL;
743   unsigned long nreader, listlen, atrlen;
744   char *p;
745   unsigned long card_state, card_protocol;
746
747   slot = new_reader_slot ();
748   if (slot == -1)
749     return -1;
750
751   err = pcsc_establish_context (PCSC_SCOPE_SYSTEM, NULL, NULL,
752                                 &reader_table[slot].pcsc.context);
753   if (err)
754     {
755       log_error ("pcsc_establish_context failed: %s (0x%lx)\n",
756                  pcsc_error_string (err), err);
757       reader_table[slot].used = 0;
758       return -1;
759     }
760   
761   err = pcsc_list_readers (reader_table[slot].pcsc.context,
762                            NULL, NULL, &nreader);
763   if (!err)
764     {
765       list = xtrymalloc (nreader+1); /* Better add 1 for safety reasons. */
766       if (!list)
767         {
768           log_error ("error allocating memory for reader list\n");
769           pcsc_release_context (reader_table[slot].pcsc.context);
770           reader_table[slot].used = 0;
771           return -1;
772         }
773       err = pcsc_list_readers (reader_table[slot].pcsc.context,
774                                NULL, list, &nreader);
775     }
776   if (err)
777     {
778       log_error ("pcsc_list_readers failed: %s (0x%lx)\n",
779                  pcsc_error_string (err), err);
780       pcsc_release_context (reader_table[slot].pcsc.context);
781       reader_table[slot].used = 0;
782       xfree (list);
783       return -1;
784     }
785
786   listlen = nreader;
787   p = list;
788   while (nreader)
789     {
790       if (!*p && !p[1])
791         break;
792       log_info ("detected reader `%s'\n", p);
793       if (nreader < (strlen (p)+1))
794         {
795           log_error ("invalid response from pcsc_list_readers\n");
796           break;
797         }
798       nreader -= strlen (p)+1;
799       p += strlen (p) + 1;
800     }
801
802   err = pcsc_connect (reader_table[slot].pcsc.context,
803                       portstr? portstr : list,
804                       PCSC_SHARE_EXCLUSIVE,
805                       PCSC_PROTOCOL_T0|PCSC_PROTOCOL_T1,
806                       &reader_table[slot].pcsc.card,
807                       &reader_table[slot].pcsc.protocol);
808   if (err)
809     {
810       log_error ("pcsc_connect failed: %s (0x%lx)\n",
811                   pcsc_error_string (err), err);
812       pcsc_release_context (reader_table[slot].pcsc.context);
813       reader_table[slot].used = 0;
814       xfree (list);
815       return -1;
816     }      
817   
818   atrlen = 32;
819   /* (We need to pass a dummy buffer.  We use LIST because it ought to
820      be large enough.) */
821   err = pcsc_status (reader_table[slot].pcsc.card,
822                      list, &listlen,
823                      &card_state, &card_protocol,
824                      reader_table[slot].atr, &atrlen);
825   xfree (list);
826   if (err)
827     {
828       log_error ("pcsc_status failed: %s (0x%lx)\n",
829                   pcsc_error_string (err), err);
830       pcsc_release_context (reader_table[slot].pcsc.context);
831       reader_table[slot].used = 0;
832       return -1;
833     }
834   if (atrlen >= DIM (reader_table[0].atr))
835     log_bug ("ATR returned by pcsc_status is too large\n");
836   reader_table[slot].atrlen = atrlen;
837 /*   log_debug ("state    from pcsc_status: 0x%lx\n", card_state); */
838 /*   log_debug ("protocol from pcsc_status: 0x%lx\n", card_protocol); */
839
840   dump_reader_status (slot); 
841   return slot;
842 #endif /*!NEED_PCSC_WRAPPER */
843 }
844
845
846 static int
847 pcsc_get_status (int slot, unsigned int *status)
848 {
849   return SW_HOST_NOT_SUPPORTED;
850 }
851
852 /* Actually send the APDU of length APDULEN to SLOT and return a
853    maximum of *BUFLEN data in BUFFER, the actual returned size will be
854    set to BUFLEN.  Returns: CT API error code. */
855 static int
856 pcsc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
857                 unsigned char *buffer, size_t *buflen)
858 {
859 #ifdef NEED_PCSC_WRAPPER
860   long err;
861   reader_table_t slotp;
862   size_t len, full_len;
863   int i, n;
864   unsigned char msgbuf[9];
865
866   if (DBG_CARD_IO)
867     log_printhex ("  PCSC_data:", apdu, apdulen);
868
869   slotp = reader_table + slot;
870
871   if (slotp->pcsc.req_fd == -1 
872       || slotp->pcsc.rsp_fd == -1 
873       || slotp->pcsc.pid == (pid_t)(-1) )
874     {
875       log_error ("pcsc_send_apdu: pcsc-wrapper not running\n");
876       return -1;
877     }
878
879   msgbuf[0] = 0x03; /* TRANSMIT command. */
880   len = apdulen;
881   msgbuf[1] = (len >> 24);
882   msgbuf[2] = (len >> 16);
883   msgbuf[3] = (len >>  8);
884   msgbuf[4] = (len      );
885   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
886        || writen (slotp->pcsc.req_fd, apdu, len))
887     {
888       log_error ("error sending PC/SC TRANSMIT request: %s\n",
889                  strerror (errno));
890       goto command_failed;
891     }
892
893   /* Read the response. */
894   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
895     {
896       log_error ("error receiving PC/SC TRANSMIT response: %s\n",
897                  i? strerror (errno) : "premature EOF");
898       goto command_failed;
899     }
900   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
901   if (msgbuf[0] != 0x81 || len < 4)
902     {
903       log_error ("invalid response header from PC/SC received\n");
904       goto command_failed;
905     }
906   len -= 4; /* Already read the error code. */
907   err = (msgbuf[5] << 24) | (msgbuf[6] << 16) | (msgbuf[7] << 8 ) | msgbuf[8];
908   if (err)
909     {
910       log_error ("pcsc_transmit failed: %s (0x%lx)\n",
911                  pcsc_error_string (err), err);
912       return -1;
913     }
914
915    full_len = len;
916    
917    n = *buflen < len ? *buflen : len;
918    if ((i=readn (slotp->pcsc.rsp_fd, buffer, n, &len)) || len != n)
919      {
920        log_error ("error receiving PC/SC TRANSMIT response: %s\n",
921                   i? strerror (errno) : "premature EOF");
922        goto command_failed;
923      }
924    *buflen = n;
925
926    full_len -= len;
927    if (full_len)
928      {
929        log_error ("pcsc_send_apdu: provided buffer too short - truncated\n");
930        err = -1; 
931      }
932    /* We need to read any rest of the response, to keep the
933       protocol runnng. */
934    while (full_len)
935      {
936        unsigned char dummybuf[128];
937
938        n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
939        if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
940          {
941            log_error ("error receiving PC/SC TRANSMIT response: %s\n",
942                       i? strerror (errno) : "premature EOF");
943            goto command_failed;
944          }
945        full_len -= n;
946      }
947
948    return err;
949
950  command_failed:
951   close (slotp->pcsc.req_fd);
952   close (slotp->pcsc.rsp_fd);
953   slotp->pcsc.req_fd = -1;
954   slotp->pcsc.rsp_fd = -1;
955   kill (slotp->pcsc.pid, SIGTERM);
956   slotp->pcsc.pid = (pid_t)(-1);
957   slotp->used = 0;
958   return -1;
959
960 #else /*!NEED_PCSC_WRAPPER*/
961
962   long err;
963   struct pcsc_io_request_s send_pci;
964   unsigned long recv_len;
965   
966   if (DBG_CARD_IO)
967     log_printhex ("  PCSC_data:", apdu, apdulen);
968
969   if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
970       send_pci.protocol = PCSC_PROTOCOL_T1;
971   else
972       send_pci.protocol = PCSC_PROTOCOL_T0;
973   send_pci.pci_len = sizeof send_pci;
974   recv_len = *buflen;
975   err = pcsc_transmit (reader_table[slot].pcsc.card,
976                        &send_pci, apdu, apdulen,
977                        NULL, buffer, &recv_len);
978   *buflen = recv_len;
979   if (err)
980     log_error ("pcsc_transmit failed: %s (0x%lx)\n",
981                pcsc_error_string (err), err);
982   
983   return err? -1:0; /* FIXME: Return appropriate error code. */
984 #endif /*!NEED_PCSC_WRAPPER*/
985 }
986
987
988 static int
989 close_pcsc_reader (int slot)
990 {
991 #ifdef NEED_PCSC_WRAPPER
992   long err;
993   reader_table_t slotp;
994   size_t len;
995   int i;
996   unsigned char msgbuf[9];
997
998   slotp = reader_table + slot;
999
1000   if (slotp->pcsc.req_fd == -1 
1001       || slotp->pcsc.rsp_fd == -1 
1002       || slotp->pcsc.pid == (pid_t)(-1) )
1003     {
1004       log_error ("close_pcsc_reader: pcsc-wrapper not running\n");
1005       return 0;
1006     }
1007
1008   msgbuf[0] = 0x02; /* CLOSE command. */
1009   len = 0;
1010   msgbuf[1] = (len >> 24);
1011   msgbuf[2] = (len >> 16);
1012   msgbuf[3] = (len >>  8);
1013   msgbuf[4] = (len      );
1014   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
1015     {
1016       log_error ("error sending PC/SC CLOSE request: %s\n",
1017                  strerror (errno));
1018       goto command_failed;
1019     }
1020
1021   /* Read the response. */
1022   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1023     {
1024       log_error ("error receiving PC/SC CLOSE response: %s\n",
1025                  i? strerror (errno) : "premature EOF");
1026       goto command_failed;
1027     }
1028   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1029   if (msgbuf[0] != 0x81 || len < 4)
1030     {
1031       log_error ("invalid response header from PC/SC received\n");
1032       goto command_failed;
1033     }
1034   len -= 4; /* Already read the error code. */
1035   err = (msgbuf[5] << 24) | (msgbuf[6] << 16) | (msgbuf[7] << 8 ) | msgbuf[8];
1036   if (err)
1037     log_error ("pcsc_close failed: %s (0x%lx)\n",
1038                pcsc_error_string (err), err);
1039   
1040   /* We will the wrapper in any case - errors are merely
1041      informational. */
1042   
1043  command_failed:
1044   close (slotp->pcsc.req_fd);
1045   close (slotp->pcsc.rsp_fd);
1046   slotp->pcsc.req_fd = -1;
1047   slotp->pcsc.rsp_fd = -1;
1048   kill (slotp->pcsc.pid, SIGTERM);
1049   slotp->pcsc.pid = (pid_t)(-1);
1050   slotp->used = 0;
1051   return 0;
1052
1053 #else /*!NEED_PCSC_WRAPPER*/
1054
1055   pcsc_release_context (reader_table[slot].pcsc.context);
1056   reader_table[slot].used = 0;
1057   return 0;
1058 #endif /*!NEED_PCSC_WRAPPER*/
1059 }
1060
1061 static int
1062 reset_pcsc_reader (int slot)
1063 {
1064   return SW_HOST_NOT_SUPPORTED;
1065 }
1066
1067
1068
1069
1070 \f
1071 #ifdef HAVE_LIBUSB
1072 /* 
1073      Internal CCID driver interface.
1074  */
1075
1076 static const char *
1077 get_ccid_error_string (long err)
1078 {
1079   if (!err)
1080     return "okay";
1081   else
1082     return "unknown CCID error";
1083 }
1084
1085 static int
1086 open_ccid_reader (void)
1087 {
1088   int err;
1089   int slot;
1090   reader_table_t slotp;
1091
1092   slot = new_reader_slot ();
1093   if (slot == -1)
1094     return -1;
1095   slotp = reader_table + slot;
1096
1097   err = ccid_open_reader (&slotp->ccid.handle, 0);
1098   if (err)
1099     {
1100       slotp->used = 0;
1101       return -1;
1102     }
1103
1104   err = ccid_get_atr (slotp->ccid.handle,
1105                       slotp->atr, sizeof slotp->atr, &slotp->atrlen);
1106   if (err)
1107     {
1108       slotp->used = 0;
1109       return -1;
1110     }
1111
1112   slotp->is_ccid = 1;
1113
1114   dump_reader_status (slot); 
1115   return slot;
1116 }
1117
1118 static int
1119 close_ccid_reader (int slot)
1120 {
1121   ccid_close_reader (reader_table[slot].ccid.handle);
1122   reader_table[slot].used = 0;
1123   return 0;
1124 }                       
1125   
1126
1127 static int
1128 reset_ccid_reader (int slot)
1129 {
1130   int err;
1131   reader_table_t slotp = reader_table + slot;
1132   unsigned char atr[33];
1133   size_t atrlen;
1134
1135   err = ccid_get_atr (slotp->ccid.handle, atr, sizeof atr, &atrlen);
1136   if (err)
1137     return -1;
1138   /* If the reset was successful, update the ATR. */
1139   assert (sizeof slotp->atr >= sizeof atr);
1140   slotp->atrlen = atrlen;
1141   memcpy (slotp->atr, atr, atrlen);
1142   dump_reader_status (slot); 
1143   return 0;
1144 }                       
1145   
1146
1147 static int
1148 get_status_ccid (int slot, unsigned int *status)
1149 {
1150   int rc;
1151   int bits;
1152
1153   rc = ccid_slot_status (reader_table[slot].ccid.handle, &bits);
1154   if (rc)
1155     return -1;
1156
1157   if (bits == 0)
1158     *status = 1|2|4;
1159   else if (bits == 1)
1160     *status = 2;
1161   else 
1162     *status = 0;
1163
1164   return 0;
1165 }
1166
1167
1168 /* Actually send the APDU of length APDULEN to SLOT and return a
1169    maximum of *BUFLEN data in BUFFER, the actual returned size will be
1170    set to BUFLEN.  Returns: Internal CCID driver error code. */
1171 static int
1172 send_apdu_ccid (int slot, unsigned char *apdu, size_t apdulen,
1173                 unsigned char *buffer, size_t *buflen)
1174 {
1175   long err;
1176   size_t maxbuflen;
1177
1178   if (DBG_CARD_IO)
1179     log_printhex ("  APDU_data:", apdu, apdulen);
1180
1181   maxbuflen = *buflen;
1182   err = ccid_transceive (reader_table[slot].ccid.handle,
1183                          apdu, apdulen,
1184                          buffer, maxbuflen, buflen);
1185   if (err)
1186     log_error ("ccid_transceive failed: (0x%lx)\n",
1187                err);
1188   
1189   return err? -1:0; /* FIXME: Return appropriate error code. */
1190 }
1191
1192 #endif /* HAVE_LIBUSB */
1193
1194
1195 \f
1196 #ifdef HAVE_OPENSC
1197 /* 
1198      OpenSC Interface.
1199
1200      This uses the OpenSC primitives to send APDUs.  We need this
1201      because we can't mix OpenSC and native (i.e. ctAPI or PC/SC)
1202      access to a card for resource conflict reasons.
1203  */
1204
1205 static int
1206 open_osc_reader (int portno)
1207 {
1208   int err;
1209   int slot;
1210   reader_table_t slotp;
1211
1212   slot = new_reader_slot ();
1213   if (slot == -1)
1214     return -1;
1215   slotp = reader_table + slot;
1216
1217   err = sc_establish_context (&slotp->osc.ctx, "scdaemon");
1218   if (err)
1219     {
1220       log_error ("failed to establish SC context: %s\n", sc_strerror (err));
1221       slotp->used = 0;
1222       return -1;
1223     }
1224   if (portno < 0 || portno >= slotp->osc.ctx->reader_count)
1225     {
1226       log_error ("no card reader available\n");
1227       sc_release_context (slotp->osc.ctx);
1228       slotp->used = 0;
1229       return -1;
1230     }
1231
1232   /* Redirect to our logging facility. */
1233   slotp->osc.ctx->error_file = log_get_stream ();
1234   slotp->osc.ctx->debug = opt.debug_sc;
1235   slotp->osc.ctx->debug_file = log_get_stream ();
1236
1237   if (sc_detect_card_presence (slotp->osc.ctx->reader[portno], 0) != 1)
1238     {
1239       log_error ("no card present\n");
1240       sc_release_context (slotp->osc.ctx);
1241       slotp->used = 0;
1242       return -1;
1243     }
1244   
1245   /* We want the standard ISO driver. */
1246   /*FIXME: OpenSC does not like "iso7816", so we use EMV for now. */
1247   err = sc_set_card_driver(slotp->osc.ctx, "emv");
1248   if (err)
1249     {
1250       log_error ("failed to select the iso7816 driver: %s\n",
1251                  sc_strerror (err));
1252       sc_release_context (slotp->osc.ctx);
1253       slotp->used = 0;
1254       return -1;
1255     }
1256
1257   /* Now connect the card and hope that OpenSC won't try to be too
1258      smart. */
1259   err = sc_connect_card (slotp->osc.ctx->reader[portno], 0,
1260                          &slotp->osc.scard);
1261   if (err)
1262     {
1263       log_error ("failed to connect card in reader %d: %s\n",
1264                  portno, sc_strerror (err));
1265       sc_release_context (slotp->osc.ctx);
1266       slotp->used = 0;
1267       return -1;
1268     }
1269   if (opt.verbose)
1270     log_info ("connected to card in opensc reader %d using driver `%s'\n",
1271               portno, slotp->osc.scard->driver->name);
1272
1273   err = sc_lock (slotp->osc.scard);
1274   if (err)
1275     {
1276       log_error ("can't lock card in reader %d: %s\n",
1277                  portno, sc_strerror (err));
1278       sc_disconnect_card (slotp->osc.scard, 0);
1279       sc_release_context (slotp->osc.ctx);
1280       slotp->used = 0;
1281       return -1;
1282     }
1283
1284   if (slotp->osc.scard->atr_len >= DIM (slotp->atr))
1285     log_bug ("ATR returned by opensc is too large\n");
1286   slotp->atrlen = slotp->osc.scard->atr_len;
1287   memcpy (slotp->atr, slotp->osc.scard->atr, slotp->atrlen);
1288
1289   slotp->is_osc = 1;
1290
1291   dump_reader_status (slot); 
1292   return slot;
1293 }
1294
1295
1296 static int
1297 close_osc_reader (int slot)
1298 {
1299   /* FIXME: Implement. */
1300   reader_table[slot].used = 0;
1301   return 0;
1302 }
1303
1304 static int
1305 reset_osc_reader (int slot)
1306 {
1307   return SW_HOST_NOT_SUPPORTED;
1308 }
1309
1310
1311 static int
1312 ocsc_get_status (int slot, unsigned int *status)
1313 {
1314   return SW_HOST_NOT_SUPPORTED;
1315 }
1316
1317
1318 /* Actually send the APDU of length APDULEN to SLOT and return a
1319    maximum of *BUFLEN data in BUFFER, the actual returned size will be
1320    set to BUFLEN.  Returns: OpenSC error code. */
1321 static int
1322 osc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
1323                 unsigned char *buffer, size_t *buflen)
1324 {
1325   long err;
1326   struct sc_apdu a;
1327   unsigned char data[SC_MAX_APDU_BUFFER_SIZE];
1328   unsigned char result[SC_MAX_APDU_BUFFER_SIZE];
1329
1330   if (DBG_CARD_IO)
1331     log_printhex ("  APDU_data:", apdu, apdulen);
1332
1333   if (apdulen < 4)
1334     {
1335       log_error ("osc_send_apdu: APDU is too short\n");
1336       return SC_ERROR_CMD_TOO_SHORT;
1337     }
1338
1339   memset(&a, 0, sizeof a);
1340   a.cla = *apdu++;
1341   a.ins = *apdu++;
1342   a.p1 = *apdu++;
1343   a.p2 = *apdu++;
1344   apdulen -= 4;
1345
1346   if (!apdulen)
1347     a.cse = SC_APDU_CASE_1;
1348   else if (apdulen == 1) 
1349     {
1350       a.le = *apdu? *apdu : 256;
1351       apdu++; apdulen--;
1352       a.cse = SC_APDU_CASE_2_SHORT;
1353     }
1354   else
1355     {
1356       a.lc = *apdu++; apdulen--;
1357       if (apdulen < a.lc)
1358         {
1359           log_error ("osc_send_apdu: APDU shorter than specified in Lc\n");
1360           return SC_ERROR_CMD_TOO_SHORT;
1361
1362         }
1363       memcpy(data, apdu, a.lc);
1364       apdu += a.lc; apdulen -= a.lc;
1365
1366       a.data = data;
1367       a.datalen = a.lc;
1368       
1369       if (!apdulen)
1370         a.cse = SC_APDU_CASE_3_SHORT;
1371       else
1372         {
1373           a.le = *apdu? *apdu : 256;
1374           apdu++; apdulen--;
1375           if (apdulen)
1376             {
1377               log_error ("osc_send_apdu: APDU larger than specified\n");
1378               return SC_ERROR_CMD_TOO_LONG;
1379             }
1380           a.cse = SC_APDU_CASE_4_SHORT;
1381         }
1382     }
1383
1384   a.resp = result;
1385   a.resplen = DIM(result);
1386
1387   err = sc_transmit_apdu (reader_table[slot].osc.scard, &a);
1388   if (err)
1389     {
1390       log_error ("sc_apdu_transmit failed: %s\n", sc_strerror (err));
1391       return err;
1392     }
1393
1394   if (*buflen < 2 || a.resplen > *buflen - 2)
1395     {
1396       log_error ("osc_send_apdu: provided buffer too short to store result\n");
1397       return SC_ERROR_BUFFER_TOO_SMALL;
1398     }
1399   memcpy (buffer, a.resp, a.resplen);
1400   buffer[a.resplen] = a.sw1;
1401   buffer[a.resplen+1] = a.sw2;
1402   *buflen = a.resplen + 2;
1403   return 0;
1404 }
1405
1406 #endif /* HAVE_OPENSC */
1407
1408
1409 \f
1410 /* 
1411        Driver Access
1412  */
1413
1414
1415 static int
1416 lock_slot (int slot)
1417 {
1418 #ifdef USE_GNU_PTH
1419   if (!pth_mutex_acquire (&reader_table[slot].lock, 0, NULL))
1420     {
1421       log_error ("failed to acquire apdu lock: %s\n", strerror (errno));
1422       return SW_HOST_LOCKING_FAILED;
1423     }
1424 #endif /*USE_GNU_PTH*/
1425   return 0;
1426 }
1427
1428 static int
1429 trylock_slot (int slot)
1430 {
1431 #ifdef USE_GNU_PTH
1432   if (!pth_mutex_acquire (&reader_table[slot].lock, TRUE, NULL))
1433     {
1434       if (errno == EBUSY)
1435         return SW_HOST_BUSY;
1436       log_error ("failed to acquire apdu lock: %s\n", strerror (errno));
1437       return SW_HOST_LOCKING_FAILED;
1438     }
1439 #endif /*USE_GNU_PTH*/
1440   return 0;
1441 }
1442
1443 static void
1444 unlock_slot (int slot)
1445 {
1446 #ifdef USE_GNU_PTH
1447   if (!pth_mutex_release (&reader_table[slot].lock))
1448     log_error ("failed to release apdu lock: %s\n", strerror (errno));
1449 #endif /*USE_GNU_PTH*/
1450 }
1451
1452
1453 /* Open the reader and return an internal slot number or -1 on
1454    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
1455    the first USB reader.  For PC/SC the first listed reader).  If
1456    OpenSC support is compiled in, we first try to use OpenSC. */
1457 int
1458 apdu_open_reader (const char *portstr)
1459 {
1460   static int pcsc_api_loaded, ct_api_loaded;
1461
1462 #ifdef HAVE_LIBUSB
1463   if (!opt.disable_ccid)
1464     {
1465       int slot;
1466
1467       slot = open_ccid_reader ();
1468       if (slot != -1)
1469         return slot; /* got one */
1470     }
1471 #endif /* HAVE_LIBUSB */
1472
1473 #ifdef HAVE_OPENSC
1474   if (!opt.disable_opensc)
1475     {
1476       int port = portstr? atoi (portstr) : 0;
1477
1478       return open_osc_reader (port);
1479     }
1480 #endif /* HAVE_OPENSC */  
1481
1482
1483   if (opt.ctapi_driver && *opt.ctapi_driver)
1484     {
1485       int port = portstr? atoi (portstr) : 32768;
1486
1487       if (!ct_api_loaded)
1488         {
1489           void *handle;
1490           
1491           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
1492           if (!handle)
1493             {
1494               log_error ("apdu_open_reader: failed to open driver: %s\n",
1495                          dlerror ());
1496               return -1;
1497             }
1498           CT_init = dlsym (handle, "CT_init");
1499           CT_data = dlsym (handle, "CT_data");
1500           CT_close = dlsym (handle, "CT_close");
1501           if (!CT_init || !CT_data || !CT_close)
1502             {
1503               log_error ("apdu_open_reader: invalid CT-API driver\n");
1504               dlclose (handle);
1505               return -1;
1506             }
1507           ct_api_loaded = 1;
1508         }
1509       return open_ct_reader (port);
1510     }
1511
1512   
1513   /* No ctAPI configured, so lets try the PC/SC API */
1514   if (!pcsc_api_loaded)
1515     {
1516 #ifndef NEED_PCSC_WRAPPER
1517       void *handle;
1518
1519       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
1520       if (!handle)
1521         {
1522           log_error ("apdu_open_reader: failed to open driver `%s': %s\n",
1523                      opt.pcsc_driver, dlerror ());
1524           return -1;
1525         }
1526
1527       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
1528       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
1529       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
1530 #ifdef _WIN32
1531       if (!pcsc_list_readers)
1532         pcsc_list_readers    = dlsym (handle, "SCardListReadersA");
1533 #endif
1534       pcsc_connect           = dlsym (handle, "SCardConnect");
1535 #ifdef _WIN32
1536       if (!pcsc_connect)
1537         pcsc_connect         = dlsym (handle, "SCardConnectA");
1538 #endif
1539       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
1540       pcsc_status            = dlsym (handle, "SCardStatus");
1541 #ifdef _WIN32
1542       if (!pcsc_status)
1543         pcsc_status          = dlsym (handle, "SCardStatusA");
1544 #endif
1545       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
1546       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
1547       pcsc_transmit          = dlsym (handle, "SCardTransmit");
1548       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
1549
1550       if (!pcsc_establish_context
1551           || !pcsc_release_context  
1552           || !pcsc_list_readers     
1553           || !pcsc_connect          
1554           || !pcsc_disconnect
1555           || !pcsc_status
1556           || !pcsc_begin_transaction
1557           || !pcsc_end_transaction
1558           || !pcsc_transmit         
1559           /* || !pcsc_set_timeout */)
1560         {
1561           /* Note that set_timeout is currently not used and also not
1562              available under Windows. */
1563           log_error ("apdu_open_reader: invalid PC/SC driver "
1564                      "(%d%d%d%d%d%d%d%d%d%d)\n",
1565                      !!pcsc_establish_context,
1566                      !!pcsc_release_context,  
1567                      !!pcsc_list_readers,     
1568                      !!pcsc_connect,          
1569                      !!pcsc_disconnect,
1570                      !!pcsc_status,
1571                      !!pcsc_begin_transaction,
1572                      !!pcsc_end_transaction,
1573                      !!pcsc_transmit,         
1574                      !!pcsc_set_timeout );
1575           dlclose (handle);
1576           return -1;
1577         }
1578 #endif /*!NEED_PCSC_WRAPPER*/  
1579       pcsc_api_loaded = 1;
1580     }
1581
1582   return open_pcsc_reader (portstr);
1583 }
1584
1585
1586 int
1587 apdu_close_reader (int slot)
1588 {
1589   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1590     return SW_HOST_NO_DRIVER;
1591   if (reader_table[slot].is_ctapi)
1592     return close_ct_reader (slot);
1593 #ifdef HAVE_LIBUSB
1594   else if (reader_table[slot].is_ccid)
1595     return close_ccid_reader (slot);
1596 #endif
1597 #ifdef HAVE_OPENSC
1598   else if (reader_table[slot].is_osc)
1599     return close_osc_reader (slot);
1600 #endif
1601   else
1602     return close_pcsc_reader (slot);
1603 }
1604
1605 /* Enumerate all readers and return information on whether this reader
1606    is in use.  The caller should start with SLOT set to 0 and
1607    increment it with each call until an error is returned. */
1608 int
1609 apdu_enum_reader (int slot, int *used)
1610 {
1611   if (slot < 0 || slot >= MAX_READER)
1612     return SW_HOST_NO_DRIVER;
1613   *used = reader_table[slot].used;
1614   return 0;
1615 }
1616
1617 /* Do a reset for the card in reader at SLOT. */
1618 int
1619 apdu_reset (int slot)
1620 {
1621   int sw;
1622
1623   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1624     return SW_HOST_NO_DRIVER;
1625   
1626   if ((sw = lock_slot (slot)))
1627     return sw;
1628
1629   if (reader_table[slot].is_ctapi)
1630     sw = reset_ct_reader (slot);
1631 #ifdef HAVE_LIBUSB
1632   else if (reader_table[slot].is_ccid)
1633     sw = reset_ccid_reader (slot);
1634 #endif
1635 #ifdef HAVE_OPENSC
1636   else if (reader_table[slot].is_osc)
1637     sw = reset_osc_reader (slot);
1638 #endif
1639   else
1640     sw = reset_pcsc_reader (slot);
1641
1642   unlock_slot (slot);
1643   return sw;
1644 }
1645
1646
1647 unsigned char *
1648 apdu_get_atr (int slot, size_t *atrlen)
1649 {
1650   char *buf;
1651
1652   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1653     return NULL;
1654   
1655   buf = xtrymalloc (reader_table[slot].atrlen);
1656   if (!buf)
1657     return NULL;
1658   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
1659   *atrlen = reader_table[slot].atrlen;
1660   return buf;
1661 }
1662
1663   
1664     
1665 static const char *
1666 error_string (int slot, long rc)
1667 {
1668   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1669     return "[invalid slot]";
1670   if (reader_table[slot].is_ctapi)
1671     return ct_error_string (rc);
1672 #ifdef HAVE_LIBUSB
1673   else if (reader_table[slot].is_ccid)
1674     return get_ccid_error_string (rc);
1675 #endif
1676 #ifdef HAVE_OPENSC
1677   else if (reader_table[slot].is_osc)
1678     return sc_strerror (rc);
1679 #endif
1680   else
1681     return pcsc_error_string (rc);
1682 }
1683
1684
1685 /* Retrieve the status for SLOT. The function does obnly wait fot the
1686    card to become available if HANG is set to true. On success the
1687    bits in STATUS will be set to
1688
1689      bit 0 = card present and usable
1690      bit 1 = card present
1691      bit 2 = card active
1692      bit 3 = card access locked [not yet implemented]
1693
1694    For must application, tetsing bit 0 is sufficient.
1695
1696    CHANGED will receive the value of the counter tracking the number
1697    of card insertions.  This value may be used to detect a card
1698    change.
1699 */
1700 int
1701 apdu_get_status (int slot, int hang,
1702                  unsigned int *status, unsigned int *changed)
1703 {
1704   int sw;
1705   unsigned int s;
1706
1707   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1708     return SW_HOST_NO_DRIVER;
1709
1710   if ((sw = hang? lock_slot (slot) : trylock_slot (slot)))
1711     return sw;
1712
1713   if (reader_table[slot].is_ctapi)
1714     sw = ct_get_status (slot, &s);
1715 #ifdef HAVE_LIBUSB
1716   else if (reader_table[slot].is_ccid)
1717     sw = get_status_ccid (slot, &s);
1718 #endif
1719 #ifdef HAVE_OPENSC
1720   else if (reader_table[slot].is_osc)
1721     sw = osc_get_status (slot, &s);
1722 #endif
1723   else
1724     sw = pcsc_get_status (slot, &s);
1725
1726   unlock_slot (slot);
1727
1728   if (sw)
1729     return sw;
1730
1731   if (status)
1732     *status = s;
1733   if (changed)
1734     *changed = reader_table[slot].change_counter;
1735   return 0;
1736 }
1737
1738
1739 /* Dispatcher for the actual send_apdu function. Note, that this
1740    function should be called in locked state. */
1741 static int
1742 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
1743            unsigned char *buffer, size_t *buflen)
1744 {
1745   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1746     return SW_HOST_NO_DRIVER;
1747   if (reader_table[slot].is_ctapi)
1748     return ct_send_apdu (slot, apdu, apdulen, buffer, buflen);
1749 #ifdef HAVE_LIBUSB
1750   else if (reader_table[slot].is_ccid)
1751     return send_apdu_ccid (slot, apdu, apdulen, buffer, buflen);
1752 #endif
1753 #ifdef HAVE_OPENSC
1754   else if (reader_table[slot].is_osc)
1755     return osc_send_apdu (slot, apdu, apdulen, buffer, buflen);
1756 #endif
1757   else
1758     return pcsc_send_apdu (slot, apdu, apdulen, buffer, buflen);
1759 }
1760
1761 /* Send an APDU to the card in SLOT.  The APDU is created from all
1762    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
1763    for LC won't sent this field and the data field; in this case DATA
1764    must also be passed as NULL.  The return value is the status word
1765    or -1 for an invalid SLOT or other non card related error.  If
1766    RETBUF is not NULL, it will receive an allocated buffer with the
1767    returned data.  The length of that data will be put into
1768    *RETBUFLEN.  The caller is reponsible for releasing the buffer even
1769    in case of errors.  */
1770 int 
1771 apdu_send_le(int slot, int class, int ins, int p0, int p1,
1772              int lc, const char *data, int le,
1773              unsigned char **retbuf, size_t *retbuflen)
1774 {
1775 #define RESULTLEN 256
1776   unsigned char result[RESULTLEN+10]; /* 10 extra in case of bugs in
1777                                          the driver. */
1778   size_t resultlen;
1779   unsigned char apdu[5+256+1];
1780   size_t apdulen;
1781   int sw;
1782   long rc; /* we need a long here due to PC/SC. */
1783
1784   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1785     return SW_HOST_NO_DRIVER;
1786
1787   if (DBG_CARD_IO)
1788     log_debug ("send apdu: c=%02X i=%02X p0=%02X p1=%02X lc=%d le=%d\n",
1789                class, ins, p0, p1, lc, le);
1790
1791   if (lc != -1 && (lc > 255 || lc < 0))
1792     return SW_WRONG_LENGTH; 
1793   if (le != -1 && (le > 256 || le < 1))
1794     return SW_WRONG_LENGTH; 
1795   if ((!data && lc != -1) || (data && lc == -1))
1796     return SW_HOST_INV_VALUE;
1797
1798   if ((sw = lock_slot (slot)))
1799     return sw;
1800
1801   apdulen = 0;
1802   apdu[apdulen++] = class;
1803   apdu[apdulen++] = ins;
1804   apdu[apdulen++] = p0;
1805   apdu[apdulen++] = p1;
1806   if (lc != -1)
1807     {
1808       apdu[apdulen++] = lc;
1809       memcpy (apdu+apdulen, data, lc);
1810       apdulen += lc;
1811     }
1812   if (le != -1)
1813     apdu[apdulen++] = le; /* Truncation is okay becuase 0 means 256. */
1814   assert (sizeof (apdu) >= apdulen);
1815   /* As safeguard don't pass any garbage from the stack to the driver. */
1816   memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
1817   resultlen = RESULTLEN;
1818   rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
1819   if (rc || resultlen < 2)
1820     {
1821       log_error ("apdu_send_simple(%d) failed: %s\n",
1822                  slot, error_string (slot, rc));
1823       unlock_slot (slot);
1824       return SW_HOST_INCOMPLETE_CARD_RESPONSE;
1825     }
1826   sw = (result[resultlen-2] << 8) | result[resultlen-1];
1827   /* store away the returned data but strip the statusword. */
1828   resultlen -= 2;
1829   if (DBG_CARD_IO)
1830     {
1831       log_debug (" response: sw=%04X  datalen=%d\n", sw, resultlen);
1832       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
1833         log_printhex ("     dump: ", result, resultlen);
1834     }
1835
1836   if (sw == SW_SUCCESS || sw == SW_EOF_REACHED)
1837     {
1838       if (retbuf)
1839         {
1840           *retbuf = xtrymalloc (resultlen? resultlen : 1);
1841           if (!*retbuf)
1842             {
1843               unlock_slot (slot);
1844               return SW_HOST_OUT_OF_CORE;
1845             }
1846           *retbuflen = resultlen;
1847           memcpy (*retbuf, result, resultlen);
1848         }
1849     }
1850   else if ((sw & 0xff00) == SW_MORE_DATA)
1851     {
1852       unsigned char *p = NULL, *tmp;
1853       size_t bufsize = 4096;
1854
1855       /* It is likely that we need to return much more data, so we
1856          start off with a large buffer. */
1857       if (retbuf)
1858         {
1859           *retbuf = p = xtrymalloc (bufsize);
1860           if (!*retbuf)
1861             {
1862               unlock_slot (slot);
1863               return SW_HOST_OUT_OF_CORE;
1864             }
1865           assert (resultlen < bufsize);
1866           memcpy (p, result, resultlen);
1867           p += resultlen;
1868         }
1869
1870       do
1871         {
1872           int len = (sw & 0x00ff);
1873           
1874           if (DBG_CARD_IO)
1875             log_debug ("apdu_send_simple(%d): %d more bytes available\n",
1876                        slot, len);
1877           apdulen = 0;
1878           apdu[apdulen++] = class;
1879           apdu[apdulen++] = 0xC0;
1880           apdu[apdulen++] = 0;
1881           apdu[apdulen++] = 0;
1882           apdu[apdulen++] = len; 
1883           memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
1884           resultlen = RESULTLEN;
1885           rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
1886           if (rc || resultlen < 2)
1887             {
1888               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
1889                          slot, error_string (slot, rc));
1890               unlock_slot (slot);
1891               return SW_HOST_INCOMPLETE_CARD_RESPONSE;
1892             }
1893           sw = (result[resultlen-2] << 8) | result[resultlen-1];
1894           resultlen -= 2;
1895           if (DBG_CARD_IO)
1896             {
1897               log_debug ("     more: sw=%04X  datalen=%d\n", sw, resultlen);
1898               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
1899                 log_printhex ("     dump: ", result, resultlen);
1900             }
1901
1902           if ((sw & 0xff00) == SW_MORE_DATA
1903               || sw == SW_SUCCESS
1904               || sw == SW_EOF_REACHED )
1905             {
1906               if (retbuf && resultlen)
1907                 {
1908                   if (p - *retbuf + resultlen > bufsize)
1909                     {
1910                       bufsize += resultlen > 4096? resultlen: 4096;
1911                       tmp = xtryrealloc (*retbuf, bufsize);
1912                       if (!tmp)
1913                         {
1914                           unlock_slot (slot);
1915                           return SW_HOST_OUT_OF_CORE;
1916                         }
1917                       p = tmp + (p - *retbuf);
1918                       *retbuf = tmp;
1919                     }
1920                   memcpy (p, result, resultlen);
1921                   p += resultlen;
1922                 }
1923             }
1924           else
1925             log_info ("apdu_send_simple(%d) "
1926                       "got unexpected status %04X from get response\n",
1927                       slot, sw);
1928         }
1929       while ((sw & 0xff00) == SW_MORE_DATA);
1930       
1931       if (retbuf)
1932         {
1933           *retbuflen = p - *retbuf;
1934           tmp = xtryrealloc (*retbuf, *retbuflen);
1935           if (tmp)
1936             *retbuf = tmp;
1937         }
1938     }
1939
1940   unlock_slot (slot);
1941
1942   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
1943     log_printhex ("      dump: ", *retbuf, *retbuflen);
1944  
1945   return sw;
1946 #undef RESULTLEN
1947 }
1948
1949 /* Send an APDU to the card in SLOT.  The APDU is created from all
1950    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
1951    LC won't sent this field and the data field; in this case DATA must
1952    also be passed as NULL. The return value is the status word or -1
1953    for an invalid SLOT or other non card related error.  If RETBUF is
1954    not NULL, it will receive an allocated buffer with the returned
1955    data.  The length of that data will be put into *RETBUFLEN.  The
1956    caller is reponsible for releasing the buffer even in case of
1957    errors.  */
1958 int 
1959 apdu_send (int slot, int class, int ins, int p0, int p1,
1960            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
1961 {
1962   return apdu_send_le (slot, class, ins, p0, p1, lc, data, 256, 
1963                        retbuf, retbuflen);
1964 }
1965
1966 /* Send an APDU to the card in SLOT.  The APDU is created from all
1967    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
1968    LC won't sent this field and the data field; in this case DATA must
1969    also be passed as NULL. The return value is the status word or -1
1970    for an invalid SLOT or other non card related error.  No data will be
1971    returned. */
1972 int 
1973 apdu_send_simple (int slot, int class, int ins, int p0, int p1,
1974                   int lc, const char *data)
1975 {
1976   return apdu_send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL);
1977 }
1978
1979
1980
1981