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