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