* configure.ac: Required newer versions of some libraries.
[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 compiled 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 /* HAVE_LIBUSB */
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       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
890       if (!handle)
891         {
892           log_error ("apdu_open_reader: failed to open driver `%s': %s",
893                      opt.pcsc_driver, dlerror ());
894           return -1;
895         }
896
897       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
898       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
899       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
900       pcsc_connect           = dlsym (handle, "SCardConnect");
901       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
902       pcsc_status            = dlsym (handle, "SCardStatus");
903       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
904       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
905       pcsc_transmit          = dlsym (handle, "SCardTransmit");
906       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
907
908       if (!pcsc_establish_context
909           || !pcsc_release_context  
910           || !pcsc_list_readers     
911           || !pcsc_connect          
912           || !pcsc_disconnect
913           || !pcsc_status
914           || !pcsc_begin_transaction
915           || !pcsc_end_transaction
916           || !pcsc_transmit         
917           || !pcsc_set_timeout)
918         {
919           log_error ("apdu_open_reader: invalid PC/SC driver\n");
920           dlclose (handle);
921           return -1;
922         }
923       pcsc_api_loaded = 1;
924     }
925   
926   return open_pcsc_reader (portstr);
927 }
928
929
930 unsigned char *
931 apdu_get_atr (int slot, size_t *atrlen)
932 {
933   char *buf;
934
935   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
936     return NULL;
937   
938   buf = xtrymalloc (reader_table[slot].atrlen);
939   if (!buf)
940     return NULL;
941   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
942   *atrlen = reader_table[slot].atrlen;
943   return buf;
944 }
945   
946     
947 static const char *
948 error_string (int slot, long rc)
949 {
950   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
951     return "[invalid slot]";
952   if (reader_table[slot].is_ctapi)
953     return ct_error_string (rc);
954 #ifdef HAVE_LIBUSB
955   else if (reader_table[slot].is_ccid)
956     return "no CCID driver error strings yet";
957 #endif
958 #ifdef HAVE_OPENSC
959   else if (reader_table[slot].is_osc)
960     return sc_strerror (rc);
961 #endif
962   else
963     return pcsc_error_string (rc);
964 }
965
966
967 /* Dispatcher for the actual send_apdu fucntion. */
968 static int
969 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
970            unsigned char *buffer, size_t *buflen)
971 {
972   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
973     return SW_HOST_NO_DRIVER;
974   if (reader_table[slot].is_ctapi)
975     return ct_send_apdu (slot, apdu, apdulen, buffer, buflen);
976 #ifdef HAVE_LIBUSB
977   else if (reader_table[slot].is_ccid)
978     return send_apdu_ccid (slot, apdu, apdulen, buffer, buflen);
979 #endif
980 #ifdef HAVE_OPENSC
981   else if (reader_table[slot].is_osc)
982     return osc_send_apdu (slot, apdu, apdulen, buffer, buflen);
983 #endif
984   else
985     return pcsc_send_apdu (slot, apdu, apdulen, buffer, buflen);
986 }
987
988 /* Send an APDU to the card in SLOT.  The APDU is created from all
989    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
990    for LC won't sent this field and the data field; in this case DATA
991    must also be passed as NULL.  The return value is the status word
992    or -1 for an invalid SLOT or other non card related error.  If
993    RETBUF is not NULL, it will receive an allocated buffer with the
994    returned data.  The length of that data will be put into
995    *RETBUFLEN.  The caller is reponsible for releasing the buffer even
996    in case of errors.  */
997 int 
998 apdu_send_le(int slot, int class, int ins, int p0, int p1,
999              int lc, const char *data, int le,
1000              unsigned char **retbuf, size_t *retbuflen)
1001 {
1002   unsigned char result[256+10]; /* 10 extra in case of bugs in the driver. */
1003   size_t resultlen = 256;
1004   unsigned char apdu[5+256+1];
1005   size_t apdulen;
1006   int sw;
1007   long rc; /* we need a long here due to PC/SC. */
1008
1009   if (DBG_CARD_IO)
1010     log_debug ("send apdu: c=%02X i=%02X p0=%02X p1=%02X lc=%d le=%d\n",
1011                class, ins, p0, p1, lc, le);
1012
1013   if (lc != -1 && (lc > 255 || lc < 0))
1014     return SW_WRONG_LENGTH; 
1015   if (le != -1 && (le > 256 || le < 1))
1016     return SW_WRONG_LENGTH; 
1017   if ((!data && lc != -1) || (data && lc == -1))
1018     return SW_HOST_INV_VALUE;
1019
1020   apdulen = 0;
1021   apdu[apdulen++] = class;
1022   apdu[apdulen++] = ins;
1023   apdu[apdulen++] = p0;
1024   apdu[apdulen++] = p1;
1025   if (lc != -1)
1026     {
1027       apdu[apdulen++] = lc;
1028       memcpy (apdu+apdulen, data, lc);
1029       apdulen += lc;
1030     }
1031   if (le != -1)
1032     apdu[apdulen++] = le; /* Truncation is okay becuase 0 means 256. */
1033   assert (sizeof (apdu) >= apdulen);
1034   /* As safeguard don't pass any garbage from the stack to the driver. */
1035   memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
1036   rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
1037   if (rc || resultlen < 2)
1038     {
1039       log_error ("apdu_send_simple(%d) failed: %s\n",
1040                  slot, error_string (slot, rc));
1041       return SW_HOST_INCOMPLETE_CARD_RESPONSE;
1042     }
1043   sw = (result[resultlen-2] << 8) | result[resultlen-1];
1044   /* store away the returned data but strip the statusword. */
1045   resultlen -= 2;
1046   if (DBG_CARD_IO)
1047     {
1048       log_debug (" response: sw=%04X  datalen=%d\n", sw, resultlen);
1049       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
1050         log_printhex ("     dump: ", result, resultlen);
1051     }
1052
1053   if (sw == SW_SUCCESS)
1054     {
1055       if (retbuf)
1056         {
1057           *retbuf = xtrymalloc (resultlen? resultlen : 1);
1058           if (!*retbuf)
1059             return SW_HOST_OUT_OF_CORE;
1060           *retbuflen = resultlen;
1061           memcpy (*retbuf, result, resultlen);
1062         }
1063     }
1064   else if ((sw & 0xff00) == SW_MORE_DATA)
1065     {
1066       unsigned char *p = NULL, *tmp;
1067       size_t bufsize = 4096;
1068
1069       /* It is likely that we need to return much more data, so we
1070          start off with a large buffer. */
1071       if (retbuf)
1072         {
1073           *retbuf = p = xtrymalloc (bufsize);
1074           if (!*retbuf)
1075             return SW_HOST_OUT_OF_CORE;
1076           assert (resultlen < bufsize);
1077           memcpy (p, result, resultlen);
1078           p += resultlen;
1079         }
1080
1081       do
1082         {
1083           int len = (sw & 0x00ff);
1084           
1085           log_debug ("apdu_send_simple(%d): %d more bytes available\n",
1086                      slot, len);
1087           apdulen = 0;
1088           apdu[apdulen++] = class;
1089           apdu[apdulen++] = 0xC0;
1090           apdu[apdulen++] = 0;
1091           apdu[apdulen++] = 0;
1092           apdu[apdulen++] = 64; /* that is 256 bytes for Le */
1093           memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
1094           rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
1095           if (rc || resultlen < 2)
1096             {
1097               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
1098                          slot, error_string (slot, rc));
1099               return SW_HOST_INCOMPLETE_CARD_RESPONSE;
1100             }
1101           sw = (result[resultlen-2] << 8) | result[resultlen-1];
1102           resultlen -= 2;
1103           if (DBG_CARD_IO)
1104             {
1105               log_debug ("     more: sw=%04X  datalen=%d\n", sw, resultlen);
1106               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
1107                 log_printhex ("     dump: ", result, resultlen);
1108             }
1109
1110           if ((sw & 0xff00) == SW_MORE_DATA || sw == SW_SUCCESS)
1111             {
1112               if (retbuf)
1113                 {
1114                   if (p - *retbuf + resultlen > bufsize)
1115                     {
1116                       bufsize += resultlen > 4096? resultlen: 4096;
1117                       tmp = xtryrealloc (*retbuf, bufsize);
1118                       if (!tmp)
1119                         return SW_HOST_OUT_OF_CORE;
1120                       p = tmp + (p - *retbuf);
1121                       *retbuf = tmp;
1122                     }
1123                   memcpy (p, result, resultlen);
1124                   p += resultlen;
1125                 }
1126             }
1127           else
1128             log_info ("apdu_send_simple(%d) "
1129                       "got unexpected status %04X from get response\n",
1130                       slot, sw);
1131         }
1132       while ((sw & 0xff00) == SW_MORE_DATA);
1133       
1134       if (retbuf)
1135         {
1136           *retbuflen = p - *retbuf;
1137           tmp = xtryrealloc (*retbuf, *retbuflen);
1138           if (tmp)
1139             *retbuf = tmp;
1140         }
1141     }
1142   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
1143     log_printhex ("      dump: ", *retbuf, *retbuflen);
1144  
1145   return sw;
1146 }
1147
1148 /* Send an APDU to the card in SLOT.  The APDU is created from all
1149    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
1150    LC won't sent this field and the data field; in this case DATA must
1151    also be passed as NULL. The return value is the status word or -1
1152    for an invalid SLOT or other non card related error.  If RETBUF is
1153    not NULL, it will receive an allocated buffer with the returned
1154    data.  The length of that data will be put into *RETBUFLEN.  The
1155    caller is reponsible for releasing the buffer even in case of
1156    errors.  */
1157 int 
1158 apdu_send (int slot, int class, int ins, int p0, int p1,
1159            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
1160 {
1161   return apdu_send_le (slot, class, ins, p0, p1, lc, data, 256, 
1162                        retbuf, retbuflen);
1163 }
1164
1165 /* Send an APDU to the card in SLOT.  The APDU is created from all
1166    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
1167    LC won't sent this field and the data field; in this case DATA must
1168    also be passed as NULL. The return value is the status word or -1
1169    for an invalid SLOT or other non card related error.  No data will be
1170    returned. */
1171 int 
1172 apdu_send_simple (int slot, int class, int ins, int p0, int p1,
1173                   int lc, const char *data)
1174 {
1175   return apdu_send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL);
1176 }
1177
1178
1179
1180