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