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