* configure.ac (HAVE_LIBUSB): Added a simple test for libusb.
[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 #ifdef HAVE_OPENSC
28 # include <opensc/opensc.h>
29 #endif
30
31 #include "scdaemon.h"
32 #include "apdu.h"
33 #include "dynload.h"
34 #include "ccid-driver.h"
35
36 #define MAX_READER 4 /* Number of readers we support concurrently. */
37 #define CARD_CONNECT_TIMEOUT 1 /* Number of seconds to wait for
38                                   insertion of the card (1 = don't wait). */
39
40
41 /* A structure to collect information pertaining to one reader
42    slot. */
43 struct reader_table_s {
44   int used;            /* True if slot is used. */
45   unsigned short port; /* Port number:  0 = unused, 1 - dev/tty */
46   int is_ccid;         /* Uses the internal CCID driver. */
47   struct {
48     ccid_driver_t handle;
49   } ccid;
50   int is_ctapi;        /* This is a ctAPI driver. */
51   struct {
52     unsigned long context;
53     unsigned long card;
54     unsigned long protocol;
55   } pcsc;
56 #ifdef HAVE_OPENSC
57   int is_osc;          /* We are using the OpenSC driver layer. */
58   struct {
59     struct sc_context *ctx;
60     struct sc_card *scard;
61   } osc;
62 #endif /*HAVE_OPENSC*/
63   int status;
64   unsigned char atr[33];
65   size_t atrlen;
66 };
67 typedef struct reader_table_s *reader_table_t;
68
69 /* A global table to keep track of active readers. */
70 static struct reader_table_s reader_table[MAX_READER];
71
72
73 /* ct API function pointer. */
74 static char (*CT_init) (unsigned short ctn, unsigned short Pn);
75 static char (*CT_data) (unsigned short ctn, unsigned char *dad,
76                         unsigned char *sad, unsigned short lc,
77                         unsigned char *cmd, unsigned short *lr,
78                         unsigned char *rsp);
79 static char (*CT_close) (unsigned short ctn);
80
81 /* PC/SC constants and function pointer. */
82 #define PCSC_SCOPE_USER      0 
83 #define PCSC_SCOPE_TERMINAL  1 
84 #define PCSC_SCOPE_SYSTEM    2 
85 #define PCSC_SCOPE_GLOBAL    3 
86
87 #define PCSC_PROTOCOL_T0     1 
88 #define PCSC_PROTOCOL_T1     2 
89 #define PCSC_PROTOCOL_RAW    4 
90
91 #define PCSC_SHARE_EXCLUSIVE 1
92 #define PCSC_SHARE_SHARED    2
93 #define PCSC_SHARE_DIRECT    3
94
95 #define PCSC_LEAVE_CARD      0
96 #define PCSC_RESET_CARD      1
97 #define PCSC_UNPOWER_CARD    2
98 #define PCSC_EJECT_CARD      3
99
100 struct pcsc_io_request_s {
101   unsigned long protocol; 
102   unsigned long pci_len;
103 };
104
105 typedef struct pcsc_io_request_s *pcsc_io_request_t;
106
107 long (*pcsc_establish_context) (unsigned long scope,
108                                 const void *reserved1,
109                                 const void *reserved2,
110                                 unsigned long *r_context);
111 long (*pcsc_release_context) (unsigned long context);
112 long (*pcsc_list_readers) (unsigned long context, const char *groups,
113                         char *readers, unsigned long *readerslen);
114 long (*pcsc_connect) (unsigned long context,
115                       const char *reader,
116                       unsigned long share_mode,
117                       unsigned long preferred_protocols,
118                       unsigned long *r_card,
119                       unsigned long *r_active_protocol);
120 long (*pcsc_disconnect) (unsigned long card, unsigned long disposition);
121 long (*pcsc_status) (unsigned long card,
122                      char *reader, unsigned long *readerlen,
123                      unsigned long *r_state, unsigned long *r_protocol,
124                      unsigned char *atr, unsigned long *atrlen);
125 long (*pcsc_begin_transaction) (unsigned long card);
126 long (*pcsc_end_transaction) (unsigned long card);
127 long (*pcsc_transmit) (unsigned long card,
128                        const pcsc_io_request_t send_pci,
129                        const unsigned char *send_buffer,
130                        unsigned long send_len,
131                        pcsc_io_request_t recv_pci,
132                        unsigned char *recv_buffer,
133                        unsigned long *recv_len);
134 long (*pcsc_set_timeout) (unsigned long context, unsigned long timeout);
135
136
137
138
139 \f
140 /* 
141       Helper
142  */
143  
144
145 /* Find an unused reader slot for PORTSTR and put it into the reader
146    table.  Return -1 on error or the index into the reader table. */
147 static int 
148 new_reader_slot (void)    
149 {
150   int i, reader = -1;
151
152   for (i=0; i < MAX_READER; i++)
153     {
154       if (!reader_table[i].used && reader == -1)
155         reader = i;
156     }
157   if (reader == -1)
158     {
159       log_error ("new_reader_slot: out of slots\n");
160       return -1;
161     }
162   reader_table[reader].used = 1;
163   reader_table[reader].is_ccid = 0;
164   reader_table[reader].is_ctapi = 0;
165 #ifdef HAVE_OPENSC
166   reader_table[reader].is_osc = 0;
167 #endif
168   return reader;
169 }
170
171
172 static void
173 dump_reader_status (int reader)
174 {
175   if (reader_table[reader].is_ccid)
176     log_info ("reader slot %d: using ccid driver\n", reader);
177   else if (reader_table[reader].is_ctapi)
178     {
179       log_info ("reader slot %d: %s\n", reader,
180                 reader_table[reader].status == 1? "Processor ICC present" :
181                 reader_table[reader].status == 0? "Memory ICC present" :
182                 "ICC not present" );
183     }
184   else
185     {
186       log_info ("reader slot %d: active protocol:", reader);
187       if ((reader_table[reader].pcsc.protocol & PCSC_PROTOCOL_T0))
188         log_printf (" T0");
189       else if ((reader_table[reader].pcsc.protocol & PCSC_PROTOCOL_T1))
190         log_printf (" T1");
191       else if ((reader_table[reader].pcsc.protocol & PCSC_PROTOCOL_RAW))
192         log_printf (" raw");
193       log_printf ("\n");
194     }
195
196   if (reader_table[reader].status != -1)
197     {
198       log_info ("reader %d: ATR=", reader);
199       log_printhex ("", reader_table[reader].atr,
200                     reader_table[reader].atrlen);
201     }
202 }
203
204
205 \f
206 /* 
207        ct API Interface 
208  */
209
210 static const char *
211 ct_error_string (long err)
212 {
213   switch (err)
214     {
215     case 0: return "okay";
216     case -1: return "invalid data";
217     case -8: return "ct error";
218     case -10: return "transmission error";
219     case -11: return "memory allocation error";
220     case -128: return "HTSI error";
221     default: return "unknown CT-API error";
222     }
223 }
224
225 /* Wait for the card in READER and activate it.  Return -1 on error or
226    0 on success. */
227 static int
228 ct_activate_card (int reader)
229 {
230   int rc, count;
231
232   for (count = 0; count < CARD_CONNECT_TIMEOUT; count++)
233     {
234       unsigned char dad[1], sad[1], cmd[11], buf[256];
235       unsigned short buflen;
236
237       if (count)
238         ; /* FIXME: we should use a more reliable timer than sleep. */
239
240       /* Check whether card has been inserted. */
241       dad[0] = 1;     /* Destination address: CT. */    
242       sad[0] = 2;     /* Source address: Host. */
243
244       cmd[0] = 0x20;  /* Class byte. */
245       cmd[1] = 0x13;  /* Request status. */
246       cmd[2] = 0x00;  /* From kernel. */
247       cmd[3] = 0x80;  /* Return card's DO. */
248       cmd[4] = 0x00;
249
250       buflen = DIM(buf);
251
252       rc = CT_data (reader, dad, sad, 5, cmd, &buflen, buf);
253       if (rc || buflen < 2 || buf[buflen-2] != 0x90)
254         {
255           log_error ("ct_activate_card: can't get status of reader %d: %s\n",
256                      reader, ct_error_string (rc));
257           return -1;
258         }
259
260       /* Connected, now activate the card. */           
261       dad[0] = 1;    /* Destination address: CT. */    
262       sad[0] = 2;    /* Source address: Host. */
263
264       cmd[0] = 0x20;  /* Class byte. */
265       cmd[1] = 0x12;  /* Request ICC. */
266       cmd[2] = 0x01;  /* From first interface. */
267       cmd[3] = 0x01;  /* Return card's ATR. */
268       cmd[4] = 0x00;
269
270       buflen = DIM(buf);
271
272       rc = CT_data (reader, dad, sad, 5, cmd, &buflen, buf);
273       if (rc || buflen < 2 || buf[buflen-2] != 0x90)
274         {
275           log_error ("ct_activate_card(%d): activation failed: %s\n",
276                      reader, ct_error_string (rc));
277           return -1;
278         }
279
280       /* Store the type and the ATR. */
281       if (buflen - 2 > DIM (reader_table[0].atr))
282         {
283           log_error ("ct_activate_card(%d): ATR too long\n", reader);
284           return -1;
285         }
286
287       reader_table[reader].status = buf[buflen - 1];
288       memcpy (reader_table[reader].atr, buf, buflen - 2);
289       reader_table[reader].atrlen = buflen - 2;
290       return 0;
291     }
292  
293   log_info ("ct_activate_card(%d): timeout waiting for card\n", reader);
294   return -1;
295 }
296
297
298 /* Open a reader and return an internal handle for it.  PORT is a
299    non-negative value with the port number of the reader. USB readers
300    do have port numbers starting at 32769. */
301 static int
302 open_ct_reader (int port)
303 {
304   int rc, reader;
305
306   if (port < 0 || port > 0xffff)
307     {
308       log_error ("open_ct_reader: invalid port %d requested\n", port);
309       return -1;
310     }
311   reader = new_reader_slot ();
312   if (reader == -1)
313     return reader;
314   reader_table[reader].port = port;
315
316   rc = CT_init (reader, (unsigned short)port);
317   if (rc)
318     {
319       log_error ("apdu_open_ct_reader failed on port %d: %s\n",
320                  port, ct_error_string (rc));
321       reader_table[reader].used = 0;
322       return -1;
323     }
324
325   rc = ct_activate_card (reader);
326   if (rc)
327     {
328       reader_table[reader].used = 0;
329       return -1;
330     }
331
332   reader_table[reader].is_ctapi = 1;
333   dump_reader_status (reader);
334   return reader;
335 }
336
337
338 /* Actually send the APDU of length APDULEN to SLOT and return a
339    maximum of *BUFLEN data in BUFFER, the actual retruned size will be
340    set to BUFLEN.  Returns: CT API error code. */
341 static int
342 ct_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
343               unsigned char *buffer, size_t *buflen)
344 {
345   int rc;
346   unsigned char dad[1], sad[1];
347   unsigned short ctbuflen;
348   
349   dad[0] = 0;     /* Destination address: Card. */    
350   sad[0] = 2;     /* Source address: Host. */
351   ctbuflen = *buflen;
352   if (DBG_CARD_IO)
353     log_printhex ("  CT_data:", apdu, apdulen);
354   rc = CT_data (slot, dad, sad, apdulen, apdu, &ctbuflen, buffer);
355   *buflen = ctbuflen;
356
357   /* FIXME: map the errorcodes to GNUPG ones, so that they can be
358      shared between CTAPI and PCSC. */
359   return rc;
360 }
361
362
363 \f
364 static const char *
365 pcsc_error_string (long err)
366 {
367   const char *s;
368
369   if (!err)
370     return "okay";
371   if ((err & 0x80100000) != 0x80100000)
372     return "invalid PC/SC error code";
373   err &= 0xffff;
374   switch (err)
375     {
376     case 0x0002: s = "cancelled"; break;
377     case 0x000e: s = "can't dispose"; break;
378     case 0x0008: s = "insufficient buffer"; break;   
379     case 0x0015: s = "invalid ATR"; break;
380     case 0x0003: s = "invalid handle"; break;
381     case 0x0004: s = "invalid parameter"; break; 
382     case 0x0005: s = "invalid target"; break;
383     case 0x0011: s = "invalid value"; break; 
384     case 0x0006: s = "no memory"; break;  
385     case 0x0013: s = "comm error"; break;      
386     case 0x0001: s = "internal error"; break;     
387     case 0x0014: s = "unknown error"; break; 
388     case 0x0007: s = "waited too long"; break;  
389     case 0x0009: s = "unknown reader"; break;
390     case 0x000a: s = "timeout"; break; 
391     case 0x000b: s = "sharing violation"; break;       
392     case 0x000c: s = "no smartcard"; break;
393     case 0x000d: s = "unknown card"; break;   
394     case 0x000f: s = "proto mismatch"; break;          
395     case 0x0010: s = "not ready"; break;               
396     case 0x0012: s = "system cancelled"; break;        
397     case 0x0016: s = "not transacted"; break;
398     case 0x0017: s = "reader unavailable"; break; 
399     case 0x0065: s = "unsupported card"; break;        
400     case 0x0066: s = "unresponsive card"; break;       
401     case 0x0067: s = "unpowered card"; break;          
402     case 0x0068: s = "reset card"; break;              
403     case 0x0069: s = "removed card"; break;            
404     case 0x006a: s = "inserted card"; break;           
405     case 0x001f: s = "unsupported feature"; break;     
406     case 0x0019: s = "PCI too small"; break;           
407     case 0x001a: s = "reader unsupported"; break;      
408     case 0x001b: s = "duplicate reader"; break;        
409     case 0x001c: s = "card unsupported"; break;        
410     case 0x001d: s = "no service"; break;              
411     case 0x001e: s = "service stopped"; break;      
412     default:     s = "unknown PC/SC error code"; break;
413     }
414   return s;
415 }
416
417 /* 
418        PC/SC Interface
419  */
420
421 static int
422 open_pcsc_reader (const char *portstr)
423 {
424   long err;
425   int slot;
426   char *list = NULL;
427   unsigned long nreader, listlen, atrlen;
428   char *p;
429   unsigned long card_state, card_protocol;
430
431   slot = new_reader_slot ();
432   if (slot == -1)
433     return -1;
434
435   err = pcsc_establish_context (PCSC_SCOPE_SYSTEM, NULL, NULL,
436                                 &reader_table[slot].pcsc.context);
437   if (err)
438     {
439       log_error ("pcsc_establish_context failed: %s (0x%lx)\n",
440                  pcsc_error_string (err), err);
441       reader_table[slot].used = 0;
442       return -1;
443     }
444   
445   err = pcsc_list_readers (reader_table[slot].pcsc.context,
446                            NULL, NULL, &nreader);
447   if (!err)
448     {
449       list = xtrymalloc (nreader+1); /* Better add 1 for safety reasons. */
450       if (!list)
451         {
452           log_error ("error allocating memory for reader list\n");
453           pcsc_release_context (reader_table[slot].pcsc.context);
454           reader_table[slot].used = 0;
455           return -1;
456         }
457       err = pcsc_list_readers (reader_table[slot].pcsc.context,
458                                NULL, list, &nreader);
459     }
460   if (err)
461     {
462       log_error ("pcsc_list_readers failed: %s (0x%lx)\n",
463                  pcsc_error_string (err), err);
464       pcsc_release_context (reader_table[slot].pcsc.context);
465       reader_table[slot].used = 0;
466       xfree (list);
467       return -1;
468     }
469
470   listlen = nreader;
471   p = list;
472   while (nreader)
473     {
474       if (!*p && !p[1])
475         break;
476       log_info ("detected reader `%s'\n", p);
477       if (nreader < (strlen (p)+1))
478         {
479           log_error ("invalid response from pcsc_list_readers\n");
480           break;
481         }
482       nreader -= strlen (p)+1;
483       p += strlen (p) + 1;
484     }
485
486   err = pcsc_connect (reader_table[slot].pcsc.context,
487                       portstr? portstr : list,
488                       PCSC_SHARE_EXCLUSIVE,
489                       PCSC_PROTOCOL_T0|PCSC_PROTOCOL_T1,
490                       &reader_table[slot].pcsc.card,
491                       &reader_table[slot].pcsc.protocol);
492   if (err)
493     {
494       log_error ("pcsc_connect failed: %s (0x%lx)\n",
495                   pcsc_error_string (err), err);
496       pcsc_release_context (reader_table[slot].pcsc.context);
497       reader_table[slot].used = 0;
498       xfree (list);
499       return -1;
500     }      
501   
502   atrlen = 32;
503   /* (We need to pass a dummy buffer.  We use LIST because it ought to
504      be large enough.) */
505   err = pcsc_status (reader_table[slot].pcsc.card,
506                      list, &listlen,
507                      &card_state, &card_protocol,
508                      reader_table[slot].atr, &atrlen);
509   xfree (list);
510   if (err)
511     {
512       log_error ("pcsc_status failed: %s (0x%lx)\n",
513                   pcsc_error_string (err), err);
514       pcsc_release_context (reader_table[slot].pcsc.context);
515       reader_table[slot].used = 0;
516       return -1;
517     }
518   if (atrlen >= DIM (reader_table[0].atr))
519     log_bug ("ATR returned by pcsc_status is too large\n");
520   reader_table[slot].atrlen = atrlen;
521 /*   log_debug ("state    from pcsc_status: 0x%lx\n", card_state); */
522 /*   log_debug ("protocol from pcsc_status: 0x%lx\n", card_protocol); */
523
524   dump_reader_status (slot); 
525   return slot;
526 }
527
528
529 /* Actually send the APDU of length APDULEN to SLOT and return a
530    maximum of *BUFLEN data in BUFFER, the actual returned size will be
531    set to BUFLEN.  Returns: CT API error code. */
532 static int
533 pcsc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
534                 unsigned char *buffer, size_t *buflen)
535 {
536   long err;
537   struct pcsc_io_request_s send_pci;
538   unsigned long recv_len;
539   
540   if (DBG_CARD_IO)
541     log_printhex ("  PCSC_data:", apdu, apdulen);
542
543   if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
544       send_pci.protocol = PCSC_PROTOCOL_T1;
545   else
546       send_pci.protocol = PCSC_PROTOCOL_T0;
547   send_pci.pci_len = sizeof send_pci;
548   recv_len = *buflen;
549   err = pcsc_transmit (reader_table[slot].pcsc.card,
550                        &send_pci, apdu, apdulen,
551                        NULL, buffer, &recv_len);
552   *buflen = recv_len;
553   if (err)
554     log_error ("pcsc_transmit failed: %s (0x%lx)\n",
555                pcsc_error_string (err), err);
556   
557   return err? -1:0; /* FIXME: Return appropriate error code. */
558 }
559
560 \f
561 #ifdef HAVE_LIBUSB
562 /* 
563      Internal CCID driver interface.
564  */
565
566 static int
567 open_ccid_reader (void)
568 {
569   int err;
570   int slot;
571   reader_table_t slotp;
572
573   slot = new_reader_slot ();
574   if (slot == -1)
575     return -1;
576   slotp = reader_table + slot;
577
578   err = ccid_open_reader (&slotp->ccid.handle, 0);
579   if (err)
580     {
581       slotp->used = 0;
582       return -1;
583     }
584
585   err = ccid_get_atr (slotp->ccid.handle,
586                       slotp->atr, sizeof slotp->atr, &slotp->atrlen);
587   if (err)
588     {
589       slotp->used = 0;
590       return -1;
591     }
592
593   slotp->is_ccid = 1;
594
595   dump_reader_status (slot); 
596   return slot;
597 }
598
599
600 /* Actually send the APDU of length APDULEN to SLOT and return a
601    maximum of *BUFLEN data in BUFFER, the actual returned size will be
602    set to BUFLEN.  Returns: Internal CCID driver error code. */
603 static int
604 send_apdu_ccid (int slot, unsigned char *apdu, size_t apdulen,
605                 unsigned char *buffer, size_t *buflen)
606 {
607   long err;
608   size_t maxbuflen;
609
610   if (DBG_CARD_IO)
611     log_printhex ("  APDU_data:", apdu, apdulen);
612
613   maxbuflen = *buflen;
614   err = ccid_transceive (reader_table[slot].ccid.handle,
615                          apdu, apdulen,
616                          buffer, maxbuflen, buflen);
617   if (err)
618     log_error ("ccid_transceive failed: (0x%lx)\n",
619                err);
620   
621   return err? -1:0; /* FIXME: Return appropriate error code. */
622 }
623
624 #endif /* HAVE_LIBUSB */
625
626
627 \f
628 #ifdef HAVE_OPENSC
629 /* 
630      OpenSC Interface.
631
632      This uses the OpenSC primitives to send APDUs.  We need this
633      because we can't mix OpenSC and native (i.e. ctAPI or PC/SC)
634      access to a card for resource conflict reasons.
635  */
636
637 static int
638 open_osc_reader (int portno)
639 {
640   int err;
641   int slot;
642   reader_table_t slotp;
643
644   slot = new_reader_slot ();
645   if (slot == -1)
646     return -1;
647   slotp = reader_table + slot;
648
649   err = sc_establish_context (&slotp->osc.ctx, "scdaemon");
650   if (err)
651     {
652       log_error ("failed to establish SC context: %s\n", sc_strerror (err));
653       slotp->used = 0;
654       return -1;
655     }
656   if (portno < 0 || portno >= slotp->osc.ctx->reader_count)
657     {
658       log_error ("no card reader available\n");
659       sc_release_context (slotp->osc.ctx);
660       slotp->used = 0;
661       return -1;
662     }
663
664   /* Redirect to our logging facility. */
665   slotp->osc.ctx->error_file = log_get_stream ();
666   slotp->osc.ctx->debug = opt.debug_sc;
667   slotp->osc.ctx->debug_file = log_get_stream ();
668
669   if (sc_detect_card_presence (slotp->osc.ctx->reader[portno], 0) != 1)
670     {
671       log_error ("no card present\n");
672       sc_release_context (slotp->osc.ctx);
673       slotp->used = 0;
674       return -1;
675     }
676   
677   /* We want the standard ISO driver. */
678   /*FIXME: OpenSC does not like "iso7816", so we use EMV for now. */
679   err = sc_set_card_driver(slotp->osc.ctx, "emv");
680   if (err)
681     {
682       log_error ("failed to select the iso7816 driver: %s\n",
683                  sc_strerror (err));
684       sc_release_context (slotp->osc.ctx);
685       slotp->used = 0;
686       return -1;
687     }
688
689   /* Now connect the card and hope that OpenSC won't try to be too
690      smart. */
691   err = sc_connect_card (slotp->osc.ctx->reader[portno], 0,
692                          &slotp->osc.scard);
693   if (err)
694     {
695       log_error ("failed to connect card in reader %d: %s\n",
696                  portno, sc_strerror (err));
697       sc_release_context (slotp->osc.ctx);
698       slotp->used = 0;
699       return -1;
700     }
701   if (opt.verbose)
702     log_info ("connected to card in opensc reader %d using driver `%s'\n",
703               portno, slotp->osc.scard->driver->name);
704
705   err = sc_lock (slotp->osc.scard);
706   if (err)
707     {
708       log_error ("can't lock card in reader %d: %s\n",
709                  portno, sc_strerror (err));
710       sc_disconnect_card (slotp->osc.scard, 0);
711       sc_release_context (slotp->osc.ctx);
712       slotp->used = 0;
713       return -1;
714     }
715
716   if (slotp->osc.scard->atr_len >= DIM (slotp->atr))
717     log_bug ("ATR returned by opensc is too large\n");
718   slotp->atrlen = slotp->osc.scard->atr_len;
719   memcpy (slotp->atr, slotp->osc.scard->atr, slotp->atrlen);
720
721   slotp->is_osc = 1;
722
723   dump_reader_status (slot); 
724   return slot;
725 }
726
727
728 /* Actually send the APDU of length APDULEN to SLOT and return a
729    maximum of *BUFLEN data in BUFFER, the actual returned size will be
730    set to BUFLEN.  Returns: OpenSC error code. */
731 static int
732 osc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
733                 unsigned char *buffer, size_t *buflen)
734 {
735   long err;
736   struct sc_apdu a;
737   unsigned char data[SC_MAX_APDU_BUFFER_SIZE];
738   unsigned char result[SC_MAX_APDU_BUFFER_SIZE];
739
740   if (DBG_CARD_IO)
741     log_printhex ("  APDU_data:", apdu, apdulen);
742
743   if (apdulen < 4)
744     {
745       log_error ("osc_send_apdu: APDU is too short\n");
746       return SC_ERROR_CMD_TOO_SHORT;
747     }
748
749   memset(&a, 0, sizeof a);
750   a.cla = *apdu++;
751   a.ins = *apdu++;
752   a.p1 = *apdu++;
753   a.p2 = *apdu++;
754   apdulen -= 4;
755
756   if (!apdulen)
757     a.cse = SC_APDU_CASE_1;
758   else if (apdulen == 1) 
759     {
760       a.le = *apdu? *apdu : 256;
761       apdu++; apdulen--;
762       a.cse = SC_APDU_CASE_2_SHORT;
763     }
764   else
765     {
766       a.lc = *apdu++; apdulen--;
767       if (apdulen < a.lc)
768         {
769           log_error ("osc_send_apdu: APDU shorter than specified in Lc\n");
770           return SC_ERROR_CMD_TOO_SHORT;
771
772         }
773       memcpy(data, apdu, a.lc);
774       apdu += a.lc; apdulen -= a.lc;
775
776       a.data = data;
777       a.datalen = a.lc;
778       
779       if (!apdulen)
780         a.cse = SC_APDU_CASE_3_SHORT;
781       else
782         {
783           a.le = *apdu? *apdu : 256;
784           apdu++; apdulen--;
785           if (apdulen)
786             {
787               log_error ("osc_send_apdu: APDU larger than specified\n");
788               return SC_ERROR_CMD_TOO_LONG;
789             }
790           a.cse = SC_APDU_CASE_4_SHORT;
791         }
792     }
793
794   a.resp = result;
795   a.resplen = DIM(result);
796
797   err = sc_transmit_apdu (reader_table[slot].osc.scard, &a);
798   if (err)
799     {
800       log_error ("sc_apdu_transmit failed: %s\n", sc_strerror (err));
801       return err;
802     }
803
804   if (*buflen < 2 || a.resplen > *buflen - 2)
805     {
806       log_error ("osc_send_apdu: provided buffer too short to store result\n");
807       return SC_ERROR_BUFFER_TOO_SMALL;
808     }
809   memcpy (buffer, a.resp, a.resplen);
810   buffer[a.resplen] = a.sw1;
811   buffer[a.resplen+1] = a.sw2;
812   *buflen = a.resplen + 2;
813   return 0;
814 }
815
816 #endif /* HAVE_OPENSC */
817
818
819 \f
820 /* 
821        Driver Access
822  */
823
824 /* Open the reader and return an internal slot number or -1 on
825    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
826    the first USB reader.  For PC/SC the first listed reader).  IF
827    OpenSC support is cmpiled in, we first try to use OpenSC. */
828 int
829 apdu_open_reader (const char *portstr)
830 {
831   static int pcsc_api_loaded, ct_api_loaded;
832
833 #ifdef HAVE_LIBUSB
834   if (!opt.disable_ccid)
835     {
836       int slot;
837
838       slot = open_ccid_reader ();
839       if (slot != -1)
840         return slot; /* got one */
841     }
842 #endif
843
844 #ifdef HAVE_OPENSC
845   if (!opt.disable_opensc)
846     {
847       int port = portstr? atoi (portstr) : 0;
848
849       return open_osc_reader (port);
850     }
851 #endif /* HAVE_OPENSC */  
852
853
854   if (opt.ctapi_driver && *opt.ctapi_driver)
855     {
856       int port = portstr? atoi (portstr) : 32768;
857
858       if (!ct_api_loaded)
859         {
860           void *handle;
861           
862           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
863           if (!handle)
864             {
865               log_error ("apdu_open_reader: failed to open driver: %s",
866                          dlerror ());
867               return -1;
868             }
869           CT_init = dlsym (handle, "CT_init");
870           CT_data = dlsym (handle, "CT_data");
871           CT_close = dlsym (handle, "CT_close");
872           if (!CT_init || !CT_data || !CT_close)
873             {
874               log_error ("apdu_open_reader: invalid ctAPI driver\n");
875               dlclose (handle);
876               return -1;
877             }
878           ct_api_loaded = 1;
879         }
880       return open_ct_reader (port);
881     }
882
883   
884   /* No ctAPI configured, so lets try the PC/SC API */
885   if (!pcsc_api_loaded)
886     {
887       void *handle;
888
889       if (!opt.pcsc_driver || !*opt.pcsc_driver)
890         {
891           log_error ("no PC/SC driver has been specified\n");
892           return -1;
893         }
894
895       handle = dlopen ("libpcsclite.so", RTLD_LAZY);
896       if (!handle)
897         {
898           log_error ("apdu_open_reader: failed to open driver: %s",
899                      dlerror ());
900           return -1;
901         }
902
903       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
904       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
905       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
906       pcsc_connect           = dlsym (handle, "SCardConnect");
907       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
908       pcsc_status            = dlsym (handle, "SCardStatus");
909       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
910       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
911       pcsc_transmit          = dlsym (handle, "SCardTransmit");
912       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
913
914       if (!pcsc_establish_context
915           || !pcsc_release_context  
916           || !pcsc_list_readers     
917           || !pcsc_connect          
918           || !pcsc_disconnect
919           || !pcsc_status
920           || !pcsc_begin_transaction
921           || !pcsc_end_transaction
922           || !pcsc_transmit         
923           || !pcsc_set_timeout)
924         {
925           log_error ("apdu_open_reader: invalid PC/SC driver\n");
926           dlclose (handle);
927           return -1;
928         }
929       pcsc_api_loaded = 1;
930     }
931   
932   return open_pcsc_reader (portstr);
933 }
934
935
936 unsigned char *
937 apdu_get_atr (int slot, size_t *atrlen)
938 {
939   char *buf;
940
941   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
942     return NULL;
943   
944   buf = xtrymalloc (reader_table[slot].atrlen);
945   if (!buf)
946     return NULL;
947   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
948   *atrlen = reader_table[slot].atrlen;
949   return buf;
950 }
951   
952     
953 static const char *
954 error_string (int slot, long rc)
955 {
956   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
957     return "[invalid slot]";
958   if (reader_table[slot].is_ctapi)
959     return ct_error_string (rc);
960 #ifdef HAVE_LIBUSB
961   else if (reader_table[slot].is_ccid)
962     return "no CCID driver error strings yet";
963 #endif
964 #ifdef HAVE_OPENSC
965   else if (reader_table[slot].is_osc)
966     return sc_strerror (rc);
967 #endif
968   else
969     return pcsc_error_string (rc);
970 }
971
972
973 /* Dispatcher for the actual send_apdu fucntion. */
974 static int
975 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
976            unsigned char *buffer, size_t *buflen)
977 {
978   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
979     return SW_HOST_NO_DRIVER;
980   if (reader_table[slot].is_ctapi)
981     return ct_send_apdu (slot, apdu, apdulen, buffer, buflen);
982 #ifdef HAVE_LIBUSB
983   else if (reader_table[slot].is_ccid)
984     return send_apdu_ccid (slot, apdu, apdulen, buffer, buflen);
985 #endif
986 #ifdef HAVE_OPENSC
987   else if (reader_table[slot].is_osc)
988     return osc_send_apdu (slot, apdu, apdulen, buffer, buflen);
989 #endif
990   else
991     return pcsc_send_apdu (slot, apdu, apdulen, buffer, buflen);
992 }
993
994 /* Send an APDU to the card in SLOT.  The APDU is created from all
995    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
996    for LC won't sent this field and the data field; in this case DATA
997    must also be passed as NULL.  The return value is the status word
998    or -1 for an invalid SLOT or other non card related error.  If
999    RETBUF is not NULL, it will receive an allocated buffer with the
1000    returned data.  The length of that data will be put into
1001    *RETBUFLEN.  The caller is reponsible for releasing the buffer even
1002    in case of errors.  */
1003 int 
1004 apdu_send_le(int slot, int class, int ins, int p0, int p1,
1005              int lc, const char *data, int le,
1006              unsigned char **retbuf, size_t *retbuflen)
1007 {
1008   unsigned char result[256+10]; /* 10 extra in case of bugs in the driver. */
1009   size_t resultlen = 256;
1010   unsigned char apdu[5+256+1];
1011   size_t apdulen;
1012   int sw;
1013   long rc; /* we need a long here due to PC/SC. */
1014
1015   if (DBG_CARD_IO)
1016     log_debug ("send apdu: c=%02X i=%02X p0=%02X p1=%02X lc=%d le=%d\n",
1017                class, ins, p0, p1, lc, le);
1018
1019   if (lc != -1 && (lc > 255 || lc < 0))
1020     return SW_WRONG_LENGTH; 
1021   if (le != -1 && (le > 256 || le < 1))
1022     return SW_WRONG_LENGTH; 
1023   if ((!data && lc != -1) || (data && lc == -1))
1024     return SW_HOST_INV_VALUE;
1025
1026   apdulen = 0;
1027   apdu[apdulen++] = class;
1028   apdu[apdulen++] = ins;
1029   apdu[apdulen++] = p0;
1030   apdu[apdulen++] = p1;
1031   if (lc != -1)
1032     {
1033       apdu[apdulen++] = lc;
1034       memcpy (apdu+apdulen, data, lc);
1035       apdulen += lc;
1036     }
1037   if (le != -1)
1038     apdu[apdulen++] = le; /* Truncation is okay becuase 0 means 256. */
1039   assert (sizeof (apdu) >= apdulen);
1040   /* As safeguard don't pass any garbage from the stack to the driver. */
1041   memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
1042   rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
1043   if (rc || resultlen < 2)
1044     {
1045       log_error ("apdu_send_simple(%d) failed: %s\n",
1046                  slot, error_string (slot, rc));
1047       return SW_HOST_INCOMPLETE_CARD_RESPONSE;
1048     }
1049   sw = (result[resultlen-2] << 8) | result[resultlen-1];
1050   /* store away the returned data but strip the statusword. */
1051   resultlen -= 2;
1052   if (DBG_CARD_IO)
1053     {
1054       log_debug (" response: sw=%04X  datalen=%d\n", sw, resultlen);
1055       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
1056         log_printhex ("     dump: ", result, resultlen);
1057     }
1058
1059   if (sw == SW_SUCCESS)
1060     {
1061       if (retbuf)
1062         {
1063           *retbuf = xtrymalloc (resultlen? resultlen : 1);
1064           if (!*retbuf)
1065             return SW_HOST_OUT_OF_CORE;
1066           *retbuflen = resultlen;
1067           memcpy (*retbuf, result, resultlen);
1068         }
1069     }
1070   else if ((sw & 0xff00) == SW_MORE_DATA)
1071     {
1072       unsigned char *p = NULL, *tmp;
1073       size_t bufsize = 4096;
1074
1075       /* It is likely that we need to return much more data, so we
1076          start off with a large buffer. */
1077       if (retbuf)
1078         {
1079           *retbuf = p = xtrymalloc (bufsize);
1080           if (!*retbuf)
1081             return SW_HOST_OUT_OF_CORE;
1082           assert (resultlen < bufsize);
1083           memcpy (p, result, resultlen);
1084           p += resultlen;
1085         }
1086
1087       do
1088         {
1089           int len = (sw & 0x00ff);
1090           
1091           log_debug ("apdu_send_simple(%d): %d more bytes available\n",
1092                      slot, len);
1093           apdulen = 0;
1094           apdu[apdulen++] = class;
1095           apdu[apdulen++] = 0xC0;
1096           apdu[apdulen++] = 0;
1097           apdu[apdulen++] = 0;
1098           apdu[apdulen++] = 64; /* that is 256 bytes for Le */
1099           memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
1100           rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
1101           if (rc || resultlen < 2)
1102             {
1103               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
1104                          slot, error_string (slot, rc));
1105               return SW_HOST_INCOMPLETE_CARD_RESPONSE;
1106             }
1107           sw = (result[resultlen-2] << 8) | result[resultlen-1];
1108           resultlen -= 2;
1109           if (DBG_CARD_IO)
1110             {
1111               log_debug ("     more: sw=%04X  datalen=%d\n", sw, resultlen);
1112               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
1113                 log_printhex ("     dump: ", result, resultlen);
1114             }
1115
1116           if ((sw & 0xff00) == SW_MORE_DATA || sw == SW_SUCCESS)
1117             {
1118               if (retbuf)
1119                 {
1120                   if (p - *retbuf + resultlen > bufsize)
1121                     {
1122                       bufsize += resultlen > 4096? resultlen: 4096;
1123                       tmp = xtryrealloc (*retbuf, bufsize);
1124                       if (!tmp)
1125                         return SW_HOST_OUT_OF_CORE;
1126                       p = tmp + (p - *retbuf);
1127                       *retbuf = tmp;
1128                     }
1129                   memcpy (p, result, resultlen);
1130                   p += resultlen;
1131                 }
1132             }
1133           else
1134             log_info ("apdu_send_simple(%d) "
1135                       "got unexpected status %04X from get response\n",
1136                       slot, sw);
1137         }
1138       while ((sw & 0xff00) == SW_MORE_DATA);
1139       
1140       if (retbuf)
1141         {
1142           *retbuflen = p - *retbuf;
1143           tmp = xtryrealloc (*retbuf, *retbuflen);
1144           if (tmp)
1145             *retbuf = tmp;
1146         }
1147     }
1148   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
1149     log_printhex ("      dump: ", *retbuf, *retbuflen);
1150  
1151   return sw;
1152 }
1153
1154 /* Send an APDU to the card in SLOT.  The APDU is created from all
1155    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
1156    LC won't sent this field and the data field; in this case DATA must
1157    also be passed as NULL. The return value is the status word or -1
1158    for an invalid SLOT or other non card related error.  If RETBUF is
1159    not NULL, it will receive an allocated buffer with the returned
1160    data.  The length of that data will be put into *RETBUFLEN.  The
1161    caller is reponsible for releasing the buffer even in case of
1162    errors.  */
1163 int 
1164 apdu_send (int slot, int class, int ins, int p0, int p1,
1165            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
1166 {
1167   return apdu_send_le (slot, class, ins, p0, p1, lc, data, 256, 
1168                        retbuf, retbuflen);
1169 }
1170
1171 /* Send an APDU to the card in SLOT.  The APDU is created from all
1172    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
1173    LC won't sent this field and the data field; in this case DATA must
1174    also be passed as NULL. The return value is the status word or -1
1175    for an invalid SLOT or other non card related error.  No data will be
1176    returned. */
1177 int 
1178 apdu_send_simple (int slot, int class, int ins, int p0, int p1,
1179                   int lc, const char *data)
1180 {
1181   return apdu_send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL);
1182 }
1183
1184
1185
1186