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