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