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