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