6afcd6711fb27aa2e1587d48f0aed63b42214e03
[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 <assert.h>
27
28 #include "scdaemon.h"
29 #include "apdu.h"
30 #include "dynload.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       /* Connected, now activate the card. */           
236       dad[0] = 1;    /* Destination address: CT. */    
237       sad[0] = 2;    /* Source address: Host. */
238
239       cmd[0] = 0x20;  /* Class byte. */
240       cmd[1] = 0x12;  /* Request ICC. */
241       cmd[2] = 0x01;  /* From first interface. */
242       cmd[3] = 0x01;  /* Return card's ATR. */
243       cmd[4] = 0x00;
244
245       buflen = DIM(buf);
246
247       rc = CT_data (reader, dad, sad, 5, cmd, &buflen, buf);
248       if (rc || buflen < 2 || buf[buflen-2] != 0x90)
249         {
250           log_error ("ct_activate_card(%d): activation failed: %s\n",
251                      reader, ct_error_string (rc));
252           return -1;
253         }
254
255       /* Store the type and the ATR. */
256       if (buflen - 2 > DIM (reader_table[0].atr))
257         {
258           log_error ("ct_activate_card(%d): ATR too long\n", reader);
259           return -1;
260         }
261
262       reader_table[reader].status = buf[buflen - 1];
263       memcpy (reader_table[reader].atr, buf, buflen - 2);
264       reader_table[reader].atrlen = buflen - 2;
265       return 0;
266     }
267  
268   log_info ("ct_activate_card(%d): timeout waiting for card\n", reader);
269   return -1;
270 }
271
272
273 /* Open a reader and return an internal handle for it.  PORT is a
274    non-negative value with the port number of the reader. USB readers
275    do have port numbers starting at 32769. */
276 static int
277 open_ct_reader (int port)
278 {
279   int rc, reader;
280
281   if (port < 0 || port > 0xffff)
282     {
283       log_error ("open_ct_reader: invalid port %d requested\n", port);
284       return -1;
285     }
286   reader = new_reader_slot ();
287   if (reader == -1)
288     return reader;
289   reader_table[reader].port = port;
290
291   rc = CT_init (reader, (unsigned short)port);
292   if (rc)
293     {
294       log_error ("apdu_open_ct_reader failed on port %d: %s\n",
295                  port, ct_error_string (rc));
296       reader_table[reader].used = 0;
297       return -1;
298     }
299
300   rc = ct_activate_card (reader);
301   if (rc)
302     {
303       reader_table[reader].used = 0;
304       return -1;
305     }
306
307   reader_table[reader].is_ctapi = 1;
308   dump_reader_status (reader);
309   return reader;
310 }
311
312
313 /* Actually send the APDU of length APDULEN to SLOT and return a
314    maximum of *BUFLEN data in BUFFER, the actual retruned size will be
315    set to BUFLEN.  Returns: CT API error code. */
316 static int
317 ct_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
318               unsigned char *buffer, size_t *buflen)
319 {
320   int rc;
321   unsigned char dad[1], sad[1];
322   unsigned short ctbuflen;
323   
324   dad[0] = 0;     /* Destination address: Card. */    
325   sad[0] = 2;     /* Source address: Host. */
326   ctbuflen = *buflen;
327   if (DBG_CARD_IO)
328     log_printhex ("  CT_data:", apdu, apdulen);
329   rc = CT_data (slot, dad, sad, apdulen, apdu, &ctbuflen, buffer);
330   *buflen = ctbuflen;
331
332   /* FIXME: map the errorcodes to GNUPG ones, so that they can be
333      shared between CTAPI and PCSC. */
334   return rc;
335 }
336
337
338 \f
339 static const char *
340 pcsc_error_string (long err)
341 {
342   const char *s;
343
344   if (!err)
345     return "okay";
346   if ((err & 0x80100000) != 0x80100000)
347     return "invalid PC/SC error code";
348   err &= 0xffff;
349   switch (err)
350     {
351     case 0x0002: s = "cancelled"; break;
352     case 0x000e: s = "can't dispose"; break;
353     case 0x0008: s = "insufficient buffer"; break;   
354     case 0x0015: s = "invalid ATR"; break;
355     case 0x0003: s = "invalid handle"; break;
356     case 0x0004: s = "invalid parameter"; break; 
357     case 0x0005: s = "invalid target"; break;
358     case 0x0011: s = "invalid value"; break; 
359     case 0x0006: s = "no memory"; break;  
360     case 0x0013: s = "comm error"; break;      
361     case 0x0001: s = "internal error"; break;     
362     case 0x0014: s = "unknown error"; break; 
363     case 0x0007: s = "waited too long"; break;  
364     case 0x0009: s = "unknown reader"; break;
365     case 0x000a: s = "timeout"; break; 
366     case 0x000b: s = "sharing violation"; break;       
367     case 0x000c: s = "no smartcard"; break;
368     case 0x000d: s = "unknown card"; break;   
369     case 0x000f: s = "proto mismatch"; break;          
370     case 0x0010: s = "not ready"; break;               
371     case 0x0012: s = "system cancelled"; break;        
372     case 0x0016: s = "not transacted"; break;
373     case 0x0017: s = "reader unavailable"; break; 
374     case 0x0065: s = "unsupported card"; break;        
375     case 0x0066: s = "unresponsive card"; break;       
376     case 0x0067: s = "unpowered card"; break;          
377     case 0x0068: s = "reset card"; break;              
378     case 0x0069: s = "removed card"; break;            
379     case 0x006a: s = "inserted card"; break;           
380     case 0x001f: s = "unsupported feature"; break;     
381     case 0x0019: s = "PCI too small"; break;           
382     case 0x001a: s = "reader unsupported"; break;      
383     case 0x001b: s = "duplicate reader"; break;        
384     case 0x001c: s = "card unsupported"; break;        
385     case 0x001d: s = "no service"; break;              
386     case 0x001e: s = "service stopped"; break;      
387     default:     s = "unknown PC/SC error code"; break;
388     }
389   return s;
390 }
391
392 /* 
393        PC/SC Interface
394  */
395
396 static int
397 open_pcsc_reader (const char *portstr)
398 {
399   long err;
400   int slot;
401   char *list = NULL;
402   unsigned long nreader, listlen, atrlen;
403   char *p;
404   unsigned long card_state, card_protocol;
405
406   slot = new_reader_slot ();
407   if (slot == -1)
408     return -1;
409
410   err = pcsc_establish_context (PCSC_SCOPE_SYSTEM, NULL, NULL,
411                                 &reader_table[slot].pcsc.context);
412   if (err)
413     {
414       log_error ("pcsc_establish_context failed: %s (0x%lx)\n",
415                  pcsc_error_string (err), err);
416       reader_table[slot].used = 0;
417       return -1;
418     }
419   
420   err = pcsc_list_readers (reader_table[slot].pcsc.context,
421                            NULL, NULL, &nreader);
422   if (!err)
423     {
424       list = xtrymalloc (nreader+1); /* Better add 1 for safety reasons. */
425       if (!list)
426         {
427           log_error ("error allocating memory for reader list\n");
428           pcsc_release_context (reader_table[slot].pcsc.context);
429           reader_table[slot].used = 0;
430           return -1;
431         }
432       err = pcsc_list_readers (reader_table[slot].pcsc.context,
433                                NULL, list, &nreader);
434     }
435   if (err)
436     {
437       log_error ("pcsc_list_readers failed: %s (0x%lx)\n",
438                  pcsc_error_string (err), err);
439       pcsc_release_context (reader_table[slot].pcsc.context);
440       reader_table[slot].used = 0;
441       xfree (list);
442       return -1;
443     }
444
445   listlen = nreader;
446   p = list;
447   while (nreader)
448     {
449       if (!*p && !p[1])
450         break;
451       log_info ("detected reader `%s'\n", p);
452       if (nreader < (strlen (p)+1))
453         {
454           log_error ("invalid response from pcsc_list_readers\n");
455           break;
456         }
457       nreader -= strlen (p)+1;
458       p += strlen (p) + 1;
459     }
460
461   err = pcsc_connect (reader_table[slot].pcsc.context,
462                       portstr? portstr : list,
463                       PCSC_SHARE_EXCLUSIVE,
464                       PCSC_PROTOCOL_T0|PCSC_PROTOCOL_T1,
465                       &reader_table[slot].pcsc.card,
466                       &reader_table[slot].pcsc.protocol);
467   if (err)
468     {
469       log_error ("pcsc_connect failed: %s (0x%lx)\n",
470                   pcsc_error_string (err), err);
471       pcsc_release_context (reader_table[slot].pcsc.context);
472       reader_table[slot].used = 0;
473       xfree (list);
474       return -1;
475     }      
476   
477   atrlen = 32;
478   /* (We need to pass a dummy buffer.  We use LIST because it ought to
479      be large enough.) */
480   err = pcsc_status (reader_table[slot].pcsc.card,
481                      list, &listlen,
482                      &card_state, &card_protocol,
483                      reader_table[slot].atr, &atrlen);
484   xfree (list);
485   if (err)
486     {
487       log_error ("pcsc_status failed: %s (0x%lx)\n",
488                   pcsc_error_string (err), err);
489       pcsc_release_context (reader_table[slot].pcsc.context);
490       reader_table[slot].used = 0;
491       return -1;
492     }
493   if (atrlen >= DIM (reader_table[0].atr))
494     log_bug ("ATR returned by pcsc_status is too large\n");
495   reader_table[slot].atrlen = atrlen;
496 /*   log_debug ("state    from pcsc_status: 0x%lx\n", card_state); */
497 /*   log_debug ("protocol from pcsc_status: 0x%lx\n", card_protocol); */
498
499   dump_reader_status (slot); 
500   return slot;
501 }
502
503
504 /* Actually send the APDU of length APDULEN to SLOT and return a
505    maximum of *BUFLEN data in BUFFER, the actual returned size will be
506    set to BUFLEN.  Returns: CT API error code. */
507 static int
508 pcsc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
509                 unsigned char *buffer, size_t *buflen)
510 {
511   long err;
512   struct pcsc_io_request_s send_pci;
513   unsigned long recv_len;
514   
515   if (DBG_CARD_IO)
516     log_printhex ("  CT_data:", apdu, apdulen);
517
518   if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
519       send_pci.protocol = PCSC_PROTOCOL_T1;
520   else
521       send_pci.protocol = PCSC_PROTOCOL_T0;
522   send_pci.pci_len = sizeof send_pci;
523   recv_len = *buflen;
524   err = pcsc_transmit (reader_table[slot].pcsc.card,
525                        &send_pci, apdu, apdulen,
526                        NULL, buffer, &recv_len);
527   *buflen = recv_len;
528   if (err)
529     log_error ("pcsc_transmit failed: %s (0x%lx)\n",
530                pcsc_error_string (err), err);
531   
532   return err? -1:0;
533 }
534
535
536
537
538 \f
539 /* 
540        Driver Access
541  */
542
543 /* Open the reader and return an internal slot number or -1 on
544    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
545    the first USB reader.  For PCSC/ the first listed reader. */
546 int
547 apdu_open_reader (const char *portstr)
548 {
549   static int pcsc_api_loaded, ct_api_loaded;
550
551   if (opt.ctapi_driver && *opt.ctapi_driver)
552     {
553       int port = portstr? atoi (portstr) : 32768;
554
555       if (!ct_api_loaded)
556         {
557           void *handle;
558           
559           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
560           if (!handle)
561             {
562               log_error ("apdu_open_reader: failed to open driver: %s",
563                          dlerror ());
564               return -1;
565             }
566           CT_init = dlsym (handle, "CT_init");
567           CT_data = dlsym (handle, "CT_data");
568           CT_close = dlsym (handle, "CT_close");
569           if (!CT_init || !CT_data || !CT_close)
570             {
571               log_error ("apdu_open_reader: invalid ctAPI driver\n");
572               dlclose (handle);
573               return -1;
574             }
575           ct_api_loaded = 1;
576         }
577       return open_ct_reader (port);
578     }
579
580   
581   /* No ctAPI configured, so lets try the PC/SC API */
582   if (!pcsc_api_loaded)
583     {
584       void *handle;
585
586       handle = dlopen ("libpcsclite.so", RTLD_LAZY);
587       if (!handle)
588         {
589           log_error ("apdu_open_reader: failed to open driver: %s",
590                      dlerror ());
591           return -1;
592         }
593
594       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
595       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
596       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
597       pcsc_connect           = dlsym (handle, "SCardConnect");
598       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
599       pcsc_status            = dlsym (handle, "SCardStatus");
600       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
601       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
602       pcsc_transmit          = dlsym (handle, "SCardTransmit");
603       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
604
605       if (!pcsc_establish_context
606           || !pcsc_release_context  
607           || !pcsc_list_readers     
608           || !pcsc_connect          
609           || !pcsc_disconnect
610           || !pcsc_status
611           || !pcsc_begin_transaction
612           || !pcsc_end_transaction
613           || !pcsc_transmit         
614           || !pcsc_set_timeout)
615         {
616           log_error ("apdu_open_reader: invalid PC/SC driver\n");
617           dlclose (handle);
618           return -1;
619         }
620       pcsc_api_loaded = 1;
621     }
622   
623   return open_pcsc_reader (portstr);
624 }
625
626
627 unsigned char *
628 apdu_get_atr (int slot, size_t *atrlen)
629 {
630   char *buf;
631
632   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
633     return NULL;
634   
635   buf = xtrymalloc (reader_table[slot].atrlen);
636   if (!buf)
637     return NULL;
638   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
639   *atrlen = reader_table[slot].atrlen;
640   return buf;
641 }
642   
643     
644 static const char *
645 error_string (int slot, long rc)
646 {
647   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
648     return "[invalid slot]";
649   if (reader_table[slot].is_ctapi)
650     return ct_error_string (rc);
651   else
652     return pcsc_error_string (rc);
653 }
654
655
656 /* Dispatcher for the actual send_apdu fucntion. */
657 static int
658 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
659            unsigned char *buffer, size_t *buflen)
660 {
661   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
662     return SW_HOST_NO_DRIVER;
663   if (reader_table[slot].is_ctapi)
664     return ct_send_apdu (slot, apdu, apdulen, buffer, buflen);
665   else
666     return pcsc_send_apdu (slot, apdu, apdulen, buffer, buflen);
667 }
668
669 /* Send an APDU to the card in SLOT.  The APDU is created from all
670    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
671    for LC won't sent this field and the data field; in this case DATA
672    must also be passed as NULL.  The return value is the status word
673    or -1 for an invalid SLOT or other non card related error.  If
674    RETBUF is not NULL, it will receive an allocated buffer with the
675    returned data.  The length of that data will be put into
676    *RETBUFLEN.  The caller is reponsible for releasing the buffer even
677    in case of errors.  */
678 int 
679 apdu_send_le(int slot, int class, int ins, int p0, int p1,
680              int lc, const char *data, int le,
681              unsigned char **retbuf, size_t *retbuflen)
682 {
683   unsigned char result[256+10]; /* 10 extra in case of bugs in the driver. */
684   size_t resultlen = 256;
685   unsigned char apdu[5+256+1];
686   size_t apdulen;
687   int sw;
688   long rc; /* we need a long here due to PC/SC. */
689
690   if (DBG_CARD_IO)
691     log_debug ("send apdu: c=%02X i=%02X p0=%02X p1=%02X lc=%d le=%d\n",
692                class, ins, p0, p1, lc, le);
693
694   if (lc != -1 && (lc > 255 || lc < 0))
695     return SW_WRONG_LENGTH; 
696   if (le != -1 && (le > 256 || le < 1))
697     return SW_WRONG_LENGTH; 
698   if ((!data && lc != -1) || (data && lc == -1))
699     return SW_HOST_INV_VALUE;
700
701   apdulen = 0;
702   apdu[apdulen++] = class;
703   apdu[apdulen++] = ins;
704   apdu[apdulen++] = p0;
705   apdu[apdulen++] = p1;
706   if (lc != -1)
707     {
708       apdu[apdulen++] = lc;
709       memcpy (apdu+apdulen, data, lc);
710       apdulen += lc;
711     }
712   if (le != -1)
713     apdu[apdulen++] = le; /* Truncation is okay becuase 0 means 256. */
714   assert (sizeof (apdu) >= apdulen);
715   /* As safeguard don't pass any garbage from the stack to the driver. */
716   memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
717   rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
718   if (rc || resultlen < 2)
719     {
720       log_error ("apdu_send_simple(%d) failed: %s\n",
721                  slot, error_string (slot, rc));
722       return SW_HOST_INCOMPLETE_CARD_RESPONSE;
723     }
724   sw = (result[resultlen-2] << 8) | result[resultlen-1];
725   /* store away the returned data but strip the statusword. */
726   resultlen -= 2;
727   if (DBG_CARD_IO)
728     {
729       log_debug (" response: sw=%04X  datalen=%d\n", sw, resultlen);
730       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
731         log_printhex ("     dump: ", result, resultlen);
732     }
733
734   if (sw == SW_SUCCESS)
735     {
736       if (retbuf)
737         {
738           *retbuf = xtrymalloc (resultlen? resultlen : 1);
739           if (!*retbuf)
740             return SW_HOST_OUT_OF_CORE;
741           *retbuflen = resultlen;
742           memcpy (*retbuf, result, resultlen);
743         }
744     }
745   else if ((sw & 0xff00) == SW_MORE_DATA)
746     {
747       unsigned char *p = NULL, *tmp;
748       size_t bufsize = 4096;
749
750       /* It is likely that we need to return much more data, so we
751          start off with a large buffer. */
752       if (retbuf)
753         {
754           *retbuf = p = xtrymalloc (bufsize);
755           if (!*retbuf)
756             return SW_HOST_OUT_OF_CORE;
757           assert (resultlen < bufsize);
758           memcpy (p, result, resultlen);
759           p += resultlen;
760         }
761
762       do
763         {
764           int len = (sw & 0x00ff);
765           
766           log_debug ("apdu_send_simple(%d): %d more bytes available\n",
767                      slot, len);
768           apdulen = 0;
769           apdu[apdulen++] = class;
770           apdu[apdulen++] = 0xC0;
771           apdu[apdulen++] = 0;
772           apdu[apdulen++] = 0;
773           apdu[apdulen++] = 64; /* that is 256 bytes for Le */
774           memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
775           rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
776           if (rc || resultlen < 2)
777             {
778               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
779                          slot, error_string (slot, rc));
780               return SW_HOST_INCOMPLETE_CARD_RESPONSE;
781             }
782           sw = (result[resultlen-2] << 8) | result[resultlen-1];
783           resultlen -= 2;
784           if (DBG_CARD_IO)
785             {
786               log_debug ("     more: sw=%04X  datalen=%d\n", sw, resultlen);
787               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
788                 log_printhex ("     dump: ", result, resultlen);
789             }
790
791           if ((sw & 0xff00) == SW_MORE_DATA || sw == SW_SUCCESS)
792             {
793               if (retbuf)
794                 {
795                   if (p - *retbuf + resultlen > bufsize)
796                     {
797                       bufsize += resultlen > 4096? resultlen: 4096;
798                       tmp = xtryrealloc (*retbuf, bufsize);
799                       if (!tmp)
800                         return SW_HOST_OUT_OF_CORE;
801                       p = tmp + (p - *retbuf);
802                       *retbuf = tmp;
803                     }
804                   memcpy (p, result, resultlen);
805                   p += resultlen;
806                 }
807             }
808           else
809             log_info ("apdu_send_simple(%d) "
810                       "got unexpected status %04X from get response\n",
811                       slot, sw);
812         }
813       while ((sw & 0xff00) == SW_MORE_DATA);
814       
815       if (retbuf)
816         {
817           *retbuflen = p - *retbuf;
818           tmp = xtryrealloc (*retbuf, *retbuflen);
819           if (tmp)
820             *retbuf = tmp;
821         }
822     }
823   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
824     log_printhex ("      dump: ", *retbuf, *retbuflen);
825  
826   return sw;
827 }
828
829 /* Send an APDU to the card in SLOT.  The APDU is created from all
830    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
831    LC won't sent this field and the data field; in this case DATA must
832    also be passed as NULL. The return value is the status word or -1
833    for an invalid SLOT or other non card related error.  If RETBUF is
834    not NULL, it will receive an allocated buffer with the returned
835    data.  The length of that data will be put into *RETBUFLEN.  The
836    caller is reponsible for releasing the buffer even in case of
837    errors.  */
838 int 
839 apdu_send (int slot, int class, int ins, int p0, int p1,
840            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
841 {
842   return apdu_send_le (slot, class, ins, p0, p1, lc, data, 256, 
843                        retbuf, retbuflen);
844 }
845
846 /* Send an APDU to the card in SLOT.  The APDU is created from all
847    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
848    LC won't sent this field and the data field; in this case DATA must
849    also be passed as NULL. The return value is the status word or -1
850    for an invalid SLOT or other non card related error.  No data will be
851    returned. */
852 int 
853 apdu_send_simple (int slot, int class, int ins, int p0, int p1,
854                   int lc, const char *data)
855 {
856   return apdu_send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL);
857 }
858
859
860
861