* cardglue.c (open_card): Use shutdown code if possible.
[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 #include <signal.h>
28 #ifdef USE_GNU_PTH
29 # include <pth.h>
30 # include <unistd.h>
31 # include <fcntl.h>
32 #endif
33 #ifdef HAVE_OPENSC
34 # include <opensc/opensc.h>
35 # ifdef USE_GNU_PTH
36 # undef USE_GNU_PTH
37 # endif
38 #endif
39
40 /* If requested include the definitions for the remote APDU protocol
41    code. */
42 #ifdef USE_G10CODE_RAPDU
43 #include "rapdu.h"
44 #endif /*USE_G10CODE_RAPDU*/
45
46 #if defined(GNUPG_SCD_MAIN_HEADER)
47 #include GNUPG_SCD_MAIN_HEADER
48 #elif GNUPG_MAJOR_VERSION == 1
49 /* This is used with GnuPG version < 1.9.  The code has been source
50    copied from the current GnuPG >= 1.9  and is maintained over
51    there. */
52 #include "options.h"
53 #include "errors.h"
54 #include "memory.h"
55 #include "util.h"
56 #include "i18n.h"
57 #include "cardglue.h"
58 #else /* GNUPG_MAJOR_VERSION != 1 */
59 #include "scdaemon.h"
60 #endif /* GNUPG_MAJOR_VERSION != 1 */
61
62 #include "apdu.h"
63 #include "dynload.h"
64 #include "ccid-driver.h"
65
66 #ifdef USE_GNU_PTH
67 #define NEED_PCSC_WRAPPER 1
68 #endif
69
70
71 #define MAX_READER 4 /* Number of readers we support concurrently. */
72
73
74 #ifdef _WIN32
75 #define DLSTDCALL __stdcall
76 #else
77 #define DLSTDCALL
78 #endif
79
80 #ifdef _POSIX_OPEN_MAX
81 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
82 #else
83 #define MAX_OPEN_FDS 20
84 #endif
85
86
87 /* A structure to collect information pertaining to one reader
88    slot. */
89 struct reader_table_s {
90   int used;            /* True if slot is used. */
91   unsigned short port; /* Port number:  0 = unused, 1 - dev/tty */
92
93   /* Function pointers intialized to the various backends.  */
94   int (*close_reader)(int);
95   int (*shutdown_reader)(int);
96   int (*reset_reader)(int);
97   int (*get_status_reader)(int, unsigned int *);
98   int (*send_apdu_reader)(int,unsigned char *,size_t,
99                           unsigned char *, size_t *);
100   void (*dump_status_reader)(int);
101
102   struct {
103     ccid_driver_t handle;
104   } ccid;
105   struct {
106     unsigned long context;
107     unsigned long card;
108     unsigned long protocol;
109 #ifdef NEED_PCSC_WRAPPER
110     int req_fd;
111     int rsp_fd;
112     pid_t pid;
113 #endif /*NEED_PCSC_WRAPPER*/
114   } pcsc;
115 #ifdef HAVE_OPENSC
116   struct {
117     struct sc_context *ctx;
118     struct sc_card *scard;
119   } osc;
120 #endif /*HAVE_OPENSC*/
121 #ifdef USE_G10CODE_RAPDU
122   struct {
123     rapdu_t handle;
124   } rapdu;
125 #endif /*USE_G10CODE_RAPDU*/
126   int status;
127   unsigned char atr[33];
128   size_t atrlen;           /* A zero length indicates that the ATR has
129                               not yet been read; i.e. the card is not
130                               ready for use. */
131   unsigned int change_counter;
132 #ifdef USE_GNU_PTH
133   int lock_initialized;
134   pth_mutex_t lock;
135 #endif
136 };
137 typedef struct reader_table_s *reader_table_t;
138
139 /* A global table to keep track of active readers. */
140 static struct reader_table_s reader_table[MAX_READER];
141
142
143 /* ct API function pointer. */
144 static char (* DLSTDCALL CT_init) (unsigned short ctn, unsigned short Pn);
145 static char (* DLSTDCALL CT_data) (unsigned short ctn, unsigned char *dad,
146                                    unsigned char *sad, unsigned short lc,
147                                    unsigned char *cmd, unsigned short *lr,
148                                    unsigned char *rsp);
149 static char (* DLSTDCALL CT_close) (unsigned short ctn);
150
151 /* PC/SC constants and function pointer. */
152 #define PCSC_SCOPE_USER      0 
153 #define PCSC_SCOPE_TERMINAL  1 
154 #define PCSC_SCOPE_SYSTEM    2 
155 #define PCSC_SCOPE_GLOBAL    3 
156
157 #define PCSC_PROTOCOL_T0     1 
158 #define PCSC_PROTOCOL_T1     2 
159 #define PCSC_PROTOCOL_RAW    4 
160
161 #define PCSC_SHARE_EXCLUSIVE 1
162 #define PCSC_SHARE_SHARED    2
163 #define PCSC_SHARE_DIRECT    3
164
165 #define PCSC_LEAVE_CARD      0
166 #define PCSC_RESET_CARD      1
167 #define PCSC_UNPOWER_CARD    2
168 #define PCSC_EJECT_CARD      3
169
170 struct pcsc_io_request_s {
171   unsigned long protocol; 
172   unsigned long pci_len;
173 };
174
175 typedef struct pcsc_io_request_s *pcsc_io_request_t;
176
177 long (* DLSTDCALL pcsc_establish_context) (unsigned long scope,
178                                            const void *reserved1,
179                                            const void *reserved2,
180                                            unsigned long *r_context);
181 long (* DLSTDCALL pcsc_release_context) (unsigned long context);
182 long (* DLSTDCALL pcsc_list_readers) (unsigned long context,
183                                       const char *groups,
184                                       char *readers, unsigned long*readerslen);
185 long (* DLSTDCALL pcsc_connect) (unsigned long context,
186                                  const char *reader,
187                                  unsigned long share_mode,
188                                  unsigned long preferred_protocols,
189                                  unsigned long *r_card,
190                                  unsigned long *r_active_protocol);
191 long (* DLSTDCALL pcsc_disconnect) (unsigned long card,
192                                     unsigned long disposition);
193 long (* DLSTDCALL pcsc_status) (unsigned long card,
194                                 char *reader, unsigned long *readerlen,
195                                 unsigned long *r_state,
196                                 unsigned long *r_protocol,
197                                 unsigned char *atr, unsigned long *atrlen);
198 long (* DLSTDCALL pcsc_begin_transaction) (unsigned long card);
199 long (* DLSTDCALL pcsc_end_transaction) (unsigned long card);
200 long (* DLSTDCALL pcsc_transmit) (unsigned long card,
201                                   const pcsc_io_request_t send_pci,
202                                   const unsigned char *send_buffer,
203                                   unsigned long send_len,
204                                   pcsc_io_request_t recv_pci,
205                                   unsigned char *recv_buffer,
206                                   unsigned long *recv_len);
207 long (* DLSTDCALL pcsc_set_timeout) (unsigned long context,
208                                      unsigned long timeout);
209
210
211
212
213 \f
214 /* 
215       Helper
216  */
217  
218
219 /* Find an unused reader slot for PORTSTR and put it into the reader
220    table.  Return -1 on error or the index into the reader table. */
221 static int 
222 new_reader_slot (void)    
223 {
224   int i, reader = -1;
225
226   for (i=0; i < MAX_READER; i++)
227     {
228       if (!reader_table[i].used && reader == -1)
229         reader = i;
230     }
231   if (reader == -1)
232     {
233       log_error ("new_reader_slot: out of slots\n");
234       return -1;
235     }
236 #ifdef USE_GNU_PTH
237   if (!reader_table[reader].lock_initialized)
238     {
239       if (!pth_mutex_init (&reader_table[reader].lock))
240         {
241           log_error ("error initializing mutex: %s\n", strerror (errno));
242           return -1;
243         }
244       reader_table[reader].lock_initialized = 1;
245     }
246 #endif /*USE_GNU_PTH*/
247   reader_table[reader].close_reader = NULL;
248   reader_table[reader].shutdown_reader = NULL;
249   reader_table[reader].reset_reader = NULL;
250   reader_table[reader].get_status_reader = NULL;
251   reader_table[reader].send_apdu_reader = NULL;
252   reader_table[reader].dump_status_reader = NULL;
253
254   reader_table[reader].used = 1;
255 #ifdef NEED_PCSC_WRAPPER
256   reader_table[reader].pcsc.req_fd = -1;
257   reader_table[reader].pcsc.rsp_fd = -1;
258   reader_table[reader].pcsc.pid = (pid_t)(-1);
259 #endif
260   return reader;
261 }
262
263
264 static void
265 dump_reader_status (int slot)
266 {
267   if (!opt.verbose)
268     return;
269
270   if (reader_table[slot].dump_status_reader)
271     reader_table[slot].dump_status_reader (slot);
272
273   if (reader_table[slot].status != -1
274       && reader_table[slot].atrlen)
275     {
276       log_info ("slot %d: ATR=", slot);
277       log_printhex ("", reader_table[slot].atr, reader_table[slot].atrlen);
278     }
279 }
280
281
282
283 static const char *
284 host_sw_string (long err)
285 {
286   switch (err)
287     {
288     case 0: return "okay";
289     case SW_HOST_OUT_OF_CORE: return "out of core";
290     case SW_HOST_INV_VALUE: return "invalid value";
291     case SW_HOST_NO_DRIVER: return "no driver";
292     case SW_HOST_NOT_SUPPORTED: return "not supported";
293     case SW_HOST_LOCKING_FAILED: return "locking failed";
294     case SW_HOST_BUSY: return "busy";
295     case SW_HOST_NO_CARD: return "no card";
296     case SW_HOST_CARD_INACTIVE: return "card inactive";
297     case SW_HOST_CARD_IO_ERROR: return "card I/O error";
298     case SW_HOST_GENERAL_ERROR: return "general error";
299     case SW_HOST_NO_READER: return "no reader";
300     case SW_HOST_ABORTED: return "aborted";
301     default: return "unknown host status error";
302     }
303 }
304
305
306 const char *
307 apdu_strerror (int rc)
308 {
309   switch (rc)
310     {
311     case SW_EOF_REACHED    : return "eof reached";
312     case SW_EEPROM_FAILURE : return "eeprom failure";
313     case SW_WRONG_LENGTH   : return "wrong length";
314     case SW_CHV_WRONG      : return "CHV wrong";
315     case SW_CHV_BLOCKED    : return "CHV blocked";
316     case SW_USE_CONDITIONS : return "use conditions not satisfied";
317     case SW_BAD_PARAMETER  : return "bad parameter";
318     case SW_NOT_SUPPORTED  : return "not supported";
319     case SW_FILE_NOT_FOUND : return "file not found";
320     case SW_RECORD_NOT_FOUND:return "record not found";
321     case SW_REF_NOT_FOUND  : return "reference not found";
322     case SW_BAD_P0_P1      : return "bad P0 or P1";
323     case SW_INS_NOT_SUP    : return "instruction not supported";
324     case SW_CLA_NOT_SUP    : return "class not supported";
325     case SW_SUCCESS        : return "success";
326     default:
327       if ((rc & ~0x00ff) == SW_MORE_DATA)
328         return "more data available";
329       if ( (rc & 0x10000) )
330         return host_sw_string (rc);
331       return "unknown status error";
332     }
333 }
334
335
336 \f
337 /* 
338        ct API Interface 
339  */
340
341 static const char *
342 ct_error_string (long err)
343 {
344   switch (err)
345     {
346     case 0: return "okay";
347     case -1: return "invalid data";
348     case -8: return "ct error";
349     case -10: return "transmission error";
350     case -11: return "memory allocation error";
351     case -128: return "HTSI error";
352     default: return "unknown CT-API error";
353     }
354 }
355
356
357 static void
358 ct_dump_reader_status (int slot)
359 {
360   log_info ("reader slot %d: %s\n", slot,
361             reader_table[slot].status == 1? "Processor ICC present" :
362             reader_table[slot].status == 0? "Memory ICC present" :
363             "ICC not present" );
364 }
365
366
367 /* Wait for the card in SLOT and activate it.  Return a status word
368    error or 0 on success. */
369 static int
370 ct_activate_card (int slot)
371 {
372   int rc;
373   unsigned char dad[1], sad[1], cmd[11], buf[256];
374   unsigned short buflen;
375   
376   /* Check whether card has been inserted. */
377   dad[0] = 1;     /* Destination address: CT. */    
378   sad[0] = 2;     /* Source address: Host. */
379
380   cmd[0] = 0x20;  /* Class byte. */
381   cmd[1] = 0x13;  /* Request status. */
382   cmd[2] = 0x00;  /* From kernel. */
383   cmd[3] = 0x80;  /* Return card's DO. */
384   cmd[4] = 0x00;
385
386   buflen = DIM(buf);
387
388   rc = CT_data (slot, dad, sad, 5, cmd, &buflen, buf);
389   if (rc || buflen < 2 || buf[buflen-2] != 0x90)
390     {
391       log_error ("ct_activate_card: can't get status of reader %d: %s\n",
392                  slot, ct_error_string (rc));
393       return SW_HOST_CARD_IO_ERROR;
394     }
395
396   /* Connected, now activate the card. */           
397   dad[0] = 1;    /* Destination address: CT. */    
398   sad[0] = 2;    /* Source address: Host. */
399
400   cmd[0] = 0x20;  /* Class byte. */
401   cmd[1] = 0x12;  /* Request ICC. */
402   cmd[2] = 0x01;  /* From first interface. */
403   cmd[3] = 0x01;  /* Return card's ATR. */
404   cmd[4] = 0x00;
405
406   buflen = DIM(buf);
407
408   rc = CT_data (slot, dad, sad, 5, cmd, &buflen, buf);
409   if (rc || buflen < 2 || buf[buflen-2] != 0x90)
410     {
411       log_error ("ct_activate_card(%d): activation failed: %s\n",
412                  slot, ct_error_string (rc));
413       if (!rc)
414         log_printhex ("  received data:", buf, buflen);
415       return SW_HOST_CARD_IO_ERROR;
416     }
417
418   /* Store the type and the ATR. */
419   if (buflen - 2 > DIM (reader_table[0].atr))
420     {
421       log_error ("ct_activate_card(%d): ATR too long\n", slot);
422       return SW_HOST_CARD_IO_ERROR;
423     }
424
425   reader_table[slot].status = buf[buflen - 1];
426   memcpy (reader_table[slot].atr, buf, buflen - 2);
427   reader_table[slot].atrlen = buflen - 2;
428   return 0;
429 }
430
431
432 static int
433 close_ct_reader (int slot)
434 {
435   CT_close (slot);
436   reader_table[slot].used = 0;
437   return 0;
438 }
439
440 static int
441 reset_ct_reader (int slot)
442 {
443   /* FIXME: Check is this is sufficient do do a reset. */
444   return ct_activate_card (slot);
445 }
446
447
448 static int
449 ct_get_status (int slot, unsigned int *status)
450 {
451   *status = 1|2|4;  /* FIXME */
452   return 0;
453
454   return SW_HOST_NOT_SUPPORTED;
455 }
456
457 /* Actually send the APDU of length APDULEN to SLOT and return a
458    maximum of *BUFLEN data in BUFFER, the actual retruned size will be
459    set to BUFLEN.  Returns: CT API error code. */
460 static int
461 ct_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
462               unsigned char *buffer, size_t *buflen)
463 {
464   int rc;
465   unsigned char dad[1], sad[1];
466   unsigned short ctbuflen;
467   
468   /* If we don't have an ATR, we need to reset the reader first. */
469   if (!reader_table[slot].atrlen
470       && (rc = reset_ct_reader (slot)))
471     return rc;
472
473   dad[0] = 0;     /* Destination address: Card. */    
474   sad[0] = 2;     /* Source address: Host. */
475   ctbuflen = *buflen;
476   if (DBG_CARD_IO)
477     log_printhex ("  CT_data:", apdu, apdulen);
478   rc = CT_data (slot, dad, sad, apdulen, apdu, &ctbuflen, buffer);
479   *buflen = ctbuflen;
480
481   return rc? SW_HOST_CARD_IO_ERROR: 0;
482 }
483
484
485
486 /* Open a reader and return an internal handle for it.  PORT is a
487    non-negative value with the port number of the reader. USB readers
488    do have port numbers starting at 32769. */
489 static int
490 open_ct_reader (int port)
491 {
492   int rc, reader;
493
494   if (port < 0 || port > 0xffff)
495     {
496       log_error ("open_ct_reader: invalid port %d requested\n", port);
497       return -1;
498     }
499   reader = new_reader_slot ();
500   if (reader == -1)
501     return reader;
502   reader_table[reader].port = port;
503
504   rc = CT_init (reader, (unsigned short)port);
505   if (rc)
506     {
507       log_error ("apdu_open_ct_reader failed on port %d: %s\n",
508                  port, ct_error_string (rc));
509       reader_table[reader].used = 0;
510       return -1;
511     }
512
513   /* Only try to activate the card. */
514   rc = ct_activate_card (reader);
515   if (rc)
516     {
517       reader_table[reader].atrlen = 0;
518       rc = 0;
519     }
520
521   reader_table[reader].close_reader = close_ct_reader;
522   reader_table[reader].reset_reader = reset_ct_reader;
523   reader_table[reader].get_status_reader = ct_get_status;
524   reader_table[reader].send_apdu_reader = ct_send_apdu;
525   reader_table[reader].dump_status_reader = ct_dump_reader_status;
526
527   dump_reader_status (reader);
528   return reader;
529 }
530
531 \f
532 #ifdef NEED_PCSC_WRAPPER
533 static int
534 writen (int fd, const void *buf, size_t nbytes)
535 {
536   size_t nleft = nbytes;
537   int nwritten;
538
539 /*   log_printhex (" writen:", buf, nbytes); */
540
541   while (nleft > 0)
542     {
543 #ifdef USE_GNU_PTH
544       nwritten = pth_write (fd, buf, nleft);
545 #else
546       nwritten = write (fd, buf, nleft);
547 #endif
548       if (nwritten < 0 && errno == EINTR)
549         continue;
550       if (nwritten < 0)
551         return -1;
552       nleft -= nwritten;
553       buf = (const char*)buf + nwritten;
554     }
555   return 0;
556 }
557
558 /* Read up to BUFLEN bytes from FD and return the number of bytes
559    actually read in NREAD.  Returns -1 on error or 0 on success. */
560 static int
561 readn (int fd, void *buf, size_t buflen, size_t *nread)
562 {
563   size_t nleft = buflen;
564   int n;
565 /*   void *orig_buf = buf; */
566
567   while (nleft > 0)
568     {
569 #ifdef USE_GNU_PTH
570       n = pth_read (fd, buf, nleft);
571 #else
572       n = read (fd, buf, nleft);
573 #endif
574       if (n < 0 && errno == EINTR) 
575         continue;
576       if (n < 0)
577         return -1; /* read error. */
578       if (!n)
579         break; /* EOF */
580       nleft -= n;
581       buf = (char*)buf + n;
582     }
583   if (nread)
584     *nread = buflen - nleft;
585
586 /*   log_printhex ("  readn:", orig_buf, *nread); */
587     
588   return 0;
589 }
590 #endif /*NEED_PCSC_WRAPPER*/
591
592 static const char *
593 pcsc_error_string (long err)
594 {
595   const char *s;
596
597   if (!err)
598     return "okay";
599   if ((err & 0x80100000) != 0x80100000)
600     return "invalid PC/SC error code";
601   err &= 0xffff;
602   switch (err)
603     {
604     case 0x0002: s = "cancelled"; break;
605     case 0x000e: s = "can't dispose"; break;
606     case 0x0008: s = "insufficient buffer"; break;   
607     case 0x0015: s = "invalid ATR"; break;
608     case 0x0003: s = "invalid handle"; break;
609     case 0x0004: s = "invalid parameter"; break; 
610     case 0x0005: s = "invalid target"; break;
611     case 0x0011: s = "invalid value"; break; 
612     case 0x0006: s = "no memory"; break;  
613     case 0x0013: s = "comm error"; break;      
614     case 0x0001: s = "internal error"; break;     
615     case 0x0014: s = "unknown error"; break; 
616     case 0x0007: s = "waited too long"; break;  
617     case 0x0009: s = "unknown reader"; break;
618     case 0x000a: s = "timeout"; break; 
619     case 0x000b: s = "sharing violation"; break;       
620     case 0x000c: s = "no smartcard"; break;
621     case 0x000d: s = "unknown card"; break;   
622     case 0x000f: s = "proto mismatch"; break;          
623     case 0x0010: s = "not ready"; break;               
624     case 0x0012: s = "system cancelled"; break;        
625     case 0x0016: s = "not transacted"; break;
626     case 0x0017: s = "reader unavailable"; break; 
627     case 0x0065: s = "unsupported card"; break;        
628     case 0x0066: s = "unresponsive card"; break;       
629     case 0x0067: s = "unpowered card"; break;          
630     case 0x0068: s = "reset card"; break;              
631     case 0x0069: s = "removed card"; break;            
632     case 0x006a: s = "inserted card"; break;           
633     case 0x001f: s = "unsupported feature"; break;     
634     case 0x0019: s = "PCI too small"; break;           
635     case 0x001a: s = "reader unsupported"; break;      
636     case 0x001b: s = "duplicate reader"; break;        
637     case 0x001c: s = "card unsupported"; break;        
638     case 0x001d: s = "no service"; break;              
639     case 0x001e: s = "service stopped"; break;      
640     default:     s = "unknown PC/SC error code"; break;
641     }
642   return s;
643 }
644
645 /* 
646        PC/SC Interface
647  */
648
649 static void
650 dump_pcsc_reader_status (int slot)
651 {
652   log_info ("reader slot %d: active protocol:", slot);
653   if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T0))
654     log_printf (" T0");
655   else if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
656     log_printf (" T1");
657   else if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_RAW))
658     log_printf (" raw");
659   log_printf ("\n");
660 }
661
662
663
664 static int
665 pcsc_get_status (int slot, unsigned int *status)
666 {
667   *status = 1|2|4;  /* FIXME!!!! */
668   return 0;
669 }
670
671 static int
672 reset_pcsc_reader (int slot)
673 {
674   return SW_HOST_NOT_SUPPORTED;
675 }
676
677
678 /* Actually send the APDU of length APDULEN to SLOT and return a
679    maximum of *BUFLEN data in BUFFER, the actual returned size will be
680    set to BUFLEN.  Returns: CT API error code. */
681 static int
682 pcsc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
683                 unsigned char *buffer, size_t *buflen)
684 {
685 #ifdef NEED_PCSC_WRAPPER
686   long err;
687   reader_table_t slotp;
688   size_t len, full_len;
689   int i, n;
690   unsigned char msgbuf[9];
691
692   if (!reader_table[slot].atrlen
693       && (err = reset_pcsc_reader (slot)))
694     return err;
695
696   if (DBG_CARD_IO)
697     log_printhex ("  PCSC_data:", apdu, apdulen);
698
699   slotp = reader_table + slot;
700
701   if (slotp->pcsc.req_fd == -1 
702       || slotp->pcsc.rsp_fd == -1 
703       || slotp->pcsc.pid == (pid_t)(-1) )
704     {
705       log_error ("pcsc_send_apdu: pcsc-wrapper not running\n");
706       return SW_HOST_CARD_IO_ERROR;
707     }
708
709   msgbuf[0] = 0x03; /* TRANSMIT command. */
710   len = apdulen;
711   msgbuf[1] = (len >> 24);
712   msgbuf[2] = (len >> 16);
713   msgbuf[3] = (len >>  8);
714   msgbuf[4] = (len      );
715   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
716        || writen (slotp->pcsc.req_fd, apdu, len))
717     {
718       log_error ("error sending PC/SC TRANSMIT request: %s\n",
719                  strerror (errno));
720       goto command_failed;
721     }
722
723   /* Read the response. */
724   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
725     {
726       log_error ("error receiving PC/SC TRANSMIT response: %s\n",
727                  i? strerror (errno) : "premature EOF");
728       goto command_failed;
729     }
730   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
731   if (msgbuf[0] != 0x81 || len < 4)
732     {
733       log_error ("invalid response header from PC/SC received\n");
734       goto command_failed;
735     }
736   len -= 4; /* Already read the error code. */
737   err = (msgbuf[5] << 24) | (msgbuf[6] << 16) | (msgbuf[7] << 8 ) | msgbuf[8];
738   if (err)
739     {
740       log_error ("pcsc_transmit failed: %s (0x%lx)\n",
741                  pcsc_error_string (err), err);
742       return SW_HOST_CARD_IO_ERROR;
743     }
744
745    full_len = len;
746    
747    n = *buflen < len ? *buflen : len;
748    if ((i=readn (slotp->pcsc.rsp_fd, buffer, n, &len)) || len != n)
749      {
750        log_error ("error receiving PC/SC TRANSMIT response: %s\n",
751                   i? strerror (errno) : "premature EOF");
752        goto command_failed;
753      }
754    *buflen = n;
755
756    full_len -= len;
757    if (full_len)
758      {
759        log_error ("pcsc_send_apdu: provided buffer too short - truncated\n");
760        err = SW_HOST_INV_VALUE;
761      }
762    /* We need to read any rest of the response, to keep the
763       protocol runnng. */
764    while (full_len)
765      {
766        unsigned char dummybuf[128];
767
768        n = full_len < DIM (dummybuf) ? full_len : DIM (dummybuf);
769        if ((i=readn (slotp->pcsc.rsp_fd, dummybuf, n, &len)) || len != n)
770          {
771            log_error ("error receiving PC/SC TRANSMIT response: %s\n",
772                       i? strerror (errno) : "premature EOF");
773            goto command_failed;
774          }
775        full_len -= n;
776      }
777
778    return err;
779
780  command_failed:
781   close (slotp->pcsc.req_fd);
782   close (slotp->pcsc.rsp_fd);
783   slotp->pcsc.req_fd = -1;
784   slotp->pcsc.rsp_fd = -1;
785   kill (slotp->pcsc.pid, SIGTERM);
786   slotp->pcsc.pid = (pid_t)(-1);
787   slotp->used = 0;
788   return -1;
789
790 #else /*!NEED_PCSC_WRAPPER*/
791
792   long err;
793   struct pcsc_io_request_s send_pci;
794   unsigned long recv_len;
795   
796   if (!reader_table[slot].atrlen
797       && (err = reset_pcsc_reader (slot)))
798     return err;
799
800   if (DBG_CARD_IO)
801     log_printhex ("  PCSC_data:", apdu, apdulen);
802
803   if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
804       send_pci.protocol = PCSC_PROTOCOL_T1;
805   else
806       send_pci.protocol = PCSC_PROTOCOL_T0;
807   send_pci.pci_len = sizeof send_pci;
808   recv_len = *buflen;
809   err = pcsc_transmit (reader_table[slot].pcsc.card,
810                        &send_pci, apdu, apdulen,
811                        NULL, buffer, &recv_len);
812   *buflen = recv_len;
813   if (err)
814     log_error ("pcsc_transmit failed: %s (0x%lx)\n",
815                pcsc_error_string (err), err);
816   
817   return err? SW_HOST_CARD_IO_ERROR:0; 
818 #endif /*!NEED_PCSC_WRAPPER*/
819 }
820
821
822 static int
823 close_pcsc_reader (int slot)
824 {
825 #ifdef NEED_PCSC_WRAPPER
826   long err;
827   reader_table_t slotp;
828   size_t len;
829   int i;
830   unsigned char msgbuf[9];
831
832   slotp = reader_table + slot;
833
834   if (slotp->pcsc.req_fd == -1 
835       || slotp->pcsc.rsp_fd == -1 
836       || slotp->pcsc.pid == (pid_t)(-1) )
837     {
838       log_error ("close_pcsc_reader: pcsc-wrapper not running\n");
839       return 0;
840     }
841
842   msgbuf[0] = 0x02; /* CLOSE command. */
843   len = 0;
844   msgbuf[1] = (len >> 24);
845   msgbuf[2] = (len >> 16);
846   msgbuf[3] = (len >>  8);
847   msgbuf[4] = (len      );
848   if ( writen (slotp->pcsc.req_fd, msgbuf, 5) )
849     {
850       log_error ("error sending PC/SC CLOSE request: %s\n",
851                  strerror (errno));
852       goto command_failed;
853     }
854
855   /* Read the response. */
856   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
857     {
858       log_error ("error receiving PC/SC CLOSE response: %s\n",
859                  i? strerror (errno) : "premature EOF");
860       goto command_failed;
861     }
862   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
863   if (msgbuf[0] != 0x81 || len < 4)
864     {
865       log_error ("invalid response header from PC/SC received\n");
866       goto command_failed;
867     }
868   len -= 4; /* Already read the error code. */
869   err = (msgbuf[5] << 24) | (msgbuf[6] << 16) | (msgbuf[7] << 8 ) | msgbuf[8];
870   if (err)
871     log_error ("pcsc_close failed: %s (0x%lx)\n",
872                pcsc_error_string (err), err);
873   
874   /* We will the wrapper in any case - errors are merely
875      informational. */
876   
877  command_failed:
878   close (slotp->pcsc.req_fd);
879   close (slotp->pcsc.rsp_fd);
880   slotp->pcsc.req_fd = -1;
881   slotp->pcsc.rsp_fd = -1;
882   kill (slotp->pcsc.pid, SIGTERM);
883   slotp->pcsc.pid = (pid_t)(-1);
884   slotp->used = 0;
885   return 0;
886
887 #else /*!NEED_PCSC_WRAPPER*/
888
889   pcsc_release_context (reader_table[slot].pcsc.context);
890   reader_table[slot].used = 0;
891   return 0;
892 #endif /*!NEED_PCSC_WRAPPER*/
893 }
894
895 static int
896 open_pcsc_reader (const char *portstr)
897 {
898 #ifdef NEED_PCSC_WRAPPER
899 /* Open the PC/SC reader using the pcsc_wrapper program.  This is
900    needed to cope with different thread models and other peculiarities
901    of libpcsclite. */
902   int slot;
903   reader_table_t slotp;
904   int fd, rp[2], wp[2];
905   int n, i;
906   pid_t pid;
907   size_t len;
908   unsigned char msgbuf[9];
909   int err;
910
911   slot = new_reader_slot ();
912   if (slot == -1)
913     return -1;
914   slotp = reader_table + slot;
915
916   /* Fire up the pcsc wrapper.  We don't use any fork/exec code from
917      the common directy but implement it direclty so that this file
918      may still be source copied. */
919   
920   if (pipe (rp) == -1)
921     {
922       log_error ("error creating a pipe: %s\n", strerror (errno));
923       slotp->used = 0;
924       return -1;
925     }
926   if (pipe (wp) == -1)
927     {
928       log_error ("error creating a pipe: %s\n", strerror (errno));
929       close (rp[0]);
930       close (rp[1]);
931       slotp->used = 0;
932       return -1;
933     }
934       
935   pid = fork ();
936   if (pid == -1)
937     {
938       log_error ("error forking process: %s\n", strerror (errno));
939       close (rp[0]);
940       close (rp[1]);
941       close (wp[0]);
942       close (wp[1]);
943       slotp->used = 0;
944       return -1;
945     }
946   slotp->pcsc.pid = pid;
947
948   if (!pid)
949     { /*
950          === Child ===
951        */
952
953       /* Double fork. */
954       pid = fork ();
955       if (pid == -1)
956         _exit (31); 
957       if (pid)
958         _exit (0); /* Immediate exit this parent, so that the child
959                       gets cleaned up by the init process. */
960
961       /* Connect our pipes. */
962       if (wp[0] != 0 && dup2 (wp[0], 0) == -1)
963         log_fatal ("dup2 stdin failed: %s\n", strerror (errno));
964       if (rp[1] != 1 && dup2 (rp[1], 1) == -1)
965         log_fatal ("dup2 stdout failed: %s\n", strerror (errno));
966       
967       /* Send stderr to the bit bucket. */
968       fd = open ("/dev/null", O_WRONLY);
969       if (fd == -1)
970         log_fatal ("can't open `/dev/null': %s", strerror (errno));
971       if (fd != 2 && dup2 (fd, 2) == -1)
972         log_fatal ("dup2 stderr failed: %s\n", strerror (errno));
973
974       /* Close all other files. */
975       n = sysconf (_SC_OPEN_MAX);
976       if (n < 0)
977         n = MAX_OPEN_FDS;
978       for (i=3; i < n; i++)
979         close(i);
980       errno = 0;
981
982       execl (GNUPG_LIBDIR "/pcsc-wrapper",
983              "pcsc-wrapper",
984              "--",
985              "1", /* API version */
986              opt.pcsc_driver, /* Name of the PC/SC library. */
987               NULL);
988       _exit (31);
989     }
990
991   /* 
992      === Parent ===
993    */
994   close (wp[0]);
995   close (rp[1]);
996   slotp->pcsc.req_fd = wp[1];
997   slotp->pcsc.rsp_fd = rp[0];
998
999   /* Wait for the intermediate child to terminate. */
1000   while ( (i=pth_waitpid (pid, NULL, 0)) == -1 && errno == EINTR)
1001     ;
1002
1003   /* Now send the open request. */
1004   msgbuf[0] = 0x01; /* OPEN command. */
1005   len = portstr? strlen (portstr):0;
1006   msgbuf[1] = (len >> 24);
1007   msgbuf[2] = (len >> 16);
1008   msgbuf[3] = (len >>  8);
1009   msgbuf[4] = (len      );
1010   if ( writen (slotp->pcsc.req_fd, msgbuf, 5)
1011        || (portstr && writen (slotp->pcsc.req_fd, portstr, len)))
1012     {
1013       log_error ("error sending PC/SC OPEN request: %s\n",
1014                  strerror (errno));
1015       goto command_failed;
1016     }
1017   /* Read the response. */
1018   if ((i=readn (slotp->pcsc.rsp_fd, msgbuf, 9, &len)) || len != 9)
1019     {
1020       log_error ("error receiving PC/SC OPEN response: %s\n",
1021                  i? strerror (errno) : "premature EOF");
1022       goto command_failed;
1023     }
1024   len = (msgbuf[1] << 24) | (msgbuf[2] << 16) | (msgbuf[3] << 8 ) | msgbuf[4];
1025   if (msgbuf[0] != 0x81 || len < 4)
1026     {
1027       log_error ("invalid response header from PC/SC received\n");
1028       goto command_failed;
1029     }
1030   len -= 4; /* Already read the error code. */
1031   if (len > DIM (slotp->atr))
1032     {
1033       log_error ("PC/SC returned a too large ATR (len=%x)\n", len);
1034       goto command_failed;
1035     }
1036   err = (msgbuf[5] << 24) | (msgbuf[6] << 16) | (msgbuf[7] << 8 ) | msgbuf[8];
1037   if (err)
1038     {
1039       log_error ("PC/SC OPEN failed: %s\n", pcsc_error_string (err));
1040       goto command_failed;
1041     }
1042   n = len;
1043   if ((i=readn (slotp->pcsc.rsp_fd, slotp->atr, n, &len)) || len != n)
1044     {
1045       log_error ("error receiving PC/SC OPEN response: %s\n",
1046                  i? strerror (errno) : "premature EOF");
1047       goto command_failed;
1048     }
1049   slotp->atrlen = len;
1050
1051   reader_table[slot].close_reader = close_pcsc_reader;
1052   reader_table[slot].reset_reader = reset_pcsc_reader;
1053   reader_table[slot].get_status_reader = pcsc_get_status;
1054   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
1055   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
1056
1057   dump_reader_status (slot); 
1058   return slot;
1059
1060  command_failed:
1061   close (slotp->pcsc.req_fd);
1062   close (slotp->pcsc.rsp_fd);
1063   slotp->pcsc.req_fd = -1;
1064   slotp->pcsc.rsp_fd = -1;
1065   kill (slotp->pcsc.pid, SIGTERM);
1066   slotp->pcsc.pid = (pid_t)(-1);
1067   slotp->used = 0;
1068   return -1;
1069 #else /*!NEED_PCSC_WRAPPER */
1070   long err;
1071   int slot;
1072   char *list = NULL;
1073   unsigned long nreader, listlen, atrlen;
1074   char *p;
1075   unsigned long card_state, card_protocol;
1076
1077   slot = new_reader_slot ();
1078   if (slot == -1)
1079     return -1;
1080
1081   err = pcsc_establish_context (PCSC_SCOPE_SYSTEM, NULL, NULL,
1082                                 &reader_table[slot].pcsc.context);
1083   if (err)
1084     {
1085       log_error ("pcsc_establish_context failed: %s (0x%lx)\n",
1086                  pcsc_error_string (err), err);
1087       reader_table[slot].used = 0;
1088       return -1;
1089     }
1090   
1091   err = pcsc_list_readers (reader_table[slot].pcsc.context,
1092                            NULL, NULL, &nreader);
1093   if (!err)
1094     {
1095       list = xtrymalloc (nreader+1); /* Better add 1 for safety reasons. */
1096       if (!list)
1097         {
1098           log_error ("error allocating memory for reader list\n");
1099           pcsc_release_context (reader_table[slot].pcsc.context);
1100           reader_table[slot].used = 0;
1101           return -1;
1102         }
1103       err = pcsc_list_readers (reader_table[slot].pcsc.context,
1104                                NULL, list, &nreader);
1105     }
1106   if (err)
1107     {
1108       log_error ("pcsc_list_readers failed: %s (0x%lx)\n",
1109                  pcsc_error_string (err), err);
1110       pcsc_release_context (reader_table[slot].pcsc.context);
1111       reader_table[slot].used = 0;
1112       xfree (list);
1113       return -1;
1114     }
1115
1116   listlen = nreader;
1117   p = list;
1118   while (nreader)
1119     {
1120       if (!*p && !p[1])
1121         break;
1122       log_info ("detected reader `%s'\n", p);
1123       if (nreader < (strlen (p)+1))
1124         {
1125           log_error ("invalid response from pcsc_list_readers\n");
1126           break;
1127         }
1128       nreader -= strlen (p)+1;
1129       p += strlen (p) + 1;
1130     }
1131
1132   err = pcsc_connect (reader_table[slot].pcsc.context,
1133                       portstr? portstr : list,
1134                       PCSC_SHARE_EXCLUSIVE,
1135                       PCSC_PROTOCOL_T0|PCSC_PROTOCOL_T1,
1136                       &reader_table[slot].pcsc.card,
1137                       &reader_table[slot].pcsc.protocol);
1138   if (err)
1139     {
1140       log_error ("pcsc_connect failed: %s (0x%lx)\n",
1141                   pcsc_error_string (err), err);
1142       pcsc_release_context (reader_table[slot].pcsc.context);
1143       reader_table[slot].used = 0;
1144       xfree (list);
1145       return -1;
1146     }      
1147   
1148   atrlen = 32;
1149   /* (We need to pass a dummy buffer.  We use LIST because it ought to
1150      be large enough.) */
1151   err = pcsc_status (reader_table[slot].pcsc.card,
1152                      list, &listlen,
1153                      &card_state, &card_protocol,
1154                      reader_table[slot].atr, &atrlen);
1155   xfree (list);
1156   if (err)
1157     {
1158       log_error ("pcsc_status failed: %s (0x%lx)\n",
1159                   pcsc_error_string (err), err);
1160       pcsc_release_context (reader_table[slot].pcsc.context);
1161       reader_table[slot].used = 0;
1162       return -1;
1163     }
1164   if (atrlen >= DIM (reader_table[0].atr))
1165     log_bug ("ATR returned by pcsc_status is too large\n");
1166   reader_table[slot].atrlen = atrlen;
1167
1168   reader_table[slot].close_reader = close_pcsc_reader;
1169   reader_table[slot].reset_reader = reset_pcsc_reader;
1170   reader_table[slot].get_status_reader = pcsc_get_status;
1171   reader_table[slot].send_apdu_reader = pcsc_send_apdu;
1172   reader_table[slot].dump_status_reader = dump_pcsc_reader_status;
1173
1174 /*   log_debug ("state    from pcsc_status: 0x%lx\n", card_state); */
1175 /*   log_debug ("protocol from pcsc_status: 0x%lx\n", card_protocol); */
1176
1177   dump_reader_status (slot); 
1178   return slot;
1179 #endif /*!NEED_PCSC_WRAPPER */
1180 }
1181
1182
1183
1184 \f
1185 #ifdef HAVE_LIBUSB
1186 /* 
1187      Internal CCID driver interface.
1188  */
1189
1190
1191 static void
1192 dump_ccid_reader_status (int slot)
1193 {
1194   log_info ("reader slot %d: using ccid driver\n", slot);
1195 }
1196
1197 static int
1198 close_ccid_reader (int slot)
1199 {
1200   ccid_close_reader (reader_table[slot].ccid.handle);
1201   reader_table[slot].used = 0;
1202   return 0;
1203 }                       
1204   
1205
1206 static int
1207 shutdown_ccid_reader (int slot)
1208 {
1209   ccid_shutdown_reader (reader_table[slot].ccid.handle);
1210   return 0;
1211 }                       
1212   
1213
1214 static int
1215 reset_ccid_reader (int slot)
1216 {
1217   int err;
1218   reader_table_t slotp = reader_table + slot;
1219   unsigned char atr[33];
1220   size_t atrlen;
1221
1222   err = ccid_get_atr (slotp->ccid.handle, atr, sizeof atr, &atrlen);
1223   if (err)
1224     return err;
1225   /* If the reset was successful, update the ATR. */
1226   assert (sizeof slotp->atr >= sizeof atr);
1227   slotp->atrlen = atrlen;
1228   memcpy (slotp->atr, atr, atrlen);
1229   dump_reader_status (slot); 
1230   return 0;
1231 }                       
1232   
1233
1234 static int
1235 get_status_ccid (int slot, unsigned int *status)
1236 {
1237   int rc;
1238   int bits;
1239
1240   rc = ccid_slot_status (reader_table[slot].ccid.handle, &bits);
1241   if (rc)
1242     return -1;
1243
1244   if (bits == 0)
1245     *status = 1|2|4;
1246   else if (bits == 1)
1247     *status = 2;
1248   else 
1249     *status = 0;
1250
1251   return 0;
1252 }
1253
1254
1255 /* Actually send the APDU of length APDULEN to SLOT and return a
1256    maximum of *BUFLEN data in BUFFER, the actual returned size will be
1257    set to BUFLEN.  Returns: Internal CCID driver error code. */
1258 static int
1259 send_apdu_ccid (int slot, unsigned char *apdu, size_t apdulen,
1260                 unsigned char *buffer, size_t *buflen)
1261 {
1262   long err;
1263   size_t maxbuflen;
1264
1265   /* If we don't have an ATR, we need to reset the reader first. */
1266   if (!reader_table[slot].atrlen
1267       && (err = reset_ccid_reader (slot)))
1268     return err;
1269
1270   if (DBG_CARD_IO)
1271     log_printhex ("  APDU_data:", apdu, apdulen);
1272
1273   maxbuflen = *buflen;
1274   err = ccid_transceive (reader_table[slot].ccid.handle,
1275                          apdu, apdulen,
1276                          buffer, maxbuflen, buflen);
1277   if (err)
1278     log_error ("ccid_transceive failed: (0x%lx)\n",
1279                err);
1280   
1281   return err; 
1282 }
1283
1284 /* Open the reader and try to read an ATR.  */
1285 static int
1286 open_ccid_reader (const char *portstr)
1287 {
1288   int err;
1289   int slot;
1290   reader_table_t slotp;
1291
1292   slot = new_reader_slot ();
1293   if (slot == -1)
1294     return -1;
1295   slotp = reader_table + slot;
1296
1297   err = ccid_open_reader (&slotp->ccid.handle, portstr);
1298   if (err)
1299     {
1300       slotp->used = 0;
1301       return -1;
1302     }
1303
1304   err = ccid_get_atr (slotp->ccid.handle,
1305                       slotp->atr, sizeof slotp->atr, &slotp->atrlen);
1306   if (err)
1307     {
1308       slotp->atrlen = 0;
1309       err = 0;
1310     }
1311
1312   reader_table[slot].close_reader = close_ccid_reader;
1313   reader_table[slot].shutdown_reader = shutdown_ccid_reader;
1314   reader_table[slot].reset_reader = reset_ccid_reader;
1315   reader_table[slot].get_status_reader = get_status_ccid;
1316   reader_table[slot].send_apdu_reader = send_apdu_ccid;
1317   reader_table[slot].dump_status_reader = dump_ccid_reader_status;
1318
1319   dump_reader_status (slot); 
1320   return slot;
1321 }
1322
1323
1324
1325 #endif /* HAVE_LIBUSB */
1326
1327
1328 \f
1329 #ifdef HAVE_OPENSC
1330 /* 
1331      OpenSC Interface.
1332
1333      This uses the OpenSC primitives to send APDUs.  We need this
1334      because we can't mix OpenSC and native (i.e. ctAPI or PC/SC)
1335      access to a card for resource conflict reasons.
1336  */
1337
1338
1339 static int
1340 close_osc_reader (int slot)
1341 {
1342   /* FIXME: Implement. */
1343   reader_table[slot].used = 0;
1344   return 0;
1345 }
1346
1347 static int
1348 reset_osc_reader (int slot)
1349 {
1350   return SW_HOST_NOT_SUPPORTED;
1351 }
1352
1353
1354 static int
1355 osc_get_status (int slot, unsigned int *status)
1356 {
1357   return SW_HOST_NOT_SUPPORTED;
1358 }
1359
1360
1361 /* Actually send the APDU of length APDULEN to SLOT and return a
1362    maximum of *BUFLEN data in BUFFER, the actual returned size will be
1363    set to BUFLEN.  Returns: OpenSC error code. */
1364 static int
1365 osc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
1366                 unsigned char *buffer, size_t *buflen)
1367 {
1368   long err;
1369   struct sc_apdu a;
1370   unsigned char data[SC_MAX_APDU_BUFFER_SIZE];
1371   unsigned char result[SC_MAX_APDU_BUFFER_SIZE];
1372
1373   if (DBG_CARD_IO)
1374     log_printhex ("  APDU_data:", apdu, apdulen);
1375
1376   if (apdulen < 4)
1377     {
1378       log_error ("osc_send_apdu: APDU is too short\n");
1379       return SW_HOST_INV_VALUE;
1380     }
1381
1382   memset(&a, 0, sizeof a);
1383   a.cla = *apdu++;
1384   a.ins = *apdu++;
1385   a.p1 = *apdu++;
1386   a.p2 = *apdu++;
1387   apdulen -= 4;
1388
1389   if (!apdulen)
1390     a.cse = SC_APDU_CASE_1;
1391   else if (apdulen == 1) 
1392     {
1393       a.le = *apdu? *apdu : 256;
1394       apdu++; apdulen--;
1395       a.cse = SC_APDU_CASE_2_SHORT;
1396     }
1397   else
1398     {
1399       a.lc = *apdu++; apdulen--;
1400       if (apdulen < a.lc)
1401         {
1402           log_error ("osc_send_apdu: APDU shorter than specified in Lc\n");
1403           return SW_HOST_INV_VALUE;
1404
1405         }
1406       memcpy(data, apdu, a.lc);
1407       apdu += a.lc; apdulen -= a.lc;
1408
1409       a.data = data;
1410       a.datalen = a.lc;
1411       
1412       if (!apdulen)
1413         a.cse = SC_APDU_CASE_3_SHORT;
1414       else
1415         {
1416           a.le = *apdu? *apdu : 256;
1417           apdu++; apdulen--;
1418           if (apdulen)
1419             {
1420               log_error ("osc_send_apdu: APDU larger than specified\n");
1421               return SW_HOST_INV_VALUE;
1422             }
1423           a.cse = SC_APDU_CASE_4_SHORT;
1424         }
1425     }
1426
1427   a.resp = result;
1428   a.resplen = DIM(result);
1429
1430   err = sc_transmit_apdu (reader_table[slot].osc.scard, &a);
1431   if (err)
1432     {
1433       log_error ("sc_apdu_transmit failed: %s\n", sc_strerror (err));
1434       return SW_HOST_CARD_IO_ERROR;
1435     }
1436
1437   if (*buflen < 2 || a.resplen > *buflen - 2)
1438     {
1439       log_error ("osc_send_apdu: provided buffer too short to store result\n");
1440       return SW_HOST_INV_VALUE;
1441     }
1442   memcpy (buffer, a.resp, a.resplen);
1443   buffer[a.resplen] = a.sw1;
1444   buffer[a.resplen+1] = a.sw2;
1445   *buflen = a.resplen + 2;
1446   return 0;
1447 }
1448
1449 static int
1450 open_osc_reader (int portno)
1451 {
1452   int err;
1453   int slot;
1454   reader_table_t slotp;
1455
1456   slot = new_reader_slot ();
1457   if (slot == -1)
1458     return -1;
1459   slotp = reader_table + slot;
1460
1461   err = sc_establish_context (&slotp->osc.ctx, "scdaemon");
1462   if (err)
1463     {
1464       log_error ("failed to establish SC context: %s\n", sc_strerror (err));
1465       slotp->used = 0;
1466       return -1;
1467     }
1468   if (portno < 0 || portno >= slotp->osc.ctx->reader_count)
1469     {
1470       log_error ("no card reader available\n");
1471       sc_release_context (slotp->osc.ctx);
1472       slotp->used = 0;
1473       return -1;
1474     }
1475
1476   /* Redirect to our logging facility. */
1477   slotp->osc.ctx->error_file = log_get_stream ();
1478   slotp->osc.ctx->debug = opt.debug_sc;
1479   slotp->osc.ctx->debug_file = log_get_stream ();
1480
1481   if (sc_detect_card_presence (slotp->osc.ctx->reader[portno], 0) != 1)
1482     {
1483       log_error ("no card present\n");
1484       sc_release_context (slotp->osc.ctx);
1485       slotp->used = 0;
1486       return -1;
1487     }
1488   
1489   /* We want the standard ISO driver. */
1490   /*FIXME: OpenSC does not like "iso7816", so we use EMV for now. */
1491   err = sc_set_card_driver(slotp->osc.ctx, "emv");
1492   if (err)
1493     {
1494       log_error ("failed to select the iso7816 driver: %s\n",
1495                  sc_strerror (err));
1496       sc_release_context (slotp->osc.ctx);
1497       slotp->used = 0;
1498       return -1;
1499     }
1500
1501   /* Now connect the card and hope that OpenSC won't try to be too
1502      smart. */
1503   err = sc_connect_card (slotp->osc.ctx->reader[portno], 0,
1504                          &slotp->osc.scard);
1505   if (err)
1506     {
1507       log_error ("failed to connect card in reader %d: %s\n",
1508                  portno, sc_strerror (err));
1509       sc_release_context (slotp->osc.ctx);
1510       slotp->used = 0;
1511       return -1;
1512     }
1513   if (opt.verbose)
1514     log_info ("connected to card in opensc reader %d using driver `%s'\n",
1515               portno, slotp->osc.scard->driver->name);
1516
1517   err = sc_lock (slotp->osc.scard);
1518   if (err)
1519     {
1520       log_error ("can't lock card in reader %d: %s\n",
1521                  portno, sc_strerror (err));
1522       sc_disconnect_card (slotp->osc.scard, 0);
1523       sc_release_context (slotp->osc.ctx);
1524       slotp->used = 0;
1525       return -1;
1526     }
1527
1528   if (slotp->osc.scard->atr_len >= DIM (slotp->atr))
1529     log_bug ("ATR returned by opensc is too large\n");
1530   slotp->atrlen = slotp->osc.scard->atr_len;
1531   memcpy (slotp->atr, slotp->osc.scard->atr, slotp->atrlen);
1532
1533   reader_table[slot].close_reader = close_osc_reader;
1534   reader_table[slot].reset_reader = reset_osc_reader;
1535   reader_table[slot].get_status_reader = osc_get_status;
1536   reader_table[slot].send_apdu_reader = osc_send_apdu;
1537   reader_table[slot].dump_status_reader = NULL;
1538
1539   dump_reader_status (slot); 
1540   return slot;
1541 }
1542
1543 #endif /* HAVE_OPENSC */
1544
1545
1546 \f
1547 #ifdef USE_G10CODE_RAPDU
1548 /* 
1549      The Remote APDU Interface.
1550
1551      This uses the Remote APDU protocol to contact a reader.
1552
1553      The port number is actually an index into the list of ports as
1554      returned via the protocol.
1555  */
1556
1557
1558 static int
1559 rapdu_status_to_sw (int status)
1560 {
1561   int rc;
1562
1563   switch (status)
1564     {
1565     case RAPDU_STATUS_SUCCESS:  rc = 0; break;
1566
1567     case RAPDU_STATUS_INVCMD:  
1568     case RAPDU_STATUS_INVPROT:  
1569     case RAPDU_STATUS_INVSEQ:  
1570     case RAPDU_STATUS_INVCOOKIE:
1571     case RAPDU_STATUS_INVREADER:  rc = SW_HOST_INV_VALUE;  break;
1572
1573     case RAPDU_STATUS_TIMEOUT:  rc = SW_HOST_CARD_IO_ERROR; break;
1574     case RAPDU_STATUS_CARDIO:   rc = SW_HOST_CARD_IO_ERROR; break;
1575     case RAPDU_STATUS_NOCARD:   rc = SW_HOST_NO_CARD; break;
1576     case RAPDU_STATUS_CARDCHG:  rc = SW_HOST_NO_CARD; break;
1577     case RAPDU_STATUS_BUSY:     rc = SW_HOST_BUSY; break;
1578     case RAPDU_STATUS_NEEDRESET: rc = SW_HOST_CARD_INACTIVE; break;
1579
1580     default: rc = SW_HOST_GENERAL_ERROR; break;
1581     }
1582
1583   return rc;
1584 }
1585
1586
1587
1588 static int
1589 close_rapdu_reader (int slot)
1590 {
1591   rapdu_release (reader_table[slot].rapdu.handle);
1592   reader_table[slot].used = 0;
1593   return 0;
1594 }
1595
1596
1597 static int
1598 reset_rapdu_reader (int slot)
1599 {
1600   int err;
1601   reader_table_t slotp;
1602   rapdu_msg_t msg = NULL;
1603
1604   slotp = reader_table + slot;
1605
1606   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
1607   if (err)
1608     {
1609       log_error ("sending rapdu command RESET failed: %s\n",
1610                 err < 0 ? strerror (errno): rapdu_strerror (err));
1611       rapdu_msg_release (msg);
1612       return rapdu_status_to_sw (err);
1613     }
1614   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
1615   if (err)
1616     {
1617       log_error ("receiving rapdu message failed: %s\n",
1618                 err < 0 ? strerror (errno): rapdu_strerror (err));
1619       rapdu_msg_release (msg);
1620       return rapdu_status_to_sw (err);
1621     }
1622   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
1623     {
1624       int sw = rapdu_status_to_sw (msg->cmd);
1625       log_error ("rapdu command RESET failed: %s\n",
1626                  rapdu_strerror (msg->cmd));
1627       rapdu_msg_release (msg);
1628       return sw;
1629     }
1630   if (msg->datalen >= DIM (slotp->atr))
1631     {
1632       log_error ("ATR returned by the RAPDU layer is too large\n");
1633       rapdu_msg_release (msg);
1634       return SW_HOST_INV_VALUE; 
1635     }
1636   slotp->atrlen = msg->datalen;
1637   memcpy (slotp->atr, msg->data, msg->datalen);
1638
1639   rapdu_msg_release (msg);
1640   return 0;
1641 }
1642
1643
1644 static int
1645 my_rapdu_get_status (int slot, unsigned int *status)
1646 {
1647   int err;
1648   reader_table_t slotp;
1649   rapdu_msg_t msg = NULL;
1650   int oldslot;
1651
1652   slotp = reader_table + slot;
1653
1654   oldslot = rapdu_set_reader (slotp->rapdu.handle, slot);
1655   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_STATUS);
1656   rapdu_set_reader (slotp->rapdu.handle, oldslot);
1657   if (err)
1658     {
1659       log_error ("sending rapdu command GET_STATUS failed: %s\n",
1660                 err < 0 ? strerror (errno): rapdu_strerror (err));
1661       return rapdu_status_to_sw (err);
1662     }
1663   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
1664   if (err)
1665     {
1666       log_error ("receiving rapdu message failed: %s\n",
1667                 err < 0 ? strerror (errno): rapdu_strerror (err));
1668       rapdu_msg_release (msg);
1669       return rapdu_status_to_sw (err);
1670     }
1671   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
1672     {
1673       int sw = rapdu_status_to_sw (msg->cmd);
1674       log_error ("rapdu command GET_STATUS failed: %s\n",
1675                  rapdu_strerror (msg->cmd));
1676       rapdu_msg_release (msg);
1677       return sw;
1678     }
1679   *status = msg->data[0];
1680
1681   rapdu_msg_release (msg);
1682   return 0;
1683 }
1684
1685
1686 /* Actually send the APDU of length APDULEN to SLOT and return a
1687    maximum of *BUFLEN data in BUFFER, the actual returned size will be
1688    set to BUFLEN.  Returns: OpenSC error code. */
1689 static int
1690 my_rapdu_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
1691                     unsigned char *buffer, size_t *buflen)
1692 {
1693   int err;
1694   reader_table_t slotp;
1695   rapdu_msg_t msg = NULL;
1696   size_t maxlen = *buflen;
1697
1698   slotp = reader_table + slot;
1699
1700   *buflen = 0;
1701   if (DBG_CARD_IO)
1702     log_printhex ("  APDU_data:", apdu, apdulen);
1703
1704   if (apdulen < 4)
1705     {
1706       log_error ("rapdu_send_apdu: APDU is too short\n");
1707       return SW_HOST_INV_VALUE;
1708     }
1709
1710   err = rapdu_send_apdu (slotp->rapdu.handle, apdu, apdulen);
1711   if (err)
1712     {
1713       log_error ("sending rapdu command APDU failed: %s\n",
1714                 err < 0 ? strerror (errno): rapdu_strerror (err));
1715       rapdu_msg_release (msg);
1716       return rapdu_status_to_sw (err);
1717     }
1718   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
1719   if (err)
1720     {
1721       log_error ("receiving rapdu message failed: %s\n",
1722                 err < 0 ? strerror (errno): rapdu_strerror (err));
1723       rapdu_msg_release (msg);
1724       return rapdu_status_to_sw (err);
1725     }
1726   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
1727     {
1728       int sw = rapdu_status_to_sw (msg->cmd);
1729       log_error ("rapdu command APDU failed: %s\n",
1730                  rapdu_strerror (msg->cmd));
1731       rapdu_msg_release (msg);
1732       return sw;
1733     }
1734   
1735   if (msg->datalen > maxlen)
1736     {
1737       log_error ("rapdu response apdu too large\n");
1738       rapdu_msg_release (msg);
1739       return SW_HOST_INV_VALUE; 
1740     }
1741
1742   *buflen = msg->datalen;
1743   memcpy (buffer, msg->data, msg->datalen);
1744
1745   rapdu_msg_release (msg);
1746   return 0;
1747 }
1748
1749 static int
1750 open_rapdu_reader (int portno,
1751                    const unsigned char *cookie, size_t length,
1752                    int (*readfnc) (void *opaque,
1753                                    void *buffer, size_t size),
1754                    void *readfnc_value,
1755                    int (*writefnc) (void *opaque,
1756                                     const void *buffer, size_t size),
1757                    void *writefnc_value,
1758                    void (*closefnc) (void *opaque),
1759                    void *closefnc_value)
1760 {
1761   int err;
1762   int slot;
1763   reader_table_t slotp;
1764   rapdu_msg_t msg = NULL;
1765
1766   slot = new_reader_slot ();
1767   if (slot == -1)
1768     return -1;
1769   slotp = reader_table + slot;
1770
1771   slotp->rapdu.handle = rapdu_new ();
1772   if (!slotp->rapdu.handle)
1773     {
1774       slotp->used = 0;
1775       return -1;
1776     }
1777
1778
1779   rapdu_set_iofunc (slotp->rapdu.handle,
1780                     readfnc, readfnc_value,
1781                     writefnc, writefnc_value,
1782                     closefnc, closefnc_value);
1783   rapdu_set_cookie (slotp->rapdu.handle, cookie, length);
1784
1785   /* First try to get the current ATR, but if the card is inactive
1786      issue a reset instead.  */
1787   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_ATR);
1788   if (err == RAPDU_STATUS_NEEDRESET)
1789     err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
1790   if (err)
1791     {
1792       log_info ("sending rapdu command GET_ATR/RESET failed: %s\n",
1793                 err < 0 ? strerror (errno): rapdu_strerror (err));
1794       goto failure;
1795     }
1796   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
1797   if (err)
1798     {
1799       log_info ("receiving rapdu message failed: %s\n",
1800                 err < 0 ? strerror (errno): rapdu_strerror (err));
1801       goto failure;
1802     }
1803   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
1804     {
1805       log_info ("rapdu command GET ATR failed: %s\n",
1806                  rapdu_strerror (msg->cmd));
1807       goto failure;
1808     }
1809   if (msg->datalen >= DIM (slotp->atr))
1810     {
1811       log_error ("ATR returned by the RAPDU layer is too large\n");
1812       goto failure;
1813     }
1814   slotp->atrlen = msg->datalen;
1815   memcpy (slotp->atr, msg->data, msg->datalen);
1816
1817   reader_table[slot].close_reader = close_rapdu_reader;
1818   reader_table[slot].reset_reader = reset_rapdu_reader;
1819   reader_table[slot].get_status_reader = my_rapdu_get_status;
1820   reader_table[slot].send_apdu_reader = my_rapdu_send_apdu;
1821   reader_table[slot].dump_status_reader = NULL;
1822
1823   dump_reader_status (slot); 
1824   rapdu_msg_release (msg);
1825   return slot;
1826
1827  failure:      
1828   rapdu_msg_release (msg);
1829   rapdu_release (slotp->rapdu.handle);
1830   slotp->used = 0;
1831   return -1;
1832 }
1833
1834 #endif /*USE_G10CODE_RAPDU*/
1835
1836
1837 \f
1838 /* 
1839        Driver Access
1840  */
1841
1842
1843 static int
1844 lock_slot (int slot)
1845 {
1846 #ifdef USE_GNU_PTH
1847   if (!pth_mutex_acquire (&reader_table[slot].lock, 0, NULL))
1848     {
1849       log_error ("failed to acquire apdu lock: %s\n", strerror (errno));
1850       return SW_HOST_LOCKING_FAILED;
1851     }
1852 #endif /*USE_GNU_PTH*/
1853   return 0;
1854 }
1855
1856 static int
1857 trylock_slot (int slot)
1858 {
1859 #ifdef USE_GNU_PTH
1860   if (!pth_mutex_acquire (&reader_table[slot].lock, TRUE, NULL))
1861     {
1862       if (errno == EBUSY)
1863         return SW_HOST_BUSY;
1864       log_error ("failed to acquire apdu lock: %s\n", strerror (errno));
1865       return SW_HOST_LOCKING_FAILED;
1866     }
1867 #endif /*USE_GNU_PTH*/
1868   return 0;
1869 }
1870
1871 static void
1872 unlock_slot (int slot)
1873 {
1874 #ifdef USE_GNU_PTH
1875   if (!pth_mutex_release (&reader_table[slot].lock))
1876     log_error ("failed to release apdu lock: %s\n", strerror (errno));
1877 #endif /*USE_GNU_PTH*/
1878 }
1879
1880
1881 /* Open the reader and return an internal slot number or -1 on
1882    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
1883    the first USB reader.  For PC/SC the first listed reader).  If
1884    OpenSC support is compiled in, we first try to use OpenSC. */
1885 int
1886 apdu_open_reader (const char *portstr)
1887 {
1888   static int pcsc_api_loaded, ct_api_loaded;
1889
1890 #ifdef HAVE_LIBUSB
1891   if (!opt.disable_ccid)
1892     {
1893       int slot, i;
1894       const char *s;
1895
1896       slot = open_ccid_reader (portstr);
1897       if (slot != -1)
1898         return slot; /* got one */
1899
1900       /* If a CCID reader specification has been given, the user does
1901          not want a fallback to other drivers. */
1902       if (portstr)
1903         for (s=portstr, i=0; *s; s++)
1904           if (*s == ':' && (++i == 3))
1905             return -1;
1906     }
1907
1908 #endif /* HAVE_LIBUSB */
1909
1910 #ifdef HAVE_OPENSC
1911   if (!opt.disable_opensc)
1912     {
1913       int port = portstr? atoi (portstr) : 0;
1914
1915       return open_osc_reader (port);
1916     }
1917 #endif /* HAVE_OPENSC */  
1918
1919
1920   if (opt.ctapi_driver && *opt.ctapi_driver)
1921     {
1922       int port = portstr? atoi (portstr) : 32768;
1923
1924       if (!ct_api_loaded)
1925         {
1926           void *handle;
1927           
1928           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
1929           if (!handle)
1930             {
1931               log_error ("apdu_open_reader: failed to open driver: %s\n",
1932                          dlerror ());
1933               return -1;
1934             }
1935           CT_init = dlsym (handle, "CT_init");
1936           CT_data = dlsym (handle, "CT_data");
1937           CT_close = dlsym (handle, "CT_close");
1938           if (!CT_init || !CT_data || !CT_close)
1939             {
1940               log_error ("apdu_open_reader: invalid CT-API driver\n");
1941               dlclose (handle);
1942               return -1;
1943             }
1944           ct_api_loaded = 1;
1945         }
1946       return open_ct_reader (port);
1947     }
1948
1949   
1950   /* No ctAPI configured, so lets try the PC/SC API */
1951   if (!pcsc_api_loaded)
1952     {
1953 #ifndef NEED_PCSC_WRAPPER
1954       void *handle;
1955
1956       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
1957       if (!handle)
1958         {
1959           log_error ("apdu_open_reader: failed to open driver `%s': %s\n",
1960                      opt.pcsc_driver, dlerror ());
1961           return -1;
1962         }
1963
1964       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
1965       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
1966       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
1967 #ifdef _WIN32
1968       if (!pcsc_list_readers)
1969         pcsc_list_readers    = dlsym (handle, "SCardListReadersA");
1970 #endif
1971       pcsc_connect           = dlsym (handle, "SCardConnect");
1972 #ifdef _WIN32
1973       if (!pcsc_connect)
1974         pcsc_connect         = dlsym (handle, "SCardConnectA");
1975 #endif
1976       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
1977       pcsc_status            = dlsym (handle, "SCardStatus");
1978 #ifdef _WIN32
1979       if (!pcsc_status)
1980         pcsc_status          = dlsym (handle, "SCardStatusA");
1981 #endif
1982       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
1983       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
1984       pcsc_transmit          = dlsym (handle, "SCardTransmit");
1985       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
1986
1987       if (!pcsc_establish_context
1988           || !pcsc_release_context  
1989           || !pcsc_list_readers     
1990           || !pcsc_connect          
1991           || !pcsc_disconnect
1992           || !pcsc_status
1993           || !pcsc_begin_transaction
1994           || !pcsc_end_transaction
1995           || !pcsc_transmit         
1996           /* || !pcsc_set_timeout */)
1997         {
1998           /* Note that set_timeout is currently not used and also not
1999              available under Windows. */
2000           log_error ("apdu_open_reader: invalid PC/SC driver "
2001                      "(%d%d%d%d%d%d%d%d%d%d)\n",
2002                      !!pcsc_establish_context,
2003                      !!pcsc_release_context,  
2004                      !!pcsc_list_readers,     
2005                      !!pcsc_connect,          
2006                      !!pcsc_disconnect,
2007                      !!pcsc_status,
2008                      !!pcsc_begin_transaction,
2009                      !!pcsc_end_transaction,
2010                      !!pcsc_transmit,         
2011                      !!pcsc_set_timeout );
2012           dlclose (handle);
2013           return -1;
2014         }
2015 #endif /*!NEED_PCSC_WRAPPER*/  
2016       pcsc_api_loaded = 1;
2017     }
2018
2019   return open_pcsc_reader (portstr);
2020 }
2021
2022
2023 /* Open an remote reader and return an internal slot number or -1 on
2024    error. This function is an alternative to apdu_open_reader and used
2025    with remote readers only.  Note that the supplied CLOSEFNC will
2026    only be called once and the slot will not be valid afther this.
2027
2028    If PORTSTR is NULL we default to the first availabe port.
2029 */  
2030 int
2031 apdu_open_remote_reader (const char *portstr,
2032                          const unsigned char *cookie, size_t length,
2033                          int (*readfnc) (void *opaque,
2034                                          void *buffer, size_t size),
2035                          void *readfnc_value,
2036                          int (*writefnc) (void *opaque,
2037                                           const void *buffer, size_t size),
2038                          void *writefnc_value,
2039                          void (*closefnc) (void *opaque),
2040                          void *closefnc_value)
2041 {
2042 #ifdef USE_G10CODE_RAPDU
2043   return open_rapdu_reader (portstr? atoi (portstr) : 0,
2044                             cookie, length,
2045                             readfnc, readfnc_value,
2046                             writefnc, writefnc_value,
2047                             closefnc, closefnc_value);
2048 #else
2049   errno = ENOSYS;
2050   return -1;
2051 #endif
2052 }
2053
2054
2055 int
2056 apdu_close_reader (int slot)
2057 {
2058   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2059     return SW_HOST_NO_DRIVER;
2060   if (reader_table[slot].close_reader)
2061     return reader_table[slot].close_reader (slot);
2062   return SW_HOST_NOT_SUPPORTED;
2063 }
2064
2065 /* Shutdown a reader; that is basically the same as a close but keeps
2066    the handle ready for later use. A apdu_reset_header should be used
2067    to get it active again. */
2068 int
2069 apdu_shutdown_reader (int slot)
2070 {
2071   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2072     return SW_HOST_NO_DRIVER;
2073   if (reader_table[slot].shutdown_reader)
2074     return reader_table[slot].shutdown_reader (slot);
2075   return SW_HOST_NOT_SUPPORTED;
2076 }
2077
2078 /* Enumerate all readers and return information on whether this reader
2079    is in use.  The caller should start with SLOT set to 0 and
2080    increment it with each call until an error is returned. */
2081 int
2082 apdu_enum_reader (int slot, int *used)
2083 {
2084   if (slot < 0 || slot >= MAX_READER)
2085     return SW_HOST_NO_DRIVER;
2086   *used = reader_table[slot].used;
2087   return 0;
2088 }
2089
2090 /* Do a reset for the card in reader at SLOT. */
2091 int
2092 apdu_reset (int slot)
2093 {
2094   int sw;
2095
2096   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2097     return SW_HOST_NO_DRIVER;
2098   
2099   if ((sw = lock_slot (slot)))
2100     return sw;
2101
2102   if (reader_table[slot].reset_reader)
2103     sw = reader_table[slot].reset_reader (slot);
2104
2105   unlock_slot (slot);
2106   return sw;
2107 }
2108
2109
2110 /* Activate a card if it has not yet been done.  This is a kind of
2111    reset-if-required.  It is useful to test for presence of a card
2112    before issuing a bunch of apdu commands.  It does not wait on a
2113    locked card. */
2114 int
2115 apdu_activate (int slot)
2116 {
2117   int sw;
2118   unsigned int s;
2119
2120   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2121     return SW_HOST_NO_DRIVER;
2122   
2123   if ((sw = trylock_slot (slot)))
2124     return sw;
2125
2126   if (reader_table[slot].get_status_reader)
2127     sw = reader_table[slot].get_status_reader (slot, &s);
2128
2129   if (!sw)
2130     {
2131       if (!(s & 2))  /* Card not present.  */
2132         sw = SW_HOST_NO_CARD;
2133       else if ( ((s & 2) && !(s & 4))
2134                 || !reader_table[slot].atrlen )
2135         {
2136           /* We don't have an ATR or a card is present though inactive:
2137              do a reset now. */
2138           if (reader_table[slot].reset_reader)
2139             sw = reader_table[slot].reset_reader (slot);
2140         }
2141     }
2142   
2143   unlock_slot (slot);
2144   return sw;
2145 }
2146
2147   
2148
2149 unsigned char *
2150 apdu_get_atr (int slot, size_t *atrlen)
2151 {
2152   char *buf;
2153
2154   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2155     return NULL;
2156   
2157   buf = xtrymalloc (reader_table[slot].atrlen);
2158   if (!buf)
2159     return NULL;
2160   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
2161   *atrlen = reader_table[slot].atrlen;
2162   return buf;
2163 }
2164
2165
2166     
2167 /* Retrieve the status for SLOT. The function does only wait for the
2168    card to become available if HANG is set to true. On success the
2169    bits in STATUS will be set to
2170
2171      bit 0 = card present and usable
2172      bit 1 = card present
2173      bit 2 = card active
2174      bit 3 = card access locked [not yet implemented]
2175
2176    For must application, testing bit 0 is sufficient.
2177
2178    CHANGED will receive the value of the counter tracking the number
2179    of card insertions.  This value may be used to detect a card
2180    change.
2181 */
2182 int
2183 apdu_get_status (int slot, int hang,
2184                  unsigned int *status, unsigned int *changed)
2185 {
2186   int sw;
2187   unsigned int s;
2188
2189   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2190     return SW_HOST_NO_DRIVER;
2191
2192   if ((sw = hang? lock_slot (slot) : trylock_slot (slot)))
2193     return sw;
2194
2195   if (reader_table[slot].get_status_reader)
2196     sw = reader_table[slot].get_status_reader (slot, &s);
2197
2198   unlock_slot (slot);
2199
2200   if (sw)
2201     return sw;
2202
2203   if (status)
2204     *status = s;
2205   if (changed)
2206     *changed = reader_table[slot].change_counter;
2207   return 0;
2208 }
2209
2210
2211 /* Dispatcher for the actual send_apdu function. Note, that this
2212    function should be called in locked state. */
2213 static int
2214 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
2215            unsigned char *buffer, size_t *buflen)
2216 {
2217   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2218     return SW_HOST_NO_DRIVER;
2219
2220   if (reader_table[slot].send_apdu_reader)
2221     return reader_table[slot].send_apdu_reader (slot,
2222                                                 apdu, apdulen,
2223                                                 buffer, buflen);
2224   else
2225     return SW_HOST_NOT_SUPPORTED;
2226 }
2227
2228 /* Send an APDU to the card in SLOT.  The APDU is created from all
2229    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
2230    for LC won't sent this field and the data field; in this case DATA
2231    must also be passed as NULL.  The return value is the status word
2232    or -1 for an invalid SLOT or other non card related error.  If
2233    RETBUF is not NULL, it will receive an allocated buffer with the
2234    returned data.  The length of that data will be put into
2235    *RETBUFLEN.  The caller is reponsible for releasing the buffer even
2236    in case of errors.  */
2237 int 
2238 apdu_send_le(int slot, int class, int ins, int p0, int p1,
2239              int lc, const char *data, int le,
2240              unsigned char **retbuf, size_t *retbuflen)
2241 {
2242 #define RESULTLEN 256
2243   unsigned char result[RESULTLEN+10]; /* 10 extra in case of bugs in
2244                                          the driver. */
2245   size_t resultlen;
2246   unsigned char apdu[5+256+1];
2247   size_t apdulen;
2248   int sw;
2249   long rc; /* we need a long here due to PC/SC. */
2250
2251   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2252     return SW_HOST_NO_DRIVER;
2253
2254   if (DBG_CARD_IO)
2255     log_debug ("send apdu: c=%02X i=%02X p0=%02X p1=%02X lc=%d le=%d\n",
2256                class, ins, p0, p1, lc, le);
2257
2258   if (lc != -1 && (lc > 255 || lc < 0))
2259     return SW_WRONG_LENGTH; 
2260   if (le != -1 && (le > 256 || le < 1))
2261     return SW_WRONG_LENGTH; 
2262   if ((!data && lc != -1) || (data && lc == -1))
2263     return SW_HOST_INV_VALUE;
2264
2265   if ((sw = lock_slot (slot)))
2266     return sw;
2267
2268   apdulen = 0;
2269   apdu[apdulen++] = class;
2270   apdu[apdulen++] = ins;
2271   apdu[apdulen++] = p0;
2272   apdu[apdulen++] = p1;
2273   if (lc != -1)
2274     {
2275       apdu[apdulen++] = lc;
2276       memcpy (apdu+apdulen, data, lc);
2277       apdulen += lc;
2278     }
2279   if (le != -1)
2280     apdu[apdulen++] = le; /* Truncation is okay becuase 0 means 256. */
2281   assert (sizeof (apdu) >= apdulen);
2282   /* As safeguard don't pass any garbage from the stack to the driver. */
2283   memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
2284   resultlen = RESULTLEN;
2285   rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
2286   if (rc || resultlen < 2)
2287     {
2288       log_error ("apdu_send_simple(%d) failed: %s\n",
2289                  slot, apdu_strerror (rc));
2290       unlock_slot (slot);
2291       return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2292     }
2293   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2294   /* store away the returned data but strip the statusword. */
2295   resultlen -= 2;
2296   if (DBG_CARD_IO)
2297     {
2298       log_debug (" response: sw=%04X  datalen=%d\n", sw, resultlen);
2299       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
2300         log_printhex ("     dump: ", result, resultlen);
2301     }
2302
2303   if (sw == SW_SUCCESS || sw == SW_EOF_REACHED)
2304     {
2305       if (retbuf)
2306         {
2307           *retbuf = xtrymalloc (resultlen? resultlen : 1);
2308           if (!*retbuf)
2309             {
2310               unlock_slot (slot);
2311               return SW_HOST_OUT_OF_CORE;
2312             }
2313           *retbuflen = resultlen;
2314           memcpy (*retbuf, result, resultlen);
2315         }
2316     }
2317   else if ((sw & 0xff00) == SW_MORE_DATA)
2318     {
2319       unsigned char *p = NULL, *tmp;
2320       size_t bufsize = 4096;
2321
2322       /* It is likely that we need to return much more data, so we
2323          start off with a large buffer. */
2324       if (retbuf)
2325         {
2326           *retbuf = p = xtrymalloc (bufsize);
2327           if (!*retbuf)
2328             {
2329               unlock_slot (slot);
2330               return SW_HOST_OUT_OF_CORE;
2331             }
2332           assert (resultlen < bufsize);
2333           memcpy (p, result, resultlen);
2334           p += resultlen;
2335         }
2336
2337       do
2338         {
2339           int len = (sw & 0x00ff);
2340           
2341           if (DBG_CARD_IO)
2342             log_debug ("apdu_send_simple(%d): %d more bytes available\n",
2343                        slot, len);
2344           apdulen = 0;
2345           apdu[apdulen++] = class;
2346           apdu[apdulen++] = 0xC0;
2347           apdu[apdulen++] = 0;
2348           apdu[apdulen++] = 0;
2349           apdu[apdulen++] = len; 
2350           memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
2351           resultlen = RESULTLEN;
2352           rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
2353           if (rc || resultlen < 2)
2354             {
2355               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
2356                          slot, apdu_strerror (rc));
2357               unlock_slot (slot);
2358               return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2359             }
2360           sw = (result[resultlen-2] << 8) | result[resultlen-1];
2361           resultlen -= 2;
2362           if (DBG_CARD_IO)
2363             {
2364               log_debug ("     more: sw=%04X  datalen=%d\n", sw, resultlen);
2365               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
2366                 log_printhex ("     dump: ", result, resultlen);
2367             }
2368
2369           if ((sw & 0xff00) == SW_MORE_DATA
2370               || sw == SW_SUCCESS
2371               || sw == SW_EOF_REACHED )
2372             {
2373               if (retbuf && resultlen)
2374                 {
2375                   if (p - *retbuf + resultlen > bufsize)
2376                     {
2377                       bufsize += resultlen > 4096? resultlen: 4096;
2378                       tmp = xtryrealloc (*retbuf, bufsize);
2379                       if (!tmp)
2380                         {
2381                           unlock_slot (slot);
2382                           return SW_HOST_OUT_OF_CORE;
2383                         }
2384                       p = tmp + (p - *retbuf);
2385                       *retbuf = tmp;
2386                     }
2387                   memcpy (p, result, resultlen);
2388                   p += resultlen;
2389                 }
2390             }
2391           else
2392             log_info ("apdu_send_simple(%d) "
2393                       "got unexpected status %04X from get response\n",
2394                       slot, sw);
2395         }
2396       while ((sw & 0xff00) == SW_MORE_DATA);
2397       
2398       if (retbuf)
2399         {
2400           *retbuflen = p - *retbuf;
2401           tmp = xtryrealloc (*retbuf, *retbuflen);
2402           if (tmp)
2403             *retbuf = tmp;
2404         }
2405     }
2406
2407   unlock_slot (slot);
2408
2409   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
2410     log_printhex ("      dump: ", *retbuf, *retbuflen);
2411  
2412   return sw;
2413 #undef RESULTLEN
2414 }
2415
2416 /* Send an APDU to the card in SLOT.  The APDU is created from all
2417    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
2418    LC won't sent this field and the data field; in this case DATA must
2419    also be passed as NULL. The return value is the status word or -1
2420    for an invalid SLOT or other non card related error.  If RETBUF is
2421    not NULL, it will receive an allocated buffer with the returned
2422    data.  The length of that data will be put into *RETBUFLEN.  The
2423    caller is reponsible for releasing the buffer even in case of
2424    errors.  */
2425 int 
2426 apdu_send (int slot, int class, int ins, int p0, int p1,
2427            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
2428 {
2429   return apdu_send_le (slot, class, ins, p0, p1, lc, data, 256, 
2430                        retbuf, retbuflen);
2431 }
2432
2433 /* Send an APDU to the card in SLOT.  The APDU is created from all
2434    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
2435    LC won't sent this field and the data field; in this case DATA must
2436    also be passed as NULL. The return value is the status word or -1
2437    for an invalid SLOT or other non card related error.  No data will be
2438    returned. */
2439 int 
2440 apdu_send_simple (int slot, int class, int ins, int p0, int p1,
2441                   int lc, const char *data)
2442 {
2443   return apdu_send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL);
2444 }
2445
2446
2447 /* This is a more generic version of the apdu sending routine.  It
2448    takes an already formatted APDU in APDUDATA or length APDUDATALEN
2449    and returns the with the APDU including the status word.  With
2450    HANDLE_MORE set to true this function will handle the MORE DATA
2451    status and return all APDUs concatenated with one status word at
2452    the end.  The function does not return a regular status word but 0
2453    on success.  If the slot is locked, the fucntion returns
2454    immediately.*/
2455 int 
2456 apdu_send_direct (int slot, const unsigned char *apdudata, size_t apdudatalen,
2457                   int handle_more,
2458                   unsigned char **retbuf, size_t *retbuflen)
2459 {
2460 #define RESULTLEN 256
2461   unsigned char apdu[5+256+1];
2462   size_t apdulen;
2463   unsigned char result[RESULTLEN+10]; /* 10 extra in case of bugs in
2464                                          the driver. */
2465   size_t resultlen;
2466   int sw;
2467   long rc; /* we need a long here due to PC/SC. */
2468   int class;
2469
2470   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2471     return SW_HOST_NO_DRIVER;
2472
2473   if ((sw = trylock_slot (slot)))
2474     return sw;
2475
2476   /* We simply trucntate a too long APDU.  */
2477   if (apdudatalen > sizeof apdu)
2478     apdudatalen = sizeof apdu;
2479   apdulen = apdudatalen;
2480   memcpy (apdu, apdudata, apdudatalen);
2481   class = apdulen? *apdu : 0;
2482
2483
2484   rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
2485   if (rc || resultlen < 2)
2486     {
2487       log_error ("apdu_send_direct(%d) failed: %s\n",
2488                  slot, apdu_strerror (rc));
2489       unlock_slot (slot);
2490       return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2491     }
2492   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2493   /* Store away the returned data but strip the statusword. */
2494   resultlen -= 2;
2495   if (DBG_CARD_IO)
2496     {
2497       log_debug (" response: sw=%04X  datalen=%d\n", sw, resultlen);
2498       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
2499         log_printhex ("     dump: ", result, resultlen);
2500     }
2501
2502   if (handle_more && (sw & 0xff00) == SW_MORE_DATA)
2503     {
2504       unsigned char *p = NULL, *tmp;
2505       size_t bufsize = 4096;
2506
2507       /* It is likely that we need to return much more data, so we
2508          start off with a large buffer. */
2509       if (retbuf)
2510         {
2511           *retbuf = p = xtrymalloc (bufsize + 2);
2512           if (!*retbuf)
2513             {
2514               unlock_slot (slot);
2515               return SW_HOST_OUT_OF_CORE;
2516             }
2517           assert (resultlen < bufsize);
2518           memcpy (p, result, resultlen);
2519           p += resultlen;
2520         }
2521
2522       do
2523         {
2524           int len = (sw & 0x00ff);
2525           
2526           if (DBG_CARD_IO)
2527             log_debug ("apdu_send_direct(%d): %d more bytes available\n",
2528                        slot, len);
2529           apdulen = 0;
2530           apdu[apdulen++] = class;
2531           apdu[apdulen++] = 0xC0;
2532           apdu[apdulen++] = 0;
2533           apdu[apdulen++] = 0;
2534           apdu[apdulen++] = len; 
2535           memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
2536           resultlen = RESULTLEN;
2537           rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
2538           if (rc || resultlen < 2)
2539             {
2540               log_error ("apdu_send_direct(%d) for get response failed: %s\n",
2541                          slot, apdu_strerror (rc));
2542               unlock_slot (slot);
2543               return rc ? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2544             }
2545           sw = (result[resultlen-2] << 8) | result[resultlen-1];
2546           resultlen -= 2;
2547           if (DBG_CARD_IO)
2548             {
2549               log_debug ("     more: sw=%04X  datalen=%d\n", sw, resultlen);
2550               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
2551                 log_printhex ("     dump: ", result, resultlen);
2552             }
2553
2554           if ((sw & 0xff00) == SW_MORE_DATA
2555               || sw == SW_SUCCESS
2556               || sw == SW_EOF_REACHED )
2557             {
2558               if (retbuf && resultlen)
2559                 {
2560                   if (p - *retbuf + resultlen > bufsize)
2561                     {
2562                       bufsize += resultlen > 4096? resultlen: 4096;
2563                       tmp = xtryrealloc (*retbuf, bufsize + 2);
2564                       if (!tmp)
2565                         {
2566                           unlock_slot (slot);
2567                           return SW_HOST_OUT_OF_CORE;
2568                         }
2569                       p = tmp + (p - *retbuf);
2570                       *retbuf = tmp;
2571                     }
2572                   memcpy (p, result, resultlen);
2573                   p += resultlen;
2574                 }
2575             }
2576           else
2577             log_info ("apdu_send_sdirect(%d) "
2578                       "got unexpected status %04X from get response\n",
2579                       slot, sw);
2580         }
2581       while ((sw & 0xff00) == SW_MORE_DATA);
2582       
2583       if (retbuf)
2584         {
2585           *retbuflen = p - *retbuf;
2586           tmp = xtryrealloc (*retbuf, *retbuflen + 2);
2587           if (tmp)
2588             *retbuf = tmp;
2589         }
2590     }
2591   else
2592     {
2593       if (retbuf)
2594         {
2595           *retbuf = xtrymalloc ((resultlen? resultlen : 1)+2);
2596           if (!*retbuf)
2597             {
2598               unlock_slot (slot);
2599               return SW_HOST_OUT_OF_CORE;
2600             }
2601           *retbuflen = resultlen;
2602           memcpy (*retbuf, result, resultlen);
2603         }
2604     }
2605
2606   unlock_slot (slot);
2607
2608   /* Append the status word - we reseved the two extra bytes while
2609      allocating the buffer. */
2610   if (retbuf)
2611     {
2612       (*retbuf)[(*retbuflen)++] = (sw >> 8);
2613       (*retbuf)[(*retbuflen)++] = sw;
2614     }
2615
2616   if (DBG_CARD_IO && retbuf)
2617     log_printhex ("      dump: ", *retbuf, *retbuflen);
2618  
2619   return 0;
2620 #undef RESULTLEN
2621 }
2622
2623