2004-07-27 Moritz Schulte <moritz@g10code.com>
[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 #include <signal.h>
29 #ifdef USE_GNU_PTH
30 # include <pth.h>
31 # include <unistd.h>
32 # include <fcntl.h>
33 #endif
34 #ifdef HAVE_OPENSC
35 # include <opensc/opensc.h>
36 # ifdef USE_GNU_PTH
37 # undef USE_GNU_PTH
38 # endif
39 #endif
40
41 /* If requested include the definitions for the remote APDU protocol
42    code. */
43 #ifdef USE_G10CODE_RAPDU
44 #include "rapdu.h"
45 #endif /*USE_G10CODE_RAPDU*/
46
47 #if defined(GNUPG_SCD_MAIN_HEADER)
48 #include GNUPG_SCD_MAIN_HEADER
49 #elif GNUPG_MAJOR_VERSION == 1
50 /* This is used with GnuPG version < 1.9.  The code has been source
51    copied from the current GnuPG >= 1.9  and is maintained over
52    there. */
53 #include "options.h"
54 #include "errors.h"
55 #include "memory.h"
56 #include "util.h"
57 #include "i18n.h"
58 #include "cardglue.h"
59 #else /* GNUPG_MAJOR_VERSION != 1 */
60 #include "scdaemon.h"
61 #endif /* GNUPG_MAJOR_VERSION != 1 */
62
63 #include "apdu.h"
64 #include "dynload.h"
65 #include "ccid-driver.h"
66
67 #ifdef USE_GNU_PTH
68 #define NEED_PCSC_WRAPPER 1
69 #endif
70
71
72 #define MAX_READER 4 /* Number of readers we support concurrently. */
73
74
75 #ifdef _WIN32
76 #define DLSTDCALL __stdcall
77 #else
78 #define DLSTDCALL
79 #endif
80
81 #ifdef _POSIX_OPEN_MAX
82 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
83 #else
84 #define MAX_OPEN_FDS 20
85 #endif
86
87
88 /* A structure to collect information pertaining to one reader
89    slot. */
90 struct reader_table_s {
91   int used;            /* True if slot is used. */
92   unsigned short port; /* Port number:  0 = unused, 1 - dev/tty */
93
94   /* Function pointers intialized to the various backends.  */
95   int (*close_reader)(int);
96   int (*reset_reader)(int);
97   int (*get_status_reader)(int, unsigned int *);
98   int (*send_apdu_reader)(int,unsigned char *,size_t,
99                           unsigned char *, size_t *);
100   void (*dump_status_reader)(int);
101
102   struct {
103     ccid_driver_t handle;
104   } ccid;
105   struct {
106     unsigned long context;
107     unsigned long card;
108     unsigned long protocol;
109 #ifdef NEED_PCSC_WRAPPER
110     int req_fd;
111     int rsp_fd;
112     pid_t pid;
113 #endif /*NEED_PCSC_WRAPPER*/
114   } pcsc;
115 #ifdef HAVE_OPENSC
116   struct {
117     struct sc_context *ctx;
118     struct sc_card *scard;
119   } osc;
120 #endif /*HAVE_OPENSC*/
121 #ifdef USE_G10CODE_RAPDU
122   struct {
123     rapdu_t handle;
124   } rapdu;
125 #endif /*USE_G10CODE_RAPDU*/
126   int status;
127   unsigned char atr[33];
128   size_t atrlen;           /* A zero length indicates that the ATR has
129                               not yet been read; i.e. the card is not
130                               ready for use. */
131   unsigned int change_counter;
132 #ifdef USE_GNU_PTH
133   int lock_initialized;
134   pth_mutex_t lock;
135 #endif
136 };
137 typedef struct reader_table_s *reader_table_t;
138
139 /* A global table to keep track of active readers. */
140 static struct reader_table_s reader_table[MAX_READER];
141
142
143 /* ct API function pointer. */
144 static char (* DLSTDCALL CT_init) (unsigned short ctn, unsigned short Pn);
145 static char (* DLSTDCALL CT_data) (unsigned short ctn, unsigned char *dad,
146                                    unsigned char *sad, unsigned short lc,
147                                    unsigned char *cmd, unsigned short *lr,
148                                    unsigned char *rsp);
149 static char (* DLSTDCALL CT_close) (unsigned short ctn);
150
151 /* PC/SC constants and function pointer. */
152 #define PCSC_SCOPE_USER      0 
153 #define PCSC_SCOPE_TERMINAL  1 
154 #define PCSC_SCOPE_SYSTEM    2 
155 #define PCSC_SCOPE_GLOBAL    3 
156
157 #define PCSC_PROTOCOL_T0     1 
158 #define PCSC_PROTOCOL_T1     2 
159 #define PCSC_PROTOCOL_RAW    4 
160
161 #define PCSC_SHARE_EXCLUSIVE 1
162 #define PCSC_SHARE_SHARED    2
163 #define PCSC_SHARE_DIRECT    3
164
165 #define PCSC_LEAVE_CARD      0
166 #define PCSC_RESET_CARD      1
167 #define PCSC_UNPOWER_CARD    2
168 #define PCSC_EJECT_CARD      3
169
170 struct pcsc_io_request_s {
171   unsigned long protocol; 
172   unsigned long pci_len;
173 };
174
175 typedef struct pcsc_io_request_s *pcsc_io_request_t;
176
177 long (* DLSTDCALL pcsc_establish_context) (unsigned long scope,
178                                            const void *reserved1,
179                                            const void *reserved2,
180                                            unsigned long *r_context);
181 long (* DLSTDCALL pcsc_release_context) (unsigned long context);
182 long (* DLSTDCALL pcsc_list_readers) (unsigned long context,
183                                       const char *groups,
184                                       char *readers, unsigned long*readerslen);
185 long (* DLSTDCALL pcsc_connect) (unsigned long context,
186                                  const char *reader,
187                                  unsigned long share_mode,
188                                  unsigned long preferred_protocols,
189                                  unsigned long *r_card,
190                                  unsigned long *r_active_protocol);
191 long (* DLSTDCALL pcsc_disconnect) (unsigned long card,
192                                     unsigned long disposition);
193 long (* DLSTDCALL pcsc_status) (unsigned long card,
194                                 char *reader, unsigned long *readerlen,
195                                 unsigned long *r_state,
196                                 unsigned long *r_protocol,
197                                 unsigned char *atr, unsigned long *atrlen);
198 long (* DLSTDCALL pcsc_begin_transaction) (unsigned long card);
199 long (* DLSTDCALL pcsc_end_transaction) (unsigned long card);
200 long (* DLSTDCALL pcsc_transmit) (unsigned long card,
201                                   const pcsc_io_request_t send_pci,
202                                   const unsigned char *send_buffer,
203                                   unsigned long send_len,
204                                   pcsc_io_request_t recv_pci,
205                                   unsigned char *recv_buffer,
206                                   unsigned long *recv_len);
207 long (* DLSTDCALL pcsc_set_timeout) (unsigned long context,
208                                      unsigned long timeout);
209
210
211
212
213 \f
214 /* 
215       Helper
216  */
217  
218
219 /* Find an unused reader slot for PORTSTR and put it into the reader
220    table.  Return -1 on error or the index into the reader table. */
221 static int 
222 new_reader_slot (void)    
223 {
224   int i, reader = -1;
225
226   for (i=0; i < MAX_READER; i++)
227     {
228       if (!reader_table[i].used && reader == -1)
229         reader = i;
230     }
231   if (reader == -1)
232     {
233       log_error ("new_reader_slot: out of slots\n");
234       return -1;
235     }
236 #ifdef USE_GNU_PTH
237   if (!reader_table[reader].lock_initialized)
238     {
239       if (!pth_mutex_init (&reader_table[reader].lock))
240         {
241           log_error ("error initializing mutex: %s\n", strerror (errno));
242           return -1;
243         }
244       reader_table[reader].lock_initialized = 1;
245     }
246 #endif /*USE_GNU_PTH*/
247   reader_table[reader].close_reader = NULL;
248   reader_table[reader].reset_reader = NULL;
249   reader_table[reader].get_status_reader = NULL;
250   reader_table[reader].send_apdu_reader = NULL;
251   reader_table[reader].dump_status_reader = NULL;
252
253   reader_table[reader].used = 1;
254 #ifdef NEED_PCSC_WRAPPER
255   reader_table[reader].pcsc.req_fd = -1;
256   reader_table[reader].pcsc.rsp_fd = -1;
257   reader_table[reader].pcsc.pid = (pid_t)(-1);
258 #endif
259   return reader;
260 }
261
262
263 static void
264 dump_reader_status (int slot)
265 {
266   if (!opt.verbose)
267     return;
268
269   if (reader_table[slot].dump_status_reader)
270     reader_table[slot].dump_status_reader (slot);
271
272   if (reader_table[slot].status != -1
273       && reader_table[slot].atrlen)
274     {
275       log_info ("slot %d: ATR=", slot);
276       log_printhex ("", reader_table[slot].atr, reader_table[slot].atrlen);
277     }
278 }
279
280
281
282 static const char *
283 host_sw_string (long err)
284 {
285   switch (err)
286     {
287     case 0: return "okay";
288     case SW_HOST_OUT_OF_CORE: return "out of core";
289     case SW_HOST_INV_VALUE: return "invalid value";
290     case SW_HOST_NO_DRIVER: return "no driver";
291     case SW_HOST_NOT_SUPPORTED: return "not supported";
292     case SW_HOST_LOCKING_FAILED: return "locking failed";
293     case SW_HOST_BUSY: return "busy";
294     case SW_HOST_NO_CARD: return "no card";
295     case SW_HOST_CARD_INACTIVE: return "card inactive";
296     case SW_HOST_CARD_IO_ERROR: return "card I/O error";
297     case SW_HOST_GENERAL_ERROR: return "general error";
298     case SW_HOST_NO_READER: return "no reader";
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   return SW_HOST_NOT_SUPPORTED;
1637 }
1638
1639
1640 /* Actually send the APDU of length APDULEN to SLOT and return a
1641    maximum of *BUFLEN data in BUFFER, the actual returned size will be
1642    set to BUFLEN.  Returns: OpenSC error code. */
1643 static int
1644 my_rapdu_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
1645                     unsigned char *buffer, size_t *buflen)
1646 {
1647   int err;
1648   reader_table_t slotp;
1649   rapdu_msg_t msg = NULL;
1650   size_t maxlen = *buflen;
1651
1652   slotp = reader_table + slot;
1653
1654   *buflen = 0;
1655   if (DBG_CARD_IO)
1656     log_printhex ("  APDU_data:", apdu, apdulen);
1657
1658   if (apdulen < 4)
1659     {
1660       log_error ("rapdu_send_apdu: APDU is too short\n");
1661       return SW_HOST_INV_VALUE;
1662     }
1663
1664   err = rapdu_send_apdu (slotp->rapdu.handle, apdu, apdulen);
1665   if (err)
1666     {
1667       log_error ("sending rapdu command APDU failed: %s\n",
1668                 err < 0 ? strerror (errno): rapdu_strerror (err));
1669       rapdu_msg_release (msg);
1670       return rapdu_status_to_sw (err);
1671     }
1672   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
1673   if (err)
1674     {
1675       log_error ("receiving rapdu message failed: %s\n",
1676                 err < 0 ? strerror (errno): rapdu_strerror (err));
1677       rapdu_msg_release (msg);
1678       return rapdu_status_to_sw (err);
1679     }
1680   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
1681     {
1682       int sw = rapdu_status_to_sw (msg->cmd);
1683       log_error ("rapdu command APDU failed: %s\n",
1684                  rapdu_strerror (msg->cmd));
1685       rapdu_msg_release (msg);
1686       return sw;
1687     }
1688   
1689   if (msg->datalen > maxlen)
1690     {
1691       log_error ("rapdu response apdu too large\n");
1692       rapdu_msg_release (msg);
1693       return SW_HOST_INV_VALUE; 
1694     }
1695
1696   *buflen = msg->datalen;
1697   memcpy (buffer, msg->data, msg->datalen);
1698
1699   rapdu_msg_release (msg);
1700   return 0;
1701 }
1702
1703 static int
1704 open_rapdu_reader (int portno,
1705                    const unsigned char *cookie, size_t length,
1706                    int (*readfnc) (void *opaque,
1707                                    void *buffer, size_t size),
1708                    void *readfnc_value,
1709                    int (*writefnc) (void *opaque,
1710                                     const void *buffer, size_t size),
1711                    void *writefnc_value,
1712                    void (*closefnc) (void *opaque),
1713                    void *closefnc_value)
1714 {
1715   int err;
1716   int slot;
1717   reader_table_t slotp;
1718   rapdu_msg_t msg = NULL;
1719
1720   slot = new_reader_slot ();
1721   if (slot == -1)
1722     return -1;
1723   slotp = reader_table + slot;
1724
1725   slotp->rapdu.handle = rapdu_new ();
1726   if (!slotp->rapdu.handle)
1727     {
1728       slotp->used = 0;
1729       return -1;
1730     }
1731
1732
1733   rapdu_set_iofunc (slotp->rapdu.handle,
1734                     readfnc, readfnc_value,
1735                     writefnc, writefnc_value,
1736                     closefnc, closefnc_value);
1737   rapdu_set_cookie (slotp->rapdu.handle, cookie, length);
1738
1739   /* First try to get the current ATR, but if the card is inactive
1740      issue a reset instead.  */
1741   err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_GET_ATR);
1742   if (err == RAPDU_STATUS_NEEDRESET)
1743     err = rapdu_send_cmd (slotp->rapdu.handle, RAPDU_CMD_RESET);
1744   if (err)
1745     {
1746       log_info ("sending rapdu command GET_ATR/RESET failed: %s\n",
1747                 err < 0 ? strerror (errno): rapdu_strerror (err));
1748       goto failure;
1749     }
1750   err = rapdu_read_msg (slotp->rapdu.handle, &msg);
1751   if (err)
1752     {
1753       log_info ("receiving rapdu message failed: %s\n",
1754                 err < 0 ? strerror (errno): rapdu_strerror (err));
1755       goto failure;
1756     }
1757   if (msg->cmd != RAPDU_STATUS_SUCCESS || !msg->datalen)
1758     {
1759       log_info ("rapdu command GET ATR failed: %s\n",
1760                  rapdu_strerror (msg->cmd));
1761       goto failure;
1762     }
1763   if (msg->datalen >= DIM (slotp->atr))
1764     {
1765       log_error ("ATR returned by the RAPDU layer is too large\n");
1766       goto failure;
1767     }
1768   slotp->atrlen = msg->datalen;
1769   memcpy (slotp->atr, msg->data, msg->datalen);
1770
1771   reader_table[slot].close_reader = close_rapdu_reader;
1772   reader_table[slot].reset_reader = reset_rapdu_reader;
1773   reader_table[slot].get_status_reader = my_rapdu_get_status;
1774   reader_table[slot].send_apdu_reader = my_rapdu_send_apdu;
1775   reader_table[slot].dump_status_reader = NULL;
1776
1777   dump_reader_status (slot); 
1778   rapdu_msg_release (msg);
1779   return slot;
1780
1781  failure:      
1782   rapdu_msg_release (msg);
1783   rapdu_release (slotp->rapdu.handle);
1784   slotp->used = 0;
1785   return -1;
1786 }
1787
1788 #endif /*USE_G10CODE_RAPDU*/
1789
1790
1791 \f
1792 /* 
1793        Driver Access
1794  */
1795
1796
1797 static int
1798 lock_slot (int slot)
1799 {
1800 #ifdef USE_GNU_PTH
1801   if (!pth_mutex_acquire (&reader_table[slot].lock, 0, NULL))
1802     {
1803       log_error ("failed to acquire apdu lock: %s\n", strerror (errno));
1804       return SW_HOST_LOCKING_FAILED;
1805     }
1806 #endif /*USE_GNU_PTH*/
1807   return 0;
1808 }
1809
1810 static int
1811 trylock_slot (int slot)
1812 {
1813 #ifdef USE_GNU_PTH
1814   if (!pth_mutex_acquire (&reader_table[slot].lock, TRUE, NULL))
1815     {
1816       if (errno == EBUSY)
1817         return SW_HOST_BUSY;
1818       log_error ("failed to acquire apdu lock: %s\n", strerror (errno));
1819       return SW_HOST_LOCKING_FAILED;
1820     }
1821 #endif /*USE_GNU_PTH*/
1822   return 0;
1823 }
1824
1825 static void
1826 unlock_slot (int slot)
1827 {
1828 #ifdef USE_GNU_PTH
1829   if (!pth_mutex_release (&reader_table[slot].lock))
1830     log_error ("failed to release apdu lock: %s\n", strerror (errno));
1831 #endif /*USE_GNU_PTH*/
1832 }
1833
1834
1835 /* Open the reader and return an internal slot number or -1 on
1836    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
1837    the first USB reader.  For PC/SC the first listed reader).  If
1838    OpenSC support is compiled in, we first try to use OpenSC. */
1839 int
1840 apdu_open_reader (const char *portstr)
1841 {
1842   static int pcsc_api_loaded, ct_api_loaded;
1843
1844 #ifdef HAVE_LIBUSB
1845   if (!opt.disable_ccid)
1846     {
1847       int slot;
1848
1849       slot = open_ccid_reader ();
1850       if (slot != -1)
1851         return slot; /* got one */
1852     }
1853 #endif /* HAVE_LIBUSB */
1854
1855 #ifdef HAVE_OPENSC
1856   if (!opt.disable_opensc)
1857     {
1858       int port = portstr? atoi (portstr) : 0;
1859
1860       return open_osc_reader (port);
1861     }
1862 #endif /* HAVE_OPENSC */  
1863
1864
1865   if (opt.ctapi_driver && *opt.ctapi_driver)
1866     {
1867       int port = portstr? atoi (portstr) : 32768;
1868
1869       if (!ct_api_loaded)
1870         {
1871           void *handle;
1872           
1873           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
1874           if (!handle)
1875             {
1876               log_error ("apdu_open_reader: failed to open driver: %s\n",
1877                          dlerror ());
1878               return -1;
1879             }
1880           CT_init = dlsym (handle, "CT_init");
1881           CT_data = dlsym (handle, "CT_data");
1882           CT_close = dlsym (handle, "CT_close");
1883           if (!CT_init || !CT_data || !CT_close)
1884             {
1885               log_error ("apdu_open_reader: invalid CT-API driver\n");
1886               dlclose (handle);
1887               return -1;
1888             }
1889           ct_api_loaded = 1;
1890         }
1891       return open_ct_reader (port);
1892     }
1893
1894   
1895   /* No ctAPI configured, so lets try the PC/SC API */
1896   if (!pcsc_api_loaded)
1897     {
1898 #ifndef NEED_PCSC_WRAPPER
1899       void *handle;
1900
1901       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
1902       if (!handle)
1903         {
1904           log_error ("apdu_open_reader: failed to open driver `%s': %s\n",
1905                      opt.pcsc_driver, dlerror ());
1906           return -1;
1907         }
1908
1909       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
1910       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
1911       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
1912 #ifdef _WIN32
1913       if (!pcsc_list_readers)
1914         pcsc_list_readers    = dlsym (handle, "SCardListReadersA");
1915 #endif
1916       pcsc_connect           = dlsym (handle, "SCardConnect");
1917 #ifdef _WIN32
1918       if (!pcsc_connect)
1919         pcsc_connect         = dlsym (handle, "SCardConnectA");
1920 #endif
1921       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
1922       pcsc_status            = dlsym (handle, "SCardStatus");
1923 #ifdef _WIN32
1924       if (!pcsc_status)
1925         pcsc_status          = dlsym (handle, "SCardStatusA");
1926 #endif
1927       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
1928       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
1929       pcsc_transmit          = dlsym (handle, "SCardTransmit");
1930       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
1931
1932       if (!pcsc_establish_context
1933           || !pcsc_release_context  
1934           || !pcsc_list_readers     
1935           || !pcsc_connect          
1936           || !pcsc_disconnect
1937           || !pcsc_status
1938           || !pcsc_begin_transaction
1939           || !pcsc_end_transaction
1940           || !pcsc_transmit         
1941           /* || !pcsc_set_timeout */)
1942         {
1943           /* Note that set_timeout is currently not used and also not
1944              available under Windows. */
1945           log_error ("apdu_open_reader: invalid PC/SC driver "
1946                      "(%d%d%d%d%d%d%d%d%d%d)\n",
1947                      !!pcsc_establish_context,
1948                      !!pcsc_release_context,  
1949                      !!pcsc_list_readers,     
1950                      !!pcsc_connect,          
1951                      !!pcsc_disconnect,
1952                      !!pcsc_status,
1953                      !!pcsc_begin_transaction,
1954                      !!pcsc_end_transaction,
1955                      !!pcsc_transmit,         
1956                      !!pcsc_set_timeout );
1957           dlclose (handle);
1958           return -1;
1959         }
1960 #endif /*!NEED_PCSC_WRAPPER*/  
1961       pcsc_api_loaded = 1;
1962     }
1963
1964   return open_pcsc_reader (portstr);
1965 }
1966
1967
1968 /* Open an remote reader and return an internal slot number or -1 on
1969    error. This function is an alternative to apdu_open_reader and used
1970    with remote readers only.  Note that the supplied CLOSEFNC will
1971    only be called once and the slot will not be valid afther this.
1972
1973    If PORTSTR is NULL we default to the first availabe port.
1974 */  
1975 int
1976 apdu_open_remote_reader (const char *portstr,
1977                          const unsigned char *cookie, size_t length,
1978                          int (*readfnc) (void *opaque,
1979                                          void *buffer, size_t size),
1980                          void *readfnc_value,
1981                          int (*writefnc) (void *opaque,
1982                                           const void *buffer, size_t size),
1983                          void *writefnc_value,
1984                          void (*closefnc) (void *opaque),
1985                          void *closefnc_value)
1986 {
1987 #ifdef USE_G10CODE_RAPDU
1988   return open_rapdu_reader (portstr? atoi (portstr) : 0,
1989                             cookie, length,
1990                             readfnc, readfnc_value,
1991                             writefnc, writefnc_value,
1992                             closefnc, closefnc_value);
1993 #else
1994   errno = ENOSYS;
1995   return -1;
1996 #endif
1997 }
1998
1999
2000 int
2001 apdu_close_reader (int slot)
2002 {
2003   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2004     return SW_HOST_NO_DRIVER;
2005   if (reader_table[slot].close_reader)
2006     return reader_table[slot].close_reader (slot);
2007   return SW_HOST_NOT_SUPPORTED;
2008 }
2009
2010 /* Enumerate all readers and return information on whether this reader
2011    is in use.  The caller should start with SLOT set to 0 and
2012    increment it with each call until an error is returned. */
2013 int
2014 apdu_enum_reader (int slot, int *used)
2015 {
2016   if (slot < 0 || slot >= MAX_READER)
2017     return SW_HOST_NO_DRIVER;
2018   *used = reader_table[slot].used;
2019   return 0;
2020 }
2021
2022 /* Do a reset for the card in reader at SLOT. */
2023 int
2024 apdu_reset (int slot)
2025 {
2026   int sw;
2027
2028   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2029     return SW_HOST_NO_DRIVER;
2030   
2031   if ((sw = lock_slot (slot)))
2032     return sw;
2033
2034   if (reader_table[slot].reset_reader)
2035     sw = reader_table[slot].reset_reader (slot);
2036
2037   unlock_slot (slot);
2038   return sw;
2039 }
2040
2041
2042 /* Activate a card if it has not yet been done.  This is a kind of
2043    reset-if-required.  It is useful to test for presence of a card
2044    before issuing a bunch of apdu commands.  It does not wait on a
2045    locked card. */
2046 int
2047 apdu_activate (int slot)
2048 {
2049   int sw;
2050   unsigned int s;
2051
2052   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2053     return SW_HOST_NO_DRIVER;
2054   
2055   if ((sw = trylock_slot (slot)))
2056     return sw;
2057
2058   if (reader_table[slot].get_status_reader)
2059     sw = reader_table[slot].get_status_reader (slot, &s);
2060
2061   if (!sw)
2062     {
2063       if (!(s & 2))  /* Card not present.  */
2064         sw = SW_HOST_NO_CARD;
2065       else if ( ((s & 2) && !(s & 4))
2066                 || !reader_table[slot].atrlen )
2067         {
2068           /* We don't have an ATR or a card is present though inactive:
2069              do a reset now. */
2070           if (reader_table[slot].reset_reader)
2071             sw = reader_table[slot].reset_reader (slot);
2072         }
2073     }
2074   
2075   unlock_slot (slot);
2076   return sw;
2077 }
2078
2079   
2080
2081 unsigned char *
2082 apdu_get_atr (int slot, size_t *atrlen)
2083 {
2084   char *buf;
2085
2086   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2087     return NULL;
2088   
2089   buf = xtrymalloc (reader_table[slot].atrlen);
2090   if (!buf)
2091     return NULL;
2092   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
2093   *atrlen = reader_table[slot].atrlen;
2094   return buf;
2095 }
2096
2097
2098     
2099 /* Retrieve the status for SLOT. The function does only wait for the
2100    card to become available if HANG is set to true. On success the
2101    bits in STATUS will be set to
2102
2103      bit 0 = card present and usable
2104      bit 1 = card present
2105      bit 2 = card active
2106      bit 3 = card access locked [not yet implemented]
2107
2108    For must application, testing bit 0 is sufficient.
2109
2110    CHANGED will receive the value of the counter tracking the number
2111    of card insertions.  This value may be used to detect a card
2112    change.
2113 */
2114 int
2115 apdu_get_status (int slot, int hang,
2116                  unsigned int *status, unsigned int *changed)
2117 {
2118   int sw;
2119   unsigned int s;
2120
2121   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2122     return SW_HOST_NO_DRIVER;
2123
2124   if ((sw = hang? lock_slot (slot) : trylock_slot (slot)))
2125     return sw;
2126
2127   if (reader_table[slot].get_status_reader)
2128     sw = reader_table[slot].get_status_reader (slot, &s);
2129
2130   unlock_slot (slot);
2131
2132   if (sw)
2133     return sw;
2134
2135   if (status)
2136     *status = s;
2137   if (changed)
2138     *changed = reader_table[slot].change_counter;
2139   return 0;
2140 }
2141
2142
2143 /* Dispatcher for the actual send_apdu function. Note, that this
2144    function should be called in locked state. */
2145 static int
2146 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
2147            unsigned char *buffer, size_t *buflen)
2148 {
2149   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2150     return SW_HOST_NO_DRIVER;
2151
2152   if (reader_table[slot].send_apdu_reader)
2153     return reader_table[slot].send_apdu_reader (slot,
2154                                                 apdu, apdulen,
2155                                                 buffer, buflen);
2156   else
2157     return SW_HOST_NOT_SUPPORTED;
2158 }
2159
2160 /* Send an APDU to the card in SLOT.  The APDU is created from all
2161    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
2162    for LC won't sent this field and the data field; in this case DATA
2163    must also be passed as NULL.  The return value is the status word
2164    or -1 for an invalid SLOT or other non card related error.  If
2165    RETBUF is not NULL, it will receive an allocated buffer with the
2166    returned data.  The length of that data will be put into
2167    *RETBUFLEN.  The caller is reponsible for releasing the buffer even
2168    in case of errors.  */
2169 int 
2170 apdu_send_le(int slot, int class, int ins, int p0, int p1,
2171              int lc, const char *data, int le,
2172              unsigned char **retbuf, size_t *retbuflen)
2173 {
2174 #define RESULTLEN 256
2175   unsigned char result[RESULTLEN+10]; /* 10 extra in case of bugs in
2176                                          the driver. */
2177   size_t resultlen;
2178   unsigned char apdu[5+256+1];
2179   size_t apdulen;
2180   int sw;
2181   long rc; /* we need a long here due to PC/SC. */
2182
2183   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2184     return SW_HOST_NO_DRIVER;
2185
2186   if (DBG_CARD_IO)
2187     log_debug ("send apdu: c=%02X i=%02X p0=%02X p1=%02X lc=%d le=%d\n",
2188                class, ins, p0, p1, lc, le);
2189
2190   if (lc != -1 && (lc > 255 || lc < 0))
2191     return SW_WRONG_LENGTH; 
2192   if (le != -1 && (le > 256 || le < 1))
2193     return SW_WRONG_LENGTH; 
2194   if ((!data && lc != -1) || (data && lc == -1))
2195     return SW_HOST_INV_VALUE;
2196
2197   if ((sw = lock_slot (slot)))
2198     return sw;
2199
2200   apdulen = 0;
2201   apdu[apdulen++] = class;
2202   apdu[apdulen++] = ins;
2203   apdu[apdulen++] = p0;
2204   apdu[apdulen++] = p1;
2205   if (lc != -1)
2206     {
2207       apdu[apdulen++] = lc;
2208       memcpy (apdu+apdulen, data, lc);
2209       apdulen += lc;
2210     }
2211   if (le != -1)
2212     apdu[apdulen++] = le; /* Truncation is okay becuase 0 means 256. */
2213   assert (sizeof (apdu) >= apdulen);
2214   /* As safeguard don't pass any garbage from the stack to the driver. */
2215   memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
2216   resultlen = RESULTLEN;
2217   rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
2218   if (rc || resultlen < 2)
2219     {
2220       log_error ("apdu_send_simple(%d) failed: %s\n",
2221                  slot, apdu_strerror (rc));
2222       unlock_slot (slot);
2223       return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2224     }
2225   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2226   /* store away the returned data but strip the statusword. */
2227   resultlen -= 2;
2228   if (DBG_CARD_IO)
2229     {
2230       log_debug (" response: sw=%04X  datalen=%d\n", sw, resultlen);
2231       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
2232         log_printhex ("     dump: ", result, resultlen);
2233     }
2234
2235   if (sw == SW_SUCCESS || sw == SW_EOF_REACHED)
2236     {
2237       if (retbuf)
2238         {
2239           *retbuf = xtrymalloc (resultlen? resultlen : 1);
2240           if (!*retbuf)
2241             {
2242               unlock_slot (slot);
2243               return SW_HOST_OUT_OF_CORE;
2244             }
2245           *retbuflen = resultlen;
2246           memcpy (*retbuf, result, resultlen);
2247         }
2248     }
2249   else if ((sw & 0xff00) == SW_MORE_DATA)
2250     {
2251       unsigned char *p = NULL, *tmp;
2252       size_t bufsize = 4096;
2253
2254       /* It is likely that we need to return much more data, so we
2255          start off with a large buffer. */
2256       if (retbuf)
2257         {
2258           *retbuf = p = xtrymalloc (bufsize);
2259           if (!*retbuf)
2260             {
2261               unlock_slot (slot);
2262               return SW_HOST_OUT_OF_CORE;
2263             }
2264           assert (resultlen < bufsize);
2265           memcpy (p, result, resultlen);
2266           p += resultlen;
2267         }
2268
2269       do
2270         {
2271           int len = (sw & 0x00ff);
2272           
2273           if (DBG_CARD_IO)
2274             log_debug ("apdu_send_simple(%d): %d more bytes available\n",
2275                        slot, len);
2276           apdulen = 0;
2277           apdu[apdulen++] = class;
2278           apdu[apdulen++] = 0xC0;
2279           apdu[apdulen++] = 0;
2280           apdu[apdulen++] = 0;
2281           apdu[apdulen++] = len; 
2282           memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
2283           resultlen = RESULTLEN;
2284           rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
2285           if (rc || resultlen < 2)
2286             {
2287               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
2288                          slot, apdu_strerror (rc));
2289               unlock_slot (slot);
2290               return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2291             }
2292           sw = (result[resultlen-2] << 8) | result[resultlen-1];
2293           resultlen -= 2;
2294           if (DBG_CARD_IO)
2295             {
2296               log_debug ("     more: sw=%04X  datalen=%d\n", sw, resultlen);
2297               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
2298                 log_printhex ("     dump: ", result, resultlen);
2299             }
2300
2301           if ((sw & 0xff00) == SW_MORE_DATA
2302               || sw == SW_SUCCESS
2303               || sw == SW_EOF_REACHED )
2304             {
2305               if (retbuf && resultlen)
2306                 {
2307                   if (p - *retbuf + resultlen > bufsize)
2308                     {
2309                       bufsize += resultlen > 4096? resultlen: 4096;
2310                       tmp = xtryrealloc (*retbuf, bufsize);
2311                       if (!tmp)
2312                         {
2313                           unlock_slot (slot);
2314                           return SW_HOST_OUT_OF_CORE;
2315                         }
2316                       p = tmp + (p - *retbuf);
2317                       *retbuf = tmp;
2318                     }
2319                   memcpy (p, result, resultlen);
2320                   p += resultlen;
2321                 }
2322             }
2323           else
2324             log_info ("apdu_send_simple(%d) "
2325                       "got unexpected status %04X from get response\n",
2326                       slot, sw);
2327         }
2328       while ((sw & 0xff00) == SW_MORE_DATA);
2329       
2330       if (retbuf)
2331         {
2332           *retbuflen = p - *retbuf;
2333           tmp = xtryrealloc (*retbuf, *retbuflen);
2334           if (tmp)
2335             *retbuf = tmp;
2336         }
2337     }
2338
2339   unlock_slot (slot);
2340
2341   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
2342     log_printhex ("      dump: ", *retbuf, *retbuflen);
2343  
2344   return sw;
2345 #undef RESULTLEN
2346 }
2347
2348 /* Send an APDU to the card in SLOT.  The APDU is created from all
2349    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
2350    LC won't sent this field and the data field; in this case DATA must
2351    also be passed as NULL. The return value is the status word or -1
2352    for an invalid SLOT or other non card related error.  If RETBUF is
2353    not NULL, it will receive an allocated buffer with the returned
2354    data.  The length of that data will be put into *RETBUFLEN.  The
2355    caller is reponsible for releasing the buffer even in case of
2356    errors.  */
2357 int 
2358 apdu_send (int slot, int class, int ins, int p0, int p1,
2359            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
2360 {
2361   return apdu_send_le (slot, class, ins, p0, p1, lc, data, 256, 
2362                        retbuf, retbuflen);
2363 }
2364
2365 /* Send an APDU to the card in SLOT.  The APDU is created from all
2366    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
2367    LC won't sent this field and the data field; in this case DATA must
2368    also be passed as NULL. The return value is the status word or -1
2369    for an invalid SLOT or other non card related error.  No data will be
2370    returned. */
2371 int 
2372 apdu_send_simple (int slot, int class, int ins, int p0, int p1,
2373                   int lc, const char *data)
2374 {
2375   return apdu_send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL);
2376 }
2377
2378
2379 /* This is a more generic version of the apdu sending routine.  It
2380    takes an already formatted APDU in APDUDATA or length APDUDATALEN
2381    and returns the with the APDU including the status word.  With
2382    HANDLE_MORE set to true this function will handle the MORE DATA
2383    status and return all APDUs concatenated with one status word at
2384    the end.  The function does not return a regular status word but 0
2385    on success.  If the slot is locked, the fucntion returns
2386    immediately.*/
2387 int 
2388 apdu_send_direct (int slot, const unsigned char *apdudata, size_t apdudatalen,
2389                   int handle_more,
2390                   unsigned char **retbuf, size_t *retbuflen)
2391 {
2392 #define RESULTLEN 256
2393   unsigned char apdu[5+256+1];
2394   size_t apdulen;
2395   unsigned char result[RESULTLEN+10]; /* 10 extra in case of bugs in
2396                                          the driver. */
2397   size_t resultlen;
2398   int sw;
2399   long rc; /* we need a long here due to PC/SC. */
2400   int class;
2401
2402   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
2403     return SW_HOST_NO_DRIVER;
2404
2405   if ((sw = trylock_slot (slot)))
2406     return sw;
2407
2408   /* We simply trucntate a too long APDU.  */
2409   if (apdudatalen > sizeof apdu)
2410     apdudatalen = sizeof apdu;
2411   apdulen = apdudatalen;
2412   memcpy (apdu, apdudata, apdudatalen);
2413   class = apdulen? *apdu : 0;
2414
2415
2416   rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
2417   if (rc || resultlen < 2)
2418     {
2419       log_error ("apdu_send_direct(%d) failed: %s\n",
2420                  slot, apdu_strerror (rc));
2421       unlock_slot (slot);
2422       return rc? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2423     }
2424   sw = (result[resultlen-2] << 8) | result[resultlen-1];
2425   /* Store away the returned data but strip the statusword. */
2426   resultlen -= 2;
2427   if (DBG_CARD_IO)
2428     {
2429       log_debug (" response: sw=%04X  datalen=%d\n", sw, resultlen);
2430       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
2431         log_printhex ("     dump: ", result, resultlen);
2432     }
2433
2434   if (handle_more && (sw & 0xff00) == SW_MORE_DATA)
2435     {
2436       unsigned char *p = NULL, *tmp;
2437       size_t bufsize = 4096;
2438
2439       /* It is likely that we need to return much more data, so we
2440          start off with a large buffer. */
2441       if (retbuf)
2442         {
2443           *retbuf = p = xtrymalloc (bufsize + 2);
2444           if (!*retbuf)
2445             {
2446               unlock_slot (slot);
2447               return SW_HOST_OUT_OF_CORE;
2448             }
2449           assert (resultlen < bufsize);
2450           memcpy (p, result, resultlen);
2451           p += resultlen;
2452         }
2453
2454       do
2455         {
2456           int len = (sw & 0x00ff);
2457           
2458           if (DBG_CARD_IO)
2459             log_debug ("apdu_send_direct(%d): %d more bytes available\n",
2460                        slot, len);
2461           apdulen = 0;
2462           apdu[apdulen++] = class;
2463           apdu[apdulen++] = 0xC0;
2464           apdu[apdulen++] = 0;
2465           apdu[apdulen++] = 0;
2466           apdu[apdulen++] = len; 
2467           memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
2468           resultlen = RESULTLEN;
2469           rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
2470           if (rc || resultlen < 2)
2471             {
2472               log_error ("apdu_send_direct(%d) for get response failed: %s\n",
2473                          slot, apdu_strerror (rc));
2474               unlock_slot (slot);
2475               return rc ? rc : SW_HOST_INCOMPLETE_CARD_RESPONSE;
2476             }
2477           sw = (result[resultlen-2] << 8) | result[resultlen-1];
2478           resultlen -= 2;
2479           if (DBG_CARD_IO)
2480             {
2481               log_debug ("     more: sw=%04X  datalen=%d\n", sw, resultlen);
2482               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
2483                 log_printhex ("     dump: ", result, resultlen);
2484             }
2485
2486           if ((sw & 0xff00) == SW_MORE_DATA
2487               || sw == SW_SUCCESS
2488               || sw == SW_EOF_REACHED )
2489             {
2490               if (retbuf && resultlen)
2491                 {
2492                   if (p - *retbuf + resultlen > bufsize)
2493                     {
2494                       bufsize += resultlen > 4096? resultlen: 4096;
2495                       tmp = xtryrealloc (*retbuf, bufsize + 2);
2496                       if (!tmp)
2497                         {
2498                           unlock_slot (slot);
2499                           return SW_HOST_OUT_OF_CORE;
2500                         }
2501                       p = tmp + (p - *retbuf);
2502                       *retbuf = tmp;
2503                     }
2504                   memcpy (p, result, resultlen);
2505                   p += resultlen;
2506                 }
2507             }
2508           else
2509             log_info ("apdu_send_sdirect(%d) "
2510                       "got unexpected status %04X from get response\n",
2511                       slot, sw);
2512         }
2513       while ((sw & 0xff00) == SW_MORE_DATA);
2514       
2515       if (retbuf)
2516         {
2517           *retbuflen = p - *retbuf;
2518           tmp = xtryrealloc (*retbuf, *retbuflen + 2);
2519           if (tmp)
2520             *retbuf = tmp;
2521         }
2522     }
2523   else
2524     {
2525       if (retbuf)
2526         {
2527           *retbuf = xtrymalloc ((resultlen? resultlen : 1)+2);
2528           if (!*retbuf)
2529             {
2530               unlock_slot (slot);
2531               return SW_HOST_OUT_OF_CORE;
2532             }
2533           *retbuflen = resultlen;
2534           memcpy (*retbuf, result, resultlen);
2535         }
2536     }
2537
2538   unlock_slot (slot);
2539
2540   /* Append the status word - we reseved the two extra bytes while
2541      allocating the buffer. */
2542   if (retbuf)
2543     {
2544       (*retbuf)[(*retbuflen)++] = (sw >> 8);
2545       (*retbuf)[(*retbuflen)++] = sw;
2546     }
2547
2548   if (DBG_CARD_IO && retbuf)
2549     log_printhex ("      dump: ", *retbuf, *retbuflen);
2550  
2551   return 0;
2552 #undef RESULTLEN
2553 }
2554
2555