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