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