1b5ebc375963cb53a2470bc7e3c580390c5b39cf
[gnupg.git] / scd / 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    full_len -= len;
926    if (full_len)
927      {
928        log_error ("pcsc_send_apdu: provided buffer too short - truncated\n");
929        err = -1; 
930      }
931    /* We need to read any rest of the response, to keep the
932       protocol runnng. */
933    while (full_len)
934      {
935        unsigned char dummybuf[128];
936
937        n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
938        if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
939          {
940            log_error ("error receiving PC/SC TRANSMIT response: %s\n",
941                       i? strerror (errno) : "premature EOF");
942            goto command_failed;
943          }
944        full_len -= n;
945      }
946
947    return err;
948
949  command_failed:
950   close (slotp->pcsc.req_fd);
951   close (slotp->pcsc.rsp_fd);
952   slotp->pcsc.req_fd = -1;
953   slotp->pcsc.rsp_fd = -1;
954   kill (slotp->pcsc.pid, SIGTERM);
955   slotp->pcsc.pid = (pid_t)(-1);
956   slotp->used = 0;
957   return -1;
958
959 #else /*!NEED_PCSC_WRAPPER*/
960
961   long err;
962   struct pcsc_io_request_s send_pci;
963   unsigned long recv_len;
964   
965   if (DBG_CARD_IO)
966     log_printhex ("  PCSC_data:", apdu, apdulen);
967
968   if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
969       send_pci.protocol = PCSC_PROTOCOL_T1;
970   else
971       send_pci.protocol = PCSC_PROTOCOL_T0;
972   send_pci.pci_len = sizeof send_pci;
973   recv_len = *buflen;
974   err = pcsc_transmit (reader_table[slot].pcsc.card,
975                        &send_pci, apdu, apdulen,
976                        NULL, buffer, &recv_len);
977   *buflen = recv_len;
978   if (err)
979     log_error ("pcsc_transmit failed: %s (0x%lx)\n",
980                pcsc_error_string (err), err);
981   
982   return err? -1:0; /* FIXME: Return appropriate error code. */
983 #endif /*!NEED_PCSC_WRAPPER*/
984 }
985
986
987 static int
988 close_pcsc_reader (int slot)
989 {
990 #ifdef NEED_PCSC_WRAPPER
991   long err;
992   reader_table_t slotp;
993   size_t len;
994   int i;
995   unsigned char msgbuf[9];
996
997   slotp = reader_table + slot;
998
999   if (slotp->pcsc.req_fd == -1 
1000       || slotp->pcsc.rsp_fd == -1 
1001       || slotp->pcsc.pid == (pid_t)(-1) )
1002     {
1003       log_error ("close_pcsc_reader: pcsc-wrapper not running\n");
1004       return 0;
1005     }
1006
1007   msgbuf[0] = 0x02; /* CLOSE command. */
1008   len = 0;
1009   msgbuf[1] = (len >> 24);
1010   msgbuf[2] = (len >> 16);
1011   msgbuf[3] = (len >>  8);
1012   msgbuf[4] = (len      );
1013   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
1014     {
1015       log_error ("error sending PC/SC CLOSE request: %s\n",
1016                  strerror (errno));
1017       goto command_failed;
1018     }
1019
1020   /* Read the response. */
1021   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1022     {
1023       log_error ("error receiving PC/SC CLOSE response: %s\n",
1024                  i? strerror (errno) : "premature EOF");
1025       goto command_failed;
1026     }
1027   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1028   if (msgbuf[0] != 0x81 || len < 4)
1029     {
1030       log_error ("invalid response header from PC/SC received\n");
1031       goto command_failed;
1032     }
1033   len -= 4; /* Already read the error code. */
1034   err = (msgbuf[5] << 24) | (msgbuf[6] << 16) | (msgbuf[7] << 8 ) | msgbuf[8];
1035   if (err)
1036     log_error ("pcsc_close failed: %s (0x%lx)\n",
1037                pcsc_error_string (err), err);
1038   
1039   /* We will the wrapper in any case - errors are merely
1040      informational. */
1041   
1042  command_failed:
1043   close (slotp->pcsc.req_fd);
1044   close (slotp->pcsc.rsp_fd);
1045   slotp->pcsc.req_fd = -1;
1046   slotp->pcsc.rsp_fd = -1;
1047   kill (slotp->pcsc.pid, SIGTERM);
1048   slotp->pcsc.pid = (pid_t)(-1);
1049   slotp->used = 0;
1050   return 0;
1051
1052 #else /*!NEED_PCSC_WRAPPER*/
1053
1054   pcsc_release_context (reader_table[slot].pcsc.context);
1055   reader_table[slot].used = 0;
1056   return 0;
1057 #endif /*!NEED_PCSC_WRAPPER*/
1058 }
1059
1060 static int
1061 reset_pcsc_reader (int slot)
1062 {
1063   return SW_HOST_NOT_SUPPORTED;
1064 }
1065
1066
1067
1068
1069 \f
1070 #ifdef HAVE_LIBUSB
1071 /* 
1072      Internal CCID driver interface.
1073  */
1074
1075 static const char *
1076 get_ccid_error_string (long err)
1077 {
1078   if (!err)
1079     return "okay";
1080   else
1081     return "unknown CCID error";
1082 }
1083
1084 static int
1085 open_ccid_reader (void)
1086 {
1087   int err;
1088   int slot;
1089   reader_table_t slotp;
1090
1091   slot = new_reader_slot ();
1092   if (slot == -1)
1093     return -1;
1094   slotp = reader_table + slot;
1095
1096   err = ccid_open_reader (&slotp->ccid.handle, 0);
1097   if (err)
1098     {
1099       slotp->used = 0;
1100       return -1;
1101     }
1102
1103   err = ccid_get_atr (slotp->ccid.handle,
1104                       slotp->atr, sizeof slotp->atr, &slotp->atrlen);
1105   if (err)
1106     {
1107       slotp->used = 0;
1108       return -1;
1109     }
1110
1111   slotp->is_ccid = 1;
1112
1113   dump_reader_status (slot); 
1114   return slot;
1115 }
1116
1117 static int
1118 close_ccid_reader (int slot)
1119 {
1120   ccid_close_reader (reader_table[slot].ccid.handle);
1121   reader_table[slot].used = 0;
1122   return 0;
1123 }                       
1124   
1125
1126 static int
1127 reset_ccid_reader (int slot)
1128 {
1129   int err;
1130   reader_table_t slotp = reader_table + slot;
1131   unsigned char atr[33];
1132   size_t atrlen;
1133
1134   err = ccid_get_atr (slotp->ccid.handle, atr, sizeof atr, &atrlen);
1135   if (err)
1136     return -1;
1137   /* If the reset was successful, update the ATR. */
1138   assert (sizeof slotp->atr >= sizeof atr);
1139   slotp->atrlen = atrlen;
1140   memcpy (slotp->atr, atr, atrlen);
1141   dump_reader_status (slot); 
1142   return 0;
1143 }                       
1144   
1145
1146 static int
1147 get_status_ccid (int slot, unsigned int *status)
1148 {
1149   int rc;
1150   int bits;
1151
1152   rc = ccid_slot_status (reader_table[slot].ccid.handle, &bits);
1153   if (rc)
1154     return -1;
1155
1156   if (bits == 0)
1157     *status = 1|2|4;
1158   else if (bits == 1)
1159     *status = 2;
1160   else 
1161     *status = 0;
1162
1163   return 0;
1164 }
1165
1166
1167 /* Actually send the APDU of length APDULEN to SLOT and return a
1168    maximum of *BUFLEN data in BUFFER, the actual returned size will be
1169    set to BUFLEN.  Returns: Internal CCID driver error code. */
1170 static int
1171 send_apdu_ccid (int slot, unsigned char *apdu, size_t apdulen,
1172                 unsigned char *buffer, size_t *buflen)
1173 {
1174   long err;
1175   size_t maxbuflen;
1176
1177   if (DBG_CARD_IO)
1178     log_printhex ("  APDU_data:", apdu, apdulen);
1179
1180   maxbuflen = *buflen;
1181   err = ccid_transceive (reader_table[slot].ccid.handle,
1182                          apdu, apdulen,
1183                          buffer, maxbuflen, buflen);
1184   if (err)
1185     log_error ("ccid_transceive failed: (0x%lx)\n",
1186                err);
1187   
1188   return err? -1:0; /* FIXME: Return appropriate error code. */
1189 }
1190
1191 #endif /* HAVE_LIBUSB */
1192
1193
1194 \f
1195 #ifdef HAVE_OPENSC
1196 /* 
1197      OpenSC Interface.
1198
1199      This uses the OpenSC primitives to send APDUs.  We need this
1200      because we can't mix OpenSC and native (i.e. ctAPI or PC/SC)
1201      access to a card for resource conflict reasons.
1202  */
1203
1204 static int
1205 open_osc_reader (int portno)
1206 {
1207   int err;
1208   int slot;
1209   reader_table_t slotp;
1210
1211   slot = new_reader_slot ();
1212   if (slot == -1)
1213     return -1;
1214   slotp = reader_table + slot;
1215
1216   err = sc_establish_context (&slotp->osc.ctx, "scdaemon");
1217   if (err)
1218     {
1219       log_error ("failed to establish SC context: %s\n", sc_strerror (err));
1220       slotp->used = 0;
1221       return -1;
1222     }
1223   if (portno < 0 || portno >= slotp->osc.ctx->reader_count)
1224     {
1225       log_error ("no card reader available\n");
1226       sc_release_context (slotp->osc.ctx);
1227       slotp->used = 0;
1228       return -1;
1229     }
1230
1231   /* Redirect to our logging facility. */
1232   slotp->osc.ctx->error_file = log_get_stream ();
1233   slotp->osc.ctx->debug = opt.debug_sc;
1234   slotp->osc.ctx->debug_file = log_get_stream ();
1235
1236   if (sc_detect_card_presence (slotp->osc.ctx->reader[portno], 0) != 1)
1237     {
1238       log_error ("no card present\n");
1239       sc_release_context (slotp->osc.ctx);
1240       slotp->used = 0;
1241       return -1;
1242     }
1243   
1244   /* We want the standard ISO driver. */
1245   /*FIXME: OpenSC does not like "iso7816", so we use EMV for now. */
1246   err = sc_set_card_driver(slotp->osc.ctx, "emv");
1247   if (err)
1248     {
1249       log_error ("failed to select the iso7816 driver: %s\n",
1250                  sc_strerror (err));
1251       sc_release_context (slotp->osc.ctx);
1252       slotp->used = 0;
1253       return -1;
1254     }
1255
1256   /* Now connect the card and hope that OpenSC won't try to be too
1257      smart. */
1258   err = sc_connect_card (slotp->osc.ctx->reader[portno], 0,
1259                          &slotp->osc.scard);
1260   if (err)
1261     {
1262       log_error ("failed to connect card in reader %d: %s\n",
1263                  portno, sc_strerror (err));
1264       sc_release_context (slotp->osc.ctx);
1265       slotp->used = 0;
1266       return -1;
1267     }
1268   if (opt.verbose)
1269     log_info ("connected to card in opensc reader %d using driver `%s'\n",
1270               portno, slotp->osc.scard->driver->name);
1271
1272   err = sc_lock (slotp->osc.scard);
1273   if (err)
1274     {
1275       log_error ("can't lock card in reader %d: %s\n",
1276                  portno, sc_strerror (err));
1277       sc_disconnect_card (slotp->osc.scard, 0);
1278       sc_release_context (slotp->osc.ctx);
1279       slotp->used = 0;
1280       return -1;
1281     }
1282
1283   if (slotp->osc.scard->atr_len >= DIM (slotp->atr))
1284     log_bug ("ATR returned by opensc is too large\n");
1285   slotp->atrlen = slotp->osc.scard->atr_len;
1286   memcpy (slotp->atr, slotp->osc.scard->atr, slotp->atrlen);
1287
1288   slotp->is_osc = 1;
1289
1290   dump_reader_status (slot); 
1291   return slot;
1292 }
1293
1294
1295 static int
1296 close_osc_reader (int slot)
1297 {
1298   /* FIXME: Implement. */
1299   reader_table[slot].used = 0;
1300   return 0;
1301 }
1302
1303 static int
1304 reset_osc_reader (int slot)
1305 {
1306   return SW_HOST_NOT_SUPPORTED;
1307 }
1308
1309
1310 static int
1311 ocsc_get_status (int slot, unsigned int *status)
1312 {
1313   return SW_HOST_NOT_SUPPORTED;
1314 }
1315
1316
1317 /* Actually send the APDU of length APDULEN to SLOT and return a
1318    maximum of *BUFLEN data in BUFFER, the actual returned size will be
1319    set to BUFLEN.  Returns: OpenSC error code. */
1320 static int
1321 osc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
1322                 unsigned char *buffer, size_t *buflen)
1323 {
1324   long err;
1325   struct sc_apdu a;
1326   unsigned char data[SC_MAX_APDU_BUFFER_SIZE];
1327   unsigned char result[SC_MAX_APDU_BUFFER_SIZE];
1328
1329   if (DBG_CARD_IO)
1330     log_printhex ("  APDU_data:", apdu, apdulen);
1331
1332   if (apdulen < 4)
1333     {
1334       log_error ("osc_send_apdu: APDU is too short\n");
1335       return SC_ERROR_CMD_TOO_SHORT;
1336     }
1337
1338   memset(&a, 0, sizeof a);
1339   a.cla = *apdu++;
1340   a.ins = *apdu++;
1341   a.p1 = *apdu++;
1342   a.p2 = *apdu++;
1343   apdulen -= 4;
1344
1345   if (!apdulen)
1346     a.cse = SC_APDU_CASE_1;
1347   else if (apdulen == 1) 
1348     {
1349       a.le = *apdu? *apdu : 256;
1350       apdu++; apdulen--;
1351       a.cse = SC_APDU_CASE_2_SHORT;
1352     }
1353   else
1354     {
1355       a.lc = *apdu++; apdulen--;
1356       if (apdulen < a.lc)
1357         {
1358           log_error ("osc_send_apdu: APDU shorter than specified in Lc\n");
1359           return SC_ERROR_CMD_TOO_SHORT;
1360
1361         }
1362       memcpy(data, apdu, a.lc);
1363       apdu += a.lc; apdulen -= a.lc;
1364
1365       a.data = data;
1366       a.datalen = a.lc;
1367       
1368       if (!apdulen)
1369         a.cse = SC_APDU_CASE_3_SHORT;
1370       else
1371         {
1372           a.le = *apdu? *apdu : 256;
1373           apdu++; apdulen--;
1374           if (apdulen)
1375             {
1376               log_error ("osc_send_apdu: APDU larger than specified\n");
1377               return SC_ERROR_CMD_TOO_LONG;
1378             }
1379           a.cse = SC_APDU_CASE_4_SHORT;
1380         }
1381     }
1382
1383   a.resp = result;
1384   a.resplen = DIM(result);
1385
1386   err = sc_transmit_apdu (reader_table[slot].osc.scard, &a);
1387   if (err)
1388     {
1389       log_error ("sc_apdu_transmit failed: %s\n", sc_strerror (err));
1390       return err;
1391     }
1392
1393   if (*buflen < 2 || a.resplen > *buflen - 2)
1394     {
1395       log_error ("osc_send_apdu: provided buffer too short to store result\n");
1396       return SC_ERROR_BUFFER_TOO_SMALL;
1397     }
1398   memcpy (buffer, a.resp, a.resplen);
1399   buffer[a.resplen] = a.sw1;
1400   buffer[a.resplen+1] = a.sw2;
1401   *buflen = a.resplen + 2;
1402   return 0;
1403 }
1404
1405 #endif /* HAVE_OPENSC */
1406
1407
1408 \f
1409 /* 
1410        Driver Access
1411  */
1412
1413
1414 static int
1415 lock_slot (int slot)
1416 {
1417 #ifdef USE_GNU_PTH
1418   if (!pth_mutex_acquire (&reader_table[slot].lock, 0, NULL))
1419     {
1420       log_error ("failed to acquire apdu lock: %s\n", strerror (errno));
1421       return SW_HOST_LOCKING_FAILED;
1422     }
1423 #endif /*USE_GNU_PTH*/
1424   return 0;
1425 }
1426
1427 static int
1428 trylock_slot (int slot)
1429 {
1430 #ifdef USE_GNU_PTH
1431   if (!pth_mutex_acquire (&reader_table[slot].lock, TRUE, NULL))
1432     {
1433       if (errno == EBUSY)
1434         return SW_HOST_BUSY;
1435       log_error ("failed to acquire apdu lock: %s\n", strerror (errno));
1436       return SW_HOST_LOCKING_FAILED;
1437     }
1438 #endif /*USE_GNU_PTH*/
1439   return 0;
1440 }
1441
1442 static void
1443 unlock_slot (int slot)
1444 {
1445 #ifdef USE_GNU_PTH
1446   if (!pth_mutex_release (&reader_table[slot].lock))
1447     log_error ("failed to release apdu lock: %s\n", strerror (errno));
1448 #endif /*USE_GNU_PTH*/
1449 }
1450
1451
1452 /* Open the reader and return an internal slot number or -1 on
1453    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
1454    the first USB reader.  For PC/SC the first listed reader).  If
1455    OpenSC support is compiled in, we first try to use OpenSC. */
1456 int
1457 apdu_open_reader (const char *portstr)
1458 {
1459   static int pcsc_api_loaded, ct_api_loaded;
1460
1461 #ifdef HAVE_LIBUSB
1462   if (!opt.disable_ccid)
1463     {
1464       int slot;
1465
1466       slot = open_ccid_reader ();
1467       if (slot != -1)
1468         return slot; /* got one */
1469     }
1470 #endif /* HAVE_LIBUSB */
1471
1472 #ifdef HAVE_OPENSC
1473   if (!opt.disable_opensc)
1474     {
1475       int port = portstr? atoi (portstr) : 0;
1476
1477       return open_osc_reader (port);
1478     }
1479 #endif /* HAVE_OPENSC */  
1480
1481
1482   if (opt.ctapi_driver && *opt.ctapi_driver)
1483     {
1484       int port = portstr? atoi (portstr) : 32768;
1485
1486       if (!ct_api_loaded)
1487         {
1488           void *handle;
1489           
1490           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
1491           if (!handle)
1492             {
1493               log_error ("apdu_open_reader: failed to open driver: %s\n",
1494                          dlerror ());
1495               return -1;
1496             }
1497           CT_init = dlsym (handle, "CT_init");
1498           CT_data = dlsym (handle, "CT_data");
1499           CT_close = dlsym (handle, "CT_close");
1500           if (!CT_init || !CT_data || !CT_close)
1501             {
1502               log_error ("apdu_open_reader: invalid CT-API driver\n");
1503               dlclose (handle);
1504               return -1;
1505             }
1506           ct_api_loaded = 1;
1507         }
1508       return open_ct_reader (port);
1509     }
1510
1511   
1512   /* No ctAPI configured, so lets try the PC/SC API */
1513   if (!pcsc_api_loaded)
1514     {
1515 #ifndef NEED_PCSC_WRAPPER
1516       void *handle;
1517
1518       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
1519       if (!handle)
1520         {
1521           log_error ("apdu_open_reader: failed to open driver `%s': %s\n",
1522                      opt.pcsc_driver, dlerror ());
1523           return -1;
1524         }
1525
1526       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
1527       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
1528       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
1529 #ifdef _WIN32
1530       if (!pcsc_list_readers)
1531         pcsc_list_readers    = dlsym (handle, "SCardListReadersA");
1532 #endif
1533       pcsc_connect           = dlsym (handle, "SCardConnect");
1534 #ifdef _WIN32
1535       if (!pcsc_connect)
1536         pcsc_connect         = dlsym (handle, "SCardConnectA");
1537 #endif
1538       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
1539       pcsc_status            = dlsym (handle, "SCardStatus");
1540 #ifdef _WIN32
1541       if (!pcsc_status)
1542         pcsc_status          = dlsym (handle, "SCardStatusA");
1543 #endif
1544       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
1545       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
1546       pcsc_transmit          = dlsym (handle, "SCardTransmit");
1547       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
1548
1549       if (!pcsc_establish_context
1550           || !pcsc_release_context  
1551           || !pcsc_list_readers     
1552           || !pcsc_connect          
1553           || !pcsc_disconnect
1554           || !pcsc_status
1555           || !pcsc_begin_transaction
1556           || !pcsc_end_transaction
1557           || !pcsc_transmit         
1558           /* || !pcsc_set_timeout */)
1559         {
1560           /* Note that set_timeout is currently not used and also not
1561              available under Windows. */
1562           log_error ("apdu_open_reader: invalid PC/SC driver "
1563                      "(%d%d%d%d%d%d%d%d%d%d)\n",
1564                      !!pcsc_establish_context,
1565                      !!pcsc_release_context,  
1566                      !!pcsc_list_readers,     
1567                      !!pcsc_connect,          
1568                      !!pcsc_disconnect,
1569                      !!pcsc_status,
1570                      !!pcsc_begin_transaction,
1571                      !!pcsc_end_transaction,
1572                      !!pcsc_transmit,         
1573                      !!pcsc_set_timeout );
1574           dlclose (handle);
1575           return -1;
1576         }
1577 #endif /*!NEED_PCSC_WRAPPER*/  
1578       pcsc_api_loaded = 1;
1579     }
1580
1581   return open_pcsc_reader (portstr);
1582 }
1583
1584
1585 int
1586 apdu_close_reader (int slot)
1587 {
1588   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1589     return SW_HOST_NO_DRIVER;
1590   if (reader_table[slot].is_ctapi)
1591     return close_ct_reader (slot);
1592 #ifdef HAVE_LIBUSB
1593   else if (reader_table[slot].is_ccid)
1594     return close_ccid_reader (slot);
1595 #endif
1596 #ifdef HAVE_OPENSC
1597   else if (reader_table[slot].is_osc)
1598     return close_osc_reader (slot);
1599 #endif
1600   else
1601     return close_pcsc_reader (slot);
1602 }
1603
1604 /* Enumerate all readers and return information on whether this reader
1605    is in use.  The caller should start with SLOT set to 0 and
1606    increment it with each call until an error is returned. */
1607 int
1608 apdu_enum_reader (int slot, int *used)
1609 {
1610   if (slot < 0 || slot >= MAX_READER)
1611     return SW_HOST_NO_DRIVER;
1612   *used = reader_table[slot].used;
1613   return 0;
1614 }
1615
1616 /* Do a reset for the card in reader at SLOT. */
1617 int
1618 apdu_reset (int slot)
1619 {
1620   int sw;
1621
1622   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1623     return SW_HOST_NO_DRIVER;
1624   
1625   if ((sw = lock_slot (slot)))
1626     return sw;
1627
1628   if (reader_table[slot].is_ctapi)
1629     sw = reset_ct_reader (slot);
1630 #ifdef HAVE_LIBUSB
1631   else if (reader_table[slot].is_ccid)
1632     sw = reset_ccid_reader (slot);
1633 #endif
1634 #ifdef HAVE_OPENSC
1635   else if (reader_table[slot].is_osc)
1636     sw = reset_osc_reader (slot);
1637 #endif
1638   else
1639     sw = reset_pcsc_reader (slot);
1640
1641   unlock_slot (slot);
1642   return sw;
1643 }
1644
1645
1646 unsigned char *
1647 apdu_get_atr (int slot, size_t *atrlen)
1648 {
1649   char *buf;
1650
1651   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1652     return NULL;
1653   
1654   buf = xtrymalloc (reader_table[slot].atrlen);
1655   if (!buf)
1656     return NULL;
1657   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
1658   *atrlen = reader_table[slot].atrlen;
1659   return buf;
1660 }
1661
1662   
1663     
1664 static const char *
1665 error_string (int slot, long rc)
1666 {
1667   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1668     return "[invalid slot]";
1669   if (reader_table[slot].is_ctapi)
1670     return ct_error_string (rc);
1671 #ifdef HAVE_LIBUSB
1672   else if (reader_table[slot].is_ccid)
1673     return get_ccid_error_string (rc);
1674 #endif
1675 #ifdef HAVE_OPENSC
1676   else if (reader_table[slot].is_osc)
1677     return sc_strerror (rc);
1678 #endif
1679   else
1680     return pcsc_error_string (rc);
1681 }
1682
1683
1684 /* Retrieve the status for SLOT. The function does obnly wait fot the
1685    card to become available if HANG is set to true. On success the
1686    bits in STATUS will be set to
1687
1688      bit 0 = card present and usable
1689      bit 1 = card present
1690      bit 2 = card active
1691      bit 3 = card access locked [not yet implemented]
1692
1693    For must application, tetsing bit 0 is sufficient.
1694
1695    CHANGED will receive the value of the counter tracking the number
1696    of card insertions.  This value may be used to detect a card
1697    change.
1698 */
1699 int
1700 apdu_get_status (int slot, int hang,
1701                  unsigned int *status, unsigned int *changed)
1702 {
1703   int sw;
1704   unsigned int s;
1705
1706   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1707     return SW_HOST_NO_DRIVER;
1708
1709   if ((sw = hang? lock_slot (slot) : trylock_slot (slot)))
1710     return sw;
1711
1712   if (reader_table[slot].is_ctapi)
1713     sw = ct_get_status (slot, &s);
1714 #ifdef HAVE_LIBUSB
1715   else if (reader_table[slot].is_ccid)
1716     sw = get_status_ccid (slot, &s);
1717 #endif
1718 #ifdef HAVE_OPENSC
1719   else if (reader_table[slot].is_osc)
1720     sw = osc_get_status (slot, &s);
1721 #endif
1722   else
1723     sw = pcsc_get_status (slot, &s);
1724
1725   unlock_slot (slot);
1726
1727   if (sw)
1728     return sw;
1729
1730   if (status)
1731     *status = s;
1732   if (changed)
1733     *changed = reader_table[slot].change_counter;
1734   return 0;
1735 }
1736
1737
1738 /* Dispatcher for the actual send_apdu function. Note, that this
1739    function should be called in locked state. */
1740 static int
1741 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
1742            unsigned char *buffer, size_t *buflen)
1743 {
1744   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1745     return SW_HOST_NO_DRIVER;
1746   if (reader_table[slot].is_ctapi)
1747     return ct_send_apdu (slot, apdu, apdulen, buffer, buflen);
1748 #ifdef HAVE_LIBUSB
1749   else if (reader_table[slot].is_ccid)
1750     return send_apdu_ccid (slot, apdu, apdulen, buffer, buflen);
1751 #endif
1752 #ifdef HAVE_OPENSC
1753   else if (reader_table[slot].is_osc)
1754     return osc_send_apdu (slot, apdu, apdulen, buffer, buflen);
1755 #endif
1756   else
1757     return pcsc_send_apdu (slot, apdu, apdulen, buffer, buflen);
1758 }
1759
1760 /* Send an APDU to the card in SLOT.  The APDU is created from all
1761    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
1762    for LC won't sent this field and the data field; in this case DATA
1763    must also be passed as NULL.  The return value is the status word
1764    or -1 for an invalid SLOT or other non card related error.  If
1765    RETBUF is not NULL, it will receive an allocated buffer with the
1766    returned data.  The length of that data will be put into
1767    *RETBUFLEN.  The caller is reponsible for releasing the buffer even
1768    in case of errors.  */
1769 int 
1770 apdu_send_le(int slot, int class, int ins, int p0, int p1,
1771              int lc, const char *data, int le,
1772              unsigned char **retbuf, size_t *retbuflen)
1773 {
1774   unsigned char result[256+10]; /* 10 extra in case of bugs in the driver. */
1775   size_t resultlen = 256;
1776   unsigned char apdu[5+256+1];
1777   size_t apdulen;
1778   int sw;
1779   long rc; /* we need a long here due to PC/SC. */
1780
1781   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1782     return SW_HOST_NO_DRIVER;
1783
1784   if (DBG_CARD_IO)
1785     log_debug ("send apdu: c=%02X i=%02X p0=%02X p1=%02X lc=%d le=%d\n",
1786                class, ins, p0, p1, lc, le);
1787
1788   if (lc != -1 && (lc > 255 || lc < 0))
1789     return SW_WRONG_LENGTH; 
1790   if (le != -1 && (le > 256 || le < 1))
1791     return SW_WRONG_LENGTH; 
1792   if ((!data && lc != -1) || (data && lc == -1))
1793     return SW_HOST_INV_VALUE;
1794
1795   if ((sw = lock_slot (slot)))
1796     return sw;
1797
1798   apdulen = 0;
1799   apdu[apdulen++] = class;
1800   apdu[apdulen++] = ins;
1801   apdu[apdulen++] = p0;
1802   apdu[apdulen++] = p1;
1803   if (lc != -1)
1804     {
1805       apdu[apdulen++] = lc;
1806       memcpy (apdu+apdulen, data, lc);
1807       apdulen += lc;
1808     }
1809   if (le != -1)
1810     apdu[apdulen++] = le; /* Truncation is okay becuase 0 means 256. */
1811   assert (sizeof (apdu) >= apdulen);
1812   /* As safeguard don't pass any garbage from the stack to the driver. */
1813   memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
1814   rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
1815   if (rc || resultlen < 2)
1816     {
1817       log_error ("apdu_send_simple(%d) failed: %s\n",
1818                  slot, error_string (slot, rc));
1819       unlock_slot (slot);
1820       return SW_HOST_INCOMPLETE_CARD_RESPONSE;
1821     }
1822   sw = (result[resultlen-2] << 8) | result[resultlen-1];
1823   /* store away the returned data but strip the statusword. */
1824   resultlen -= 2;
1825   if (DBG_CARD_IO)
1826     {
1827       log_debug (" response: sw=%04X  datalen=%d\n", sw, resultlen);
1828       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
1829         log_printhex ("     dump: ", result, resultlen);
1830     }
1831
1832   if (sw == SW_SUCCESS || sw == SW_EOF_REACHED)
1833     {
1834       if (retbuf)
1835         {
1836           *retbuf = xtrymalloc (resultlen? resultlen : 1);
1837           if (!*retbuf)
1838             {
1839               unlock_slot (slot);
1840               return SW_HOST_OUT_OF_CORE;
1841             }
1842           *retbuflen = resultlen;
1843           memcpy (*retbuf, result, resultlen);
1844         }
1845     }
1846   else if ((sw & 0xff00) == SW_MORE_DATA)
1847     {
1848       unsigned char *p = NULL, *tmp;
1849       size_t bufsize = 4096;
1850
1851       /* It is likely that we need to return much more data, so we
1852          start off with a large buffer. */
1853       if (retbuf)
1854         {
1855           *retbuf = p = xtrymalloc (bufsize);
1856           if (!*retbuf)
1857             {
1858               unlock_slot (slot);
1859               return SW_HOST_OUT_OF_CORE;
1860             }
1861           assert (resultlen < bufsize);
1862           memcpy (p, result, resultlen);
1863           p += resultlen;
1864         }
1865
1866       do
1867         {
1868           int len = (sw & 0x00ff);
1869           
1870           log_debug ("apdu_send_simple(%d): %d more bytes available\n",
1871                      slot, len);
1872           apdulen = 0;
1873           apdu[apdulen++] = class;
1874           apdu[apdulen++] = 0xC0;
1875           apdu[apdulen++] = 0;
1876           apdu[apdulen++] = 0;
1877           apdu[apdulen++] = len; 
1878           memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
1879           rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
1880           if (rc || resultlen < 2)
1881             {
1882               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
1883                          slot, error_string (slot, rc));
1884               unlock_slot (slot);
1885               return SW_HOST_INCOMPLETE_CARD_RESPONSE;
1886             }
1887           sw = (result[resultlen-2] << 8) | result[resultlen-1];
1888           resultlen -= 2;
1889           if (DBG_CARD_IO)
1890             {
1891               log_debug ("     more: sw=%04X  datalen=%d\n", sw, resultlen);
1892               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
1893                 log_printhex ("     dump: ", result, resultlen);
1894             }
1895
1896           if ((sw & 0xff00) == SW_MORE_DATA || sw == SW_SUCCESS)
1897             {
1898               if (retbuf)
1899                 {
1900                   if (p - *retbuf + resultlen > bufsize)
1901                     {
1902                       bufsize += resultlen > 4096? resultlen: 4096;
1903                       tmp = xtryrealloc (*retbuf, bufsize);
1904                       if (!tmp)
1905                         {
1906                           unlock_slot (slot);
1907                           return SW_HOST_OUT_OF_CORE;
1908                         }
1909                       p = tmp + (p - *retbuf);
1910                       *retbuf = tmp;
1911                     }
1912                   memcpy (p, result, resultlen);
1913                   p += resultlen;
1914                 }
1915             }
1916           else
1917             log_info ("apdu_send_simple(%d) "
1918                       "got unexpected status %04X from get response\n",
1919                       slot, sw);
1920         }
1921       while ((sw & 0xff00) == SW_MORE_DATA);
1922       
1923       if (retbuf)
1924         {
1925           *retbuflen = p - *retbuf;
1926           tmp = xtryrealloc (*retbuf, *retbuflen);
1927           if (tmp)
1928             *retbuf = tmp;
1929         }
1930     }
1931
1932   unlock_slot (slot);
1933
1934   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
1935     log_printhex ("      dump: ", *retbuf, *retbuflen);
1936  
1937   return sw;
1938 }
1939
1940 /* Send an APDU to the card in SLOT.  The APDU is created from all
1941    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
1942    LC won't sent this field and the data field; in this case DATA must
1943    also be passed as NULL. The return value is the status word or -1
1944    for an invalid SLOT or other non card related error.  If RETBUF is
1945    not NULL, it will receive an allocated buffer with the returned
1946    data.  The length of that data will be put into *RETBUFLEN.  The
1947    caller is reponsible for releasing the buffer even in case of
1948    errors.  */
1949 int 
1950 apdu_send (int slot, int class, int ins, int p0, int p1,
1951            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
1952 {
1953   return apdu_send_le (slot, class, ins, p0, p1, lc, data, 256, 
1954                        retbuf, retbuflen);
1955 }
1956
1957 /* Send an APDU to the card in SLOT.  The APDU is created from all
1958    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
1959    LC won't sent this field and the data field; in this case DATA must
1960    also be passed as NULL. The return value is the status word or -1
1961    for an invalid SLOT or other non card related error.  No data will be
1962    returned. */
1963 int 
1964 apdu_send_simple (int slot, int class, int ins, int p0, int p1,
1965                   int lc, const char *data)
1966 {
1967   return apdu_send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL);
1968 }
1969
1970
1971
1972