Cleanups, fixes and PC/SC support
[gnupg.git] / scd / apdu.c
1 /* apdu.c - ISO 7816 APDU functions and low level I/O
2  *      Copyright (C) 2003 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <dlfcn.h>
27 #include <assert.h>
28
29 #include "scdaemon.h"
30 #include "apdu.h"
31
32 #define MAX_READER 4 /* Number of readers we support concurrently. */
33 #define CARD_CONNECT_TIMEOUT 1 /* Number of seconds to wait for
34                                   insertion of the card (1 = don't wait). */
35
36
37
38 /* A global table to keep track of active readers. */
39 static struct {
40   int used;            /* True if slot is used. */
41   unsigned short port; /* Port number:  0 = unused, 1 - dev/tty */
42   int is_ctapi;        /* This is a ctAPI driver. */
43   struct {
44     unsigned long context;
45     unsigned long card;
46     unsigned long protocol;
47   } pcsc;
48   int status;
49   unsigned char atr[33];
50   size_t atrlen;
51 } reader_table[MAX_READER];                          
52
53
54 /* ct API function pointer. */
55 static char (*CT_init) (unsigned short ctn, unsigned short Pn);
56 static char (*CT_data) (unsigned short ctn, unsigned char *dad,
57                         unsigned char *sad, unsigned short lc,
58                         unsigned char *cmd, unsigned short *lr,
59                         unsigned char *rsp);
60 static char (*CT_close) (unsigned short ctn);
61
62 /* PC/SC constants and function pointer. */
63 #define PCSC_SCOPE_USER      0 
64 #define PCSC_SCOPE_TERMINAL  1 
65 #define PCSC_SCOPE_SYSTEM    2 
66 #define PCSC_SCOPE_GLOBAL    3 
67
68 #define PCSC_PROTOCOL_T0     1 
69 #define PCSC_PROTOCOL_T1     2 
70 #define PCSC_PROTOCOL_RAW    4 
71
72 #define PCSC_SHARE_EXCLUSIVE 1
73 #define PCSC_SHARE_SHARED    2
74 #define PCSC_SHARE_DIRECT    3
75
76 #define PCSC_LEAVE_CARD      0
77 #define PCSC_RESET_CARD      1
78 #define PCSC_UNPOWER_CARD    2
79 #define PCSC_EJECT_CARD      3
80
81 struct pcsc_io_request_s {
82   unsigned long protocol; 
83   unsigned long pci_len;
84 };
85
86 typedef struct pcsc_io_request_s *pcsc_io_request_t;
87
88 long (*pcsc_establish_context) (unsigned long scope,
89                                 const void *reserved1,
90                                 const void *reserved2,
91                                 unsigned long *r_context);
92 long (*pcsc_release_context) (unsigned long context);
93 long (*pcsc_list_readers) (unsigned long context, const char *groups,
94                         char *readers, unsigned long *readerslen);
95 long (*pcsc_connect) (unsigned long context,
96                       const char *reader,
97                       unsigned long share_mode,
98                       unsigned long preferred_protocols,
99                       unsigned long *r_card,
100                       unsigned long *r_active_protocol);
101 long (*pcsc_disconnect) (unsigned long card, unsigned long disposition);
102 long (*pcsc_status) (unsigned long card,
103                      char *reader, unsigned long *readerlen,
104                      unsigned long *r_state, unsigned long *r_protocol,
105                      unsigned char *atr, unsigned long *atrlen);
106 long (*pcsc_begin_transaction) (unsigned long card);
107 long (*pcsc_end_transaction) (unsigned long card);
108 long (*pcsc_transmit) (unsigned long card,
109                        const pcsc_io_request_t send_pci,
110                        const unsigned char *send_buffer,
111                        unsigned long send_len,
112                        pcsc_io_request_t recv_pci,
113                        unsigned char *recv_buffer,
114                        unsigned long *recv_len);
115 long (*pcsc_set_timeout) (unsigned long context, unsigned long timeout);
116
117
118
119
120 \f
121 /* 
122       Helper
123  */
124  
125
126 /* Find an unused reader slot for PORTSTR and put it into the reader
127    table.  Return -1 on error or the index into the reader table. */
128 static int 
129 new_reader_slot (void)    
130 {
131   int i, reader = -1;
132
133   for (i=0; i < MAX_READER; i++)
134     {
135       if (!reader_table[i].used && reader == -1)
136         reader = i;
137     }
138   if (reader == -1)
139     {
140       log_error ("new_reader_slot: out of slots\n");
141       return -1;
142     }
143   reader_table[reader].used = 1;
144   reader_table[reader].is_ctapi = 0;
145   return reader;
146 }
147
148
149 static void
150 dump_reader_status (int reader)
151 {
152   if (reader_table[reader].is_ctapi)
153     {
154       log_info ("reader slot %d: %s\n", reader,
155                 reader_table[reader].status == 1? "Processor ICC present" :
156                 reader_table[reader].status == 0? "Memory ICC present" :
157                 "ICC not present" );
158     }
159   else
160     {
161       log_info ("reader slot %d: active protocol:", reader);
162       if ((reader_table[reader].pcsc.protocol & PCSC_PROTOCOL_T0))
163         log_printf (" T0");
164       else if ((reader_table[reader].pcsc.protocol & PCSC_PROTOCOL_T1))
165         log_printf (" T1");
166       else if ((reader_table[reader].pcsc.protocol & PCSC_PROTOCOL_RAW))
167         log_printf (" raw");
168       log_printf ("\n");
169     }
170
171   if (reader_table[reader].status != -1)
172     {
173       log_info ("reader %d: ATR=", reader);
174       log_printhex ("", reader_table[reader].atr,
175                     reader_table[reader].atrlen);
176     }
177 }
178
179
180 \f
181 /* 
182        ct API Interface 
183  */
184
185 static const char *
186 ct_error_string (long err)
187 {
188   switch (err)
189     {
190     case 0: return "okay";
191     case -1: return "invalid data";
192     case -8: return "ct error";
193     case -10: return "transmission error";
194     case -11: return "memory allocation error";
195     case -128: return "HTSI error";
196     default: return "unknown CT-API error";
197     }
198 }
199
200 /* Wait for the card in READER and activate it.  Return -1 on error or
201    0 on success. */
202 static int
203 ct_activate_card (int reader)
204 {
205   int rc, count;
206
207   for (count = 0; count < CARD_CONNECT_TIMEOUT; count++)
208     {
209       unsigned char dad[1], sad[1], cmd[11], buf[256];
210       unsigned short buflen;
211
212       if (count)
213         ; /* FIXME: we should use a more reliable timer than sleep. */
214
215       /* Check whether card has been inserted. */
216       dad[0] = 1;     /* Destination address: CT. */    
217       sad[0] = 2;     /* Source address: Host. */
218
219       cmd[0] = 0x20;  /* Class byte. */
220       cmd[1] = 0x13;  /* Request status. */
221       cmd[2] = 0x00;  /* From kernel. */
222       cmd[3] = 0x80;  /* Return card's DO. */
223       cmd[4] = 0x00;
224
225       buflen = DIM(buf);
226
227       rc = CT_data (reader, dad, sad, 5, cmd, &buflen, buf);
228       if (rc || buflen < 2 || buf[buflen-2] != 0x90)
229         {
230           log_error ("ct_activate_card: can't get status of reader %d: %s\n",
231                      reader, ct_error_string (rc));
232           return -1;
233         }
234
235       if (buf[0] == 0x05)
236         { /* Connected, now activate the card. */           
237           dad[0] = 1;    /* Destination address: CT. */    
238           sad[0] = 2;    /* Source address: Host. */
239
240           cmd[0] = 0x20;  /* Class byte. */
241           cmd[1] = 0x12;  /* Request ICC. */
242           cmd[2] = 0x01;  /* From first interface. */
243           cmd[3] = 0x01;  /* Return card's ATR. */
244           cmd[4] = 0x00;
245
246           buflen = DIM(buf);
247
248           rc = CT_data (reader, dad, sad, 5, cmd, &buflen, buf);
249           if (rc || buflen < 2 || buf[buflen-2] != 0x90)
250             {
251               log_error ("ct_activate_card(%d): activation failed: %s\n",
252                          reader, ct_error_string (rc));
253               return -1;
254             }
255
256           /* Store the type and the ATR. */
257           if (buflen - 2 > DIM (reader_table[0].atr))
258             {
259               log_error ("ct_activate_card(%d): ATR too long\n", reader);
260               return -1;
261             }
262
263           reader_table[reader].status = buf[buflen - 1];
264           memcpy (reader_table[reader].atr, buf, buflen - 2);
265           reader_table[reader].atrlen = buflen - 2;
266           return 0;
267         }
268
269     }
270  
271   log_info ("ct_activate_card(%d): timeout waiting for card\n", reader);
272   return -1;
273 }
274
275
276 /* Open a reader and return an internal handle for it.  PORT is a
277    non-negative value with the port number of the reader. USB readers
278    do have port numbers starting at 32769. */
279 static int
280 open_ct_reader (int port)
281 {
282   int rc, reader;
283
284   if (port < 0 || port > 0xffff)
285     {
286       log_error ("open_ct_reader: invalid port %d requested\n", port);
287       return -1;
288     }
289   reader = new_reader_slot ();
290   if (reader == -1)
291     return reader;
292   reader_table[reader].port = port;
293
294   rc = CT_init (reader, (unsigned short)port);
295   if (rc)
296     {
297       log_error ("apdu_open_ct_reader failed on port %d: %s\n",
298                  port, ct_error_string (rc));
299       reader_table[reader].used = 0;
300       return -1;
301     }
302
303   rc = ct_activate_card (reader);
304   if (rc)
305     {
306       reader_table[reader].used = 0;
307       return -1;
308     }
309
310   reader_table[reader].is_ctapi = 1;
311   dump_reader_status (reader);
312   return reader;
313 }
314
315
316 /* Actually send the APDU of length APDULEN to SLOT and return a
317    maximum of *BUFLEN data in BUFFER, the actual retruned size will be
318    set to BUFLEN.  Returns: CT API error code. */
319 static int
320 ct_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
321               unsigned char *buffer, size_t *buflen)
322 {
323   int rc;
324   unsigned char dad[1], sad[1];
325   unsigned short ctbuflen;
326   
327   dad[0] = 0;     /* Destination address: Card. */    
328   sad[0] = 2;     /* Source address: Host. */
329   ctbuflen = *buflen;
330   if (DBG_CARD_IO)
331     log_printhex ("  CT_data:", apdu, apdulen);
332   rc = CT_data (slot, dad, sad, apdulen, apdu, &ctbuflen, buffer);
333   *buflen = ctbuflen;
334
335   /* FIXME: map the errorcodes to GNUPG ones, so that they can be
336      shared between CTAPI and PCSC. */
337   return rc;
338 }
339
340
341 \f
342 static const char *
343 pcsc_error_string (long err)
344 {
345   const char *s;
346
347   if (!err)
348     return "okay";
349   if ((err & 0x80100000) != 0x80100000)
350     return "invalid PC/SC error code";
351   err &= 0xffff;
352   switch (err)
353     {
354     case 0x0002: s = "cancelled"; break;
355     case 0x000e: s = "can't dispose"; break;
356     case 0x0008: s = "insufficient buffer"; break;   
357     case 0x0015: s = "invalid ATR"; break;
358     case 0x0003: s = "invalid handle"; break;
359     case 0x0004: s = "invalid parameter"; break; 
360     case 0x0005: s = "invalid target"; break;
361     case 0x0011: s = "invalid value"; break; 
362     case 0x0006: s = "no memory"; break;  
363     case 0x0013: s = "comm error"; break;      
364     case 0x0001: s = "internal error"; break;     
365     case 0x0014: s = "unknown error"; break; 
366     case 0x0007: s = "waited too long"; break;  
367     case 0x0009: s = "unknown reader"; break;
368     case 0x000a: s = "timeout"; break; 
369     case 0x000b: s = "sharing violation"; break;       
370     case 0x000c: s = "no smartcard"; break;
371     case 0x000d: s = "unknown card"; break;   
372     case 0x000f: s = "proto mismatch"; break;          
373     case 0x0010: s = "not ready"; break;               
374     case 0x0012: s = "system cancelled"; break;        
375     case 0x0016: s = "not transacted"; break;
376     case 0x0017: s = "reader unavailable"; break; 
377     case 0x0065: s = "unsupported card"; break;        
378     case 0x0066: s = "unresponsive card"; break;       
379     case 0x0067: s = "unpowered card"; break;          
380     case 0x0068: s = "reset card"; break;              
381     case 0x0069: s = "removed card"; break;            
382     case 0x006a: s = "inserted card"; break;           
383     case 0x001f: s = "unsupported feature"; break;     
384     case 0x0019: s = "PCI too small"; break;           
385     case 0x001a: s = "reader unsupported"; break;      
386     case 0x001b: s = "duplicate reader"; break;        
387     case 0x001c: s = "card unsupported"; break;        
388     case 0x001d: s = "no service"; break;              
389     case 0x001e: s = "service stopped"; break;      
390     default:     s = "unknown PC/SC error code"; break;
391     }
392   return s;
393 }
394
395 /* 
396        PC/SC Interface
397  */
398
399 static int
400 open_pcsc_reader (const char *portstr)
401 {
402   long err;
403   int slot;
404   char *list = NULL;
405   unsigned long nreader, listlen, atrlen;
406   char *p;
407   unsigned long card_state, card_protocol;
408
409   slot = new_reader_slot ();
410   if (slot == -1)
411     return -1;
412
413   err = pcsc_establish_context (PCSC_SCOPE_SYSTEM, NULL, NULL,
414                                 &reader_table[slot].pcsc.context);
415   if (err)
416     {
417       log_error ("pcsc_establish_context failed: %s (0x%lx)\n",
418                  pcsc_error_string (err), err);
419       reader_table[slot].used = 0;
420       return -1;
421     }
422   
423   err = pcsc_list_readers (reader_table[slot].pcsc.context,
424                            NULL, NULL, &nreader);
425   if (!err)
426     {
427       list = xtrymalloc (nreader+1); /* Better add 1 for safety reasons. */
428       if (!list)
429         {
430           log_error ("error allocating memory for reader list\n");
431           pcsc_release_context (reader_table[slot].pcsc.context);
432           reader_table[slot].used = 0;
433           return -1;
434         }
435       err = pcsc_list_readers (reader_table[slot].pcsc.context,
436                                NULL, list, &nreader);
437     }
438   if (err)
439     {
440       log_error ("pcsc_list_readers failed: %s (0x%lx)\n",
441                  pcsc_error_string (err), err);
442       pcsc_release_context (reader_table[slot].pcsc.context);
443       reader_table[slot].used = 0;
444       xfree (list);
445       return -1;
446     }
447
448   listlen = nreader;
449   p = list;
450   while (nreader)
451     {
452       if (!*p && !p[1])
453         break;
454       log_info ("detected reader `%s'\n", p);
455       if (nreader < (strlen (p)+1))
456         {
457           log_error ("invalid response from pcsc_list_readers\n");
458           break;
459         }
460       nreader -= strlen (p)+1;
461       p += strlen (p) + 1;
462     }
463
464   err = pcsc_connect (reader_table[slot].pcsc.context,
465                       portstr? portstr : list,
466                       PCSC_SHARE_EXCLUSIVE,
467                       PCSC_PROTOCOL_T0|PCSC_PROTOCOL_T1,
468                       &reader_table[slot].pcsc.card,
469                       &reader_table[slot].pcsc.protocol);
470   if (err)
471     {
472       log_error ("pcsc_connect failed: %s (0x%lx)\n",
473                   pcsc_error_string (err), err);
474       pcsc_release_context (reader_table[slot].pcsc.context);
475       reader_table[slot].used = 0;
476       xfree (list);
477       return -1;
478     }      
479   
480   atrlen = 32;
481   /* (We need to pass a dummy buffer.  We use LIST because it ought to
482      be large enough.) */
483   err = pcsc_status (reader_table[slot].pcsc.card,
484                      list, &listlen,
485                      &card_state, &card_protocol,
486                      reader_table[slot].atr, &atrlen);
487   xfree (list);
488   if (err)
489     {
490       log_error ("pcsc_status failed: %s (0x%lx)\n",
491                   pcsc_error_string (err), err);
492       pcsc_release_context (reader_table[slot].pcsc.context);
493       reader_table[slot].used = 0;
494       return -1;
495     }
496   if (atrlen >= DIM (reader_table[0].atr))
497     log_bug ("ATR returned by pcsc_status is too large\n");
498   reader_table[slot].atrlen = atrlen;
499 /*   log_debug ("state    from pcsc_status: 0x%lx\n", card_state); */
500 /*   log_debug ("protocol from pcsc_status: 0x%lx\n", card_protocol); */
501
502   dump_reader_status (slot); 
503   return slot;
504 }
505
506
507 /* Actually send the APDU of length APDULEN to SLOT and return a
508    maximum of *BUFLEN data in BUFFER, the actual returned size will be
509    set to BUFLEN.  Returns: CT API error code. */
510 static int
511 pcsc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
512                 unsigned char *buffer, size_t *buflen)
513 {
514   long err;
515   struct pcsc_io_request_s send_pci;
516   unsigned long recv_len;
517   
518   if (DBG_CARD_IO)
519     log_printhex ("  CT_data:", apdu, apdulen);
520
521   if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
522       send_pci.protocol = PCSC_PROTOCOL_T1;
523   else
524       send_pci.protocol = PCSC_PROTOCOL_T0;
525   send_pci.pci_len = sizeof send_pci;
526   recv_len = *buflen;
527   err = pcsc_transmit (reader_table[slot].pcsc.card,
528                        &send_pci, apdu, apdulen,
529                        NULL, buffer, &recv_len);
530   *buflen = recv_len;
531   if (err)
532     log_error ("pcsc_transmit failed: %s (0x%lx)\n",
533                pcsc_error_string (err), err);
534   
535   return err? -1:0;
536 }
537
538
539
540
541 \f
542 /* 
543        Driver Access
544  */
545
546 /* Open the reader and return an internal slot number or -1 on
547    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
548    the first USB reader.  For PCSC/ the first listed reader. */
549 int
550 apdu_open_reader (const char *portstr)
551 {
552   static int pcsc_api_loaded, ct_api_loaded;
553
554   if (opt.ctapi_driver && *opt.ctapi_driver)
555     {
556       int port = portstr? atoi (portstr) : 32768;
557
558       if (!ct_api_loaded)
559         {
560           void *handle;
561           
562           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
563           if (!handle)
564             {
565               log_error ("apdu_open_reader: failed to open driver: %s",
566                          dlerror ());
567               return -1;
568             }
569           CT_init = dlsym (handle, "CT_init");
570           CT_data = dlsym (handle, "CT_data");
571           CT_close = dlsym (handle, "CT_close");
572           if (!CT_init || !CT_data || !CT_close)
573             {
574               log_error ("apdu_open_reader: invalid ctAPI driver\n");
575               dlclose (handle);
576               return -1;
577             }
578           ct_api_loaded = 1;
579         }
580       return open_ct_reader (port);
581     }
582
583   
584   /* No ctAPI configured, so lets try the PC/SC API */
585   if (!pcsc_api_loaded)
586     {
587       void *handle;
588
589       handle = dlopen ("libpcsclite.so", RTLD_LAZY);
590       if (!handle)
591         {
592           log_error ("apdu_open_reader: failed to open driver: %s",
593                      dlerror ());
594           return -1;
595         }
596
597       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
598       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
599       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
600       pcsc_connect           = dlsym (handle, "SCardConnect");
601       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
602       pcsc_status            = dlsym (handle, "SCardStatus");
603       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
604       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
605       pcsc_transmit          = dlsym (handle, "SCardTransmit");
606       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
607
608       if (!pcsc_establish_context
609           || !pcsc_release_context  
610           || !pcsc_list_readers     
611           || !pcsc_connect          
612           || !pcsc_disconnect
613           || !pcsc_status
614           || !pcsc_begin_transaction
615           || !pcsc_end_transaction
616           || !pcsc_transmit         
617           || !pcsc_set_timeout)
618         {
619           log_error ("apdu_open_reader: invalid PC/SC driver\n");
620           dlclose (handle);
621           return -1;
622         }
623       pcsc_api_loaded = 1;
624     }
625   
626   return open_pcsc_reader (portstr);
627 }
628
629
630 unsigned char *
631 apdu_get_atr (int slot, size_t *atrlen)
632 {
633   char *buf;
634
635   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
636     return NULL;
637   
638   buf = xtrymalloc (reader_table[slot].atrlen);
639   if (!buf)
640     return NULL;
641   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
642   *atrlen = reader_table[slot].atrlen;
643   return buf;
644 }
645   
646     
647 static const char *
648 error_string (int slot, long rc)
649 {
650   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
651     return "[invalid slot]";
652   if (reader_table[slot].is_ctapi)
653     return ct_error_string (rc);
654   else
655     return pcsc_error_string (rc);
656 }
657
658
659 /* Dispatcher for the actual send_apdu fucntion. */
660 static int
661 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
662            unsigned char *buffer, size_t *buflen)
663 {
664   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
665     return SW_HOST_NO_DRIVER;
666   if (reader_table[slot].is_ctapi)
667     return ct_send_apdu (slot, apdu, apdulen, buffer, buflen);
668   else
669     return pcsc_send_apdu (slot, apdu, apdulen, buffer, buflen);
670 }
671
672 /* Send an APDU to the card in SLOT.  The APDU is created from all
673    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
674    for LC won't sent this field and the data field; in this case DATA
675    must also be passed as NULL.  The return value is the status word
676    or -1 for an invalid SLOT or other non card related error.  If
677    RETBUF is not NULL, it will receive an allocated buffer with the
678    returned data.  The length of that data will be put into
679    *RETBUFLEN.  The caller is reponsible for releasing the buffer even
680    in case of errors.  */
681 int 
682 apdu_send_le(int slot, int class, int ins, int p0, int p1,
683              int lc, const char *data, int le,
684              unsigned char **retbuf, size_t *retbuflen)
685 {
686   unsigned char result[256+10]; /* 10 extra in case of bugs in the driver. */
687   size_t resultlen = 256;
688   unsigned char apdu[5+256+1];
689   size_t apdulen;
690   int sw;
691   long rc; /* we need a long here due to PC/SC. */
692
693   if (DBG_CARD_IO)
694     log_debug ("send apdu: c=%02X i=%02X p0=%02X p1=%02X lc=%d le=%d\n",
695                class, ins, p0, p1, lc, le);
696
697   if (lc != -1 && (lc > 255 || lc < 0))
698     return SW_WRONG_LENGTH; 
699   if (le != -1 && (le > 256 || le < 1))
700     return SW_WRONG_LENGTH; 
701   if ((!data && lc != -1) || (data && lc == -1))
702     return SW_HOST_INV_VALUE;
703
704   apdulen = 0;
705   apdu[apdulen++] = class;
706   apdu[apdulen++] = ins;
707   apdu[apdulen++] = p0;
708   apdu[apdulen++] = p1;
709   if (lc != -1)
710     {
711       apdu[apdulen++] = lc;
712       memcpy (apdu+apdulen, data, lc);
713       apdulen += lc;
714     }
715   if (le != -1)
716     apdu[apdulen++] = le; /* Truncation is okay becuase 0 means 256. */
717   assert (sizeof (apdu) >= apdulen);
718   /* As safeguard don't pass any garbage from the stack to the driver. */
719   memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
720   rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
721   if (rc || resultlen < 2)
722     {
723       log_error ("apdu_send_simple(%d) failed: %s\n",
724                  slot, error_string (slot, rc));
725       return SW_HOST_INCOMPLETE_CARD_RESPONSE;
726     }
727   sw = (result[resultlen-2] << 8) | result[resultlen-1];
728   /* store away the returned data but strip the statusword. */
729   resultlen -= 2;
730   if (DBG_CARD_IO)
731     {
732       log_debug (" response: sw=%04X  datalen=%d\n", sw, resultlen);
733       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
734         log_printhex ("     dump: ", result, resultlen);
735     }
736
737   if (sw == SW_SUCCESS)
738     {
739       if (retbuf)
740         {
741           *retbuf = xtrymalloc (resultlen? resultlen : 1);
742           if (!*retbuf)
743             return SW_HOST_OUT_OF_CORE;
744           *retbuflen = resultlen;
745           memcpy (*retbuf, result, resultlen);
746         }
747     }
748   else if ((sw & 0xff00) == SW_MORE_DATA)
749     {
750       unsigned char *p = NULL, *tmp;
751       size_t bufsize = 4096;
752
753       /* It is likely that we need to return much more data, so we
754          start off with a large buffer. */
755       if (retbuf)
756         {
757           *retbuf = p = xtrymalloc (bufsize);
758           if (!*retbuf)
759             return SW_HOST_OUT_OF_CORE;
760           assert (resultlen < bufsize);
761           memcpy (p, result, resultlen);
762           p += resultlen;
763         }
764
765       do
766         {
767           int len = (sw & 0x00ff);
768           
769           log_debug ("apdu_send_simple(%d): %d more bytes available\n",
770                      slot, len);
771           apdulen = 0;
772           apdu[apdulen++] = class;
773           apdu[apdulen++] = 0xC0;
774           apdu[apdulen++] = 0;
775           apdu[apdulen++] = 0;
776           apdu[apdulen++] = 64; /* that is 256 bytes for Le */
777           memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
778           rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
779           if (rc || resultlen < 2)
780             {
781               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
782                          slot, error_string (slot, rc));
783               return SW_HOST_INCOMPLETE_CARD_RESPONSE;
784             }
785           sw = (result[resultlen-2] << 8) | result[resultlen-1];
786           resultlen -= 2;
787           if (DBG_CARD_IO)
788             {
789               log_debug ("     more: sw=%04X  datalen=%d\n", sw, resultlen);
790               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
791                 log_printhex ("     dump: ", result, resultlen);
792             }
793
794           if ((sw & 0xff00) == SW_MORE_DATA || sw == SW_SUCCESS)
795             {
796               if (retbuf)
797                 {
798                   if (p - *retbuf + resultlen > bufsize)
799                     {
800                       bufsize += resultlen > 4096? resultlen: 4096;
801                       tmp = xtryrealloc (*retbuf, bufsize);
802                       if (!tmp)
803                         return SW_HOST_OUT_OF_CORE;
804                       p = tmp + (p - *retbuf);
805                       *retbuf = tmp;
806                     }
807                   memcpy (p, result, resultlen);
808                   p += resultlen;
809                 }
810             }
811           else
812             log_info ("apdu_send_simple(%d) "
813                       "got unexpected status %04X from get response\n",
814                       slot, sw);
815         }
816       while ((sw & 0xff00) == SW_MORE_DATA);
817       
818       if (retbuf)
819         {
820           *retbuflen = p - *retbuf;
821           tmp = xtryrealloc (*retbuf, *retbuflen);
822           if (tmp)
823             *retbuf = tmp;
824         }
825     }
826   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
827     log_printhex ("      dump: ", *retbuf, *retbuflen);
828  
829   return sw;
830 }
831
832 /* Send an APDU to the card in SLOT.  The APDU is created from all
833    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
834    LC won't sent this field and the data field; in this case DATA must
835    also be passed as NULL. The return value is the status word or -1
836    for an invalid SLOT or other non card related error.  If RETBUF is
837    not NULL, it will receive an allocated buffer with the returned
838    data.  The length of that data will be put into *RETBUFLEN.  The
839    caller is reponsible for releasing the buffer even in case of
840    errors.  */
841 int 
842 apdu_send (int slot, int class, int ins, int p0, int p1,
843            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
844 {
845   return apdu_send_le (slot, class, ins, p0, p1, lc, data, 256, 
846                        retbuf, retbuflen);
847 }
848
849 /* Send an APDU to the card in SLOT.  The APDU is created from all
850    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
851    LC won't sent this field and the data field; in this case DATA must
852    also be passed as NULL. The return value is the status word or -1
853    for an invalid SLOT or other non card related error.  No data will be
854    returned. */
855 int 
856 apdu_send_simple (int slot, int class, int ins, int p0, int p1,
857                   int lc, const char *data)
858 {
859   return apdu_send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL);
860 }
861
862
863
864