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