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