* apdu.c (close_ct_reader, close_pcsc_reader): Implemented.
[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   CT_close (slot);
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   pcsc_release_context (reader_table[slot].pcsc.context);
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 const char *
612 get_ccid_error_string (long err)
613 {
614   if (!err)
615     return "okay";
616   else
617     return "unknown CCID error";
618 }
619
620 static int
621 open_ccid_reader (void)
622 {
623   int err;
624   int slot;
625   reader_table_t slotp;
626
627   slot = new_reader_slot ();
628   if (slot == -1)
629     return -1;
630   slotp = reader_table + slot;
631
632   err = ccid_open_reader (&slotp->ccid.handle, 0);
633   if (err)
634     {
635       slotp->used = 0;
636       return -1;
637     }
638
639   err = ccid_get_atr (slotp->ccid.handle,
640                       slotp->atr, sizeof slotp->atr, &slotp->atrlen);
641   if (err)
642     {
643       slotp->used = 0;
644       return -1;
645     }
646
647   slotp->is_ccid = 1;
648
649   dump_reader_status (slot); 
650   return slot;
651 }
652
653 static int
654 close_ccid_reader (int slot)
655 {
656   ccid_close_reader (reader_table[slot].ccid.handle);
657   reader_table[slot].used = 0;
658   return 0;
659 }                       
660   
661
662
663 /* Actually send the APDU of length APDULEN to SLOT and return a
664    maximum of *BUFLEN data in BUFFER, the actual returned size will be
665    set to BUFLEN.  Returns: Internal CCID driver error code. */
666 static int
667 send_apdu_ccid (int slot, unsigned char *apdu, size_t apdulen,
668                 unsigned char *buffer, size_t *buflen)
669 {
670   long err;
671   size_t maxbuflen;
672
673   if (DBG_CARD_IO)
674     log_printhex ("  APDU_data:", apdu, apdulen);
675
676   maxbuflen = *buflen;
677   err = ccid_transceive (reader_table[slot].ccid.handle,
678                          apdu, apdulen,
679                          buffer, maxbuflen, buflen);
680   if (err)
681     log_error ("ccid_transceive failed: (0x%lx)\n",
682                err);
683   
684   return err? -1:0; /* FIXME: Return appropriate error code. */
685 }
686
687 #endif /* HAVE_LIBUSB */
688
689
690 \f
691 #ifdef HAVE_OPENSC
692 /* 
693      OpenSC Interface.
694
695      This uses the OpenSC primitives to send APDUs.  We need this
696      because we can't mix OpenSC and native (i.e. ctAPI or PC/SC)
697      access to a card for resource conflict reasons.
698  */
699
700 static int
701 open_osc_reader (int portno)
702 {
703   int err;
704   int slot;
705   reader_table_t slotp;
706
707   slot = new_reader_slot ();
708   if (slot == -1)
709     return -1;
710   slotp = reader_table + slot;
711
712   err = sc_establish_context (&slotp->osc.ctx, "scdaemon");
713   if (err)
714     {
715       log_error ("failed to establish SC context: %s\n", sc_strerror (err));
716       slotp->used = 0;
717       return -1;
718     }
719   if (portno < 0 || portno >= slotp->osc.ctx->reader_count)
720     {
721       log_error ("no card reader available\n");
722       sc_release_context (slotp->osc.ctx);
723       slotp->used = 0;
724       return -1;
725     }
726
727   /* Redirect to our logging facility. */
728   slotp->osc.ctx->error_file = log_get_stream ();
729   slotp->osc.ctx->debug = opt.debug_sc;
730   slotp->osc.ctx->debug_file = log_get_stream ();
731
732   if (sc_detect_card_presence (slotp->osc.ctx->reader[portno], 0) != 1)
733     {
734       log_error ("no card present\n");
735       sc_release_context (slotp->osc.ctx);
736       slotp->used = 0;
737       return -1;
738     }
739   
740   /* We want the standard ISO driver. */
741   /*FIXME: OpenSC does not like "iso7816", so we use EMV for now. */
742   err = sc_set_card_driver(slotp->osc.ctx, "emv");
743   if (err)
744     {
745       log_error ("failed to select the iso7816 driver: %s\n",
746                  sc_strerror (err));
747       sc_release_context (slotp->osc.ctx);
748       slotp->used = 0;
749       return -1;
750     }
751
752   /* Now connect the card and hope that OpenSC won't try to be too
753      smart. */
754   err = sc_connect_card (slotp->osc.ctx->reader[portno], 0,
755                          &slotp->osc.scard);
756   if (err)
757     {
758       log_error ("failed to connect card in reader %d: %s\n",
759                  portno, sc_strerror (err));
760       sc_release_context (slotp->osc.ctx);
761       slotp->used = 0;
762       return -1;
763     }
764   if (opt.verbose)
765     log_info ("connected to card in opensc reader %d using driver `%s'\n",
766               portno, slotp->osc.scard->driver->name);
767
768   err = sc_lock (slotp->osc.scard);
769   if (err)
770     {
771       log_error ("can't lock card in reader %d: %s\n",
772                  portno, sc_strerror (err));
773       sc_disconnect_card (slotp->osc.scard, 0);
774       sc_release_context (slotp->osc.ctx);
775       slotp->used = 0;
776       return -1;
777     }
778
779   if (slotp->osc.scard->atr_len >= DIM (slotp->atr))
780     log_bug ("ATR returned by opensc is too large\n");
781   slotp->atrlen = slotp->osc.scard->atr_len;
782   memcpy (slotp->atr, slotp->osc.scard->atr, slotp->atrlen);
783
784   slotp->is_osc = 1;
785
786   dump_reader_status (slot); 
787   return slot;
788 }
789
790
791 static int
792 close_osc_reader (int slot)
793 {
794   /* FIXME: Implement. */
795   reader_table[slot].used = 0;
796   return 0;
797 }
798
799
800
801 /* Actually send the APDU of length APDULEN to SLOT and return a
802    maximum of *BUFLEN data in BUFFER, the actual returned size will be
803    set to BUFLEN.  Returns: OpenSC error code. */
804 static int
805 osc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
806                 unsigned char *buffer, size_t *buflen)
807 {
808   long err;
809   struct sc_apdu a;
810   unsigned char data[SC_MAX_APDU_BUFFER_SIZE];
811   unsigned char result[SC_MAX_APDU_BUFFER_SIZE];
812
813   if (DBG_CARD_IO)
814     log_printhex ("  APDU_data:", apdu, apdulen);
815
816   if (apdulen < 4)
817     {
818       log_error ("osc_send_apdu: APDU is too short\n");
819       return SC_ERROR_CMD_TOO_SHORT;
820     }
821
822   memset(&a, 0, sizeof a);
823   a.cla = *apdu++;
824   a.ins = *apdu++;
825   a.p1 = *apdu++;
826   a.p2 = *apdu++;
827   apdulen -= 4;
828
829   if (!apdulen)
830     a.cse = SC_APDU_CASE_1;
831   else if (apdulen == 1) 
832     {
833       a.le = *apdu? *apdu : 256;
834       apdu++; apdulen--;
835       a.cse = SC_APDU_CASE_2_SHORT;
836     }
837   else
838     {
839       a.lc = *apdu++; apdulen--;
840       if (apdulen < a.lc)
841         {
842           log_error ("osc_send_apdu: APDU shorter than specified in Lc\n");
843           return SC_ERROR_CMD_TOO_SHORT;
844
845         }
846       memcpy(data, apdu, a.lc);
847       apdu += a.lc; apdulen -= a.lc;
848
849       a.data = data;
850       a.datalen = a.lc;
851       
852       if (!apdulen)
853         a.cse = SC_APDU_CASE_3_SHORT;
854       else
855         {
856           a.le = *apdu? *apdu : 256;
857           apdu++; apdulen--;
858           if (apdulen)
859             {
860               log_error ("osc_send_apdu: APDU larger than specified\n");
861               return SC_ERROR_CMD_TOO_LONG;
862             }
863           a.cse = SC_APDU_CASE_4_SHORT;
864         }
865     }
866
867   a.resp = result;
868   a.resplen = DIM(result);
869
870   err = sc_transmit_apdu (reader_table[slot].osc.scard, &a);
871   if (err)
872     {
873       log_error ("sc_apdu_transmit failed: %s\n", sc_strerror (err));
874       return err;
875     }
876
877   if (*buflen < 2 || a.resplen > *buflen - 2)
878     {
879       log_error ("osc_send_apdu: provided buffer too short to store result\n");
880       return SC_ERROR_BUFFER_TOO_SMALL;
881     }
882   memcpy (buffer, a.resp, a.resplen);
883   buffer[a.resplen] = a.sw1;
884   buffer[a.resplen+1] = a.sw2;
885   *buflen = a.resplen + 2;
886   return 0;
887 }
888
889 #endif /* HAVE_OPENSC */
890
891
892 \f
893 /* 
894        Driver Access
895  */
896
897 /* Open the reader and return an internal slot number or -1 on
898    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
899    the first USB reader.  For PC/SC the first listed reader).  If
900    OpenSC support is compiled in, we first try to use OpenSC. */
901 int
902 apdu_open_reader (const char *portstr)
903 {
904   static int pcsc_api_loaded, ct_api_loaded;
905
906 #ifdef HAVE_LIBUSB
907   if (!opt.disable_ccid)
908     {
909       int slot;
910
911       slot = open_ccid_reader ();
912       if (slot != -1)
913         return slot; /* got one */
914     }
915 #endif /* HAVE_LIBUSB */
916
917 #ifdef HAVE_OPENSC
918   if (!opt.disable_opensc)
919     {
920       int port = portstr? atoi (portstr) : 0;
921
922       return open_osc_reader (port);
923     }
924 #endif /* HAVE_OPENSC */  
925
926
927   if (opt.ctapi_driver && *opt.ctapi_driver)
928     {
929       int port = portstr? atoi (portstr) : 32768;
930
931       if (!ct_api_loaded)
932         {
933           void *handle;
934           
935           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
936           if (!handle)
937             {
938               log_error ("apdu_open_reader: failed to open driver: %s",
939                          dlerror ());
940               return -1;
941             }
942           CT_init = dlsym (handle, "CT_init");
943           CT_data = dlsym (handle, "CT_data");
944           CT_close = dlsym (handle, "CT_close");
945           if (!CT_init || !CT_data || !CT_close)
946             {
947               log_error ("apdu_open_reader: invalid CT-API driver\n");
948               dlclose (handle);
949               return -1;
950             }
951           ct_api_loaded = 1;
952         }
953       return open_ct_reader (port);
954     }
955
956   
957   /* No ctAPI configured, so lets try the PC/SC API */
958   if (!pcsc_api_loaded)
959     {
960       void *handle;
961
962       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
963       if (!handle)
964         {
965           log_error ("apdu_open_reader: failed to open driver `%s': %s",
966                      opt.pcsc_driver, dlerror ());
967           return -1;
968         }
969
970       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
971       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
972       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
973 #ifdef _WIN32
974       if (!pcsc_list_readers)
975         pcsc_list_readers    = dlsym (handle, "SCardListReadersA");
976 #endif
977       pcsc_connect           = dlsym (handle, "SCardConnect");
978 #ifdef _WIN32
979       if (!pcsc_connect)
980         pcsc_connect         = dlsym (handle, "SCardConnectA");
981 #endif
982       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
983       pcsc_status            = dlsym (handle, "SCardStatus");
984 #ifdef _WIN32
985       if (!pcsc_status)
986         pcsc_status          = dlsym (handle, "SCardStatusA");
987 #endif
988       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
989       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
990       pcsc_transmit          = dlsym (handle, "SCardTransmit");
991       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
992
993       if (!pcsc_establish_context
994           || !pcsc_release_context  
995           || !pcsc_list_readers     
996           || !pcsc_connect          
997           || !pcsc_disconnect
998           || !pcsc_status
999           || !pcsc_begin_transaction
1000           || !pcsc_end_transaction
1001           || !pcsc_transmit         
1002           /* || !pcsc_set_timeout */)
1003         {
1004           /* Note that set_timeout is currently not used and also not
1005              available under Windows. */
1006           log_error ("apdu_open_reader: invalid PC/SC driver "
1007                      "(%d%d%d%d%d%d%d%d%d%d)\n",
1008                      !!pcsc_establish_context,
1009                      !!pcsc_release_context,  
1010                      !!pcsc_list_readers,     
1011                      !!pcsc_connect,          
1012                      !!pcsc_disconnect,
1013                      !!pcsc_status,
1014                      !!pcsc_begin_transaction,
1015                      !!pcsc_end_transaction,
1016                      !!pcsc_transmit,         
1017                      !!pcsc_set_timeout );
1018           dlclose (handle);
1019           return -1;
1020         }
1021       pcsc_api_loaded = 1;
1022     }
1023   
1024   return open_pcsc_reader (portstr);
1025 }
1026
1027
1028 int
1029 apdu_close_reader (int slot)
1030 {
1031   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1032     return SW_HOST_NO_DRIVER;
1033   if (reader_table[slot].is_ctapi)
1034     return close_ct_reader (slot);
1035 #ifdef HAVE_LIBUSB
1036   else if (reader_table[slot].is_ccid)
1037     return close_ccid_reader (slot);
1038 #endif
1039 #ifdef HAVE_OPENSC
1040   else if (reader_table[slot].is_osc)
1041     return close_osc_reader (slot);
1042 #endif
1043   else
1044     return close_pcsc_reader (slot);
1045 }
1046
1047
1048 unsigned char *
1049 apdu_get_atr (int slot, size_t *atrlen)
1050 {
1051   char *buf;
1052
1053   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1054     return NULL;
1055   
1056   buf = xtrymalloc (reader_table[slot].atrlen);
1057   if (!buf)
1058     return NULL;
1059   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
1060   *atrlen = reader_table[slot].atrlen;
1061   return buf;
1062 }
1063   
1064     
1065 static const char *
1066 error_string (int slot, long rc)
1067 {
1068   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1069     return "[invalid slot]";
1070   if (reader_table[slot].is_ctapi)
1071     return ct_error_string (rc);
1072 #ifdef HAVE_LIBUSB
1073   else if (reader_table[slot].is_ccid)
1074     return get_ccid_error_string (rc);
1075 #endif
1076 #ifdef HAVE_OPENSC
1077   else if (reader_table[slot].is_osc)
1078     return sc_strerror (rc);
1079 #endif
1080   else
1081     return pcsc_error_string (rc);
1082 }
1083
1084
1085 /* Dispatcher for the actual send_apdu fucntion. */
1086 static int
1087 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
1088            unsigned char *buffer, size_t *buflen)
1089 {
1090   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1091     return SW_HOST_NO_DRIVER;
1092   if (reader_table[slot].is_ctapi)
1093     return ct_send_apdu (slot, apdu, apdulen, buffer, buflen);
1094 #ifdef HAVE_LIBUSB
1095   else if (reader_table[slot].is_ccid)
1096     return send_apdu_ccid (slot, apdu, apdulen, buffer, buflen);
1097 #endif
1098 #ifdef HAVE_OPENSC
1099   else if (reader_table[slot].is_osc)
1100     return osc_send_apdu (slot, apdu, apdulen, buffer, buflen);
1101 #endif
1102   else
1103     return pcsc_send_apdu (slot, apdu, apdulen, buffer, buflen);
1104 }
1105
1106 /* Send an APDU to the card in SLOT.  The APDU is created from all
1107    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
1108    for LC won't sent this field and the data field; in this case DATA
1109    must also be passed as NULL.  The return value is the status word
1110    or -1 for an invalid SLOT or other non card related error.  If
1111    RETBUF is not NULL, it will receive an allocated buffer with the
1112    returned data.  The length of that data will be put into
1113    *RETBUFLEN.  The caller is reponsible for releasing the buffer even
1114    in case of errors.  */
1115 int 
1116 apdu_send_le(int slot, int class, int ins, int p0, int p1,
1117              int lc, const char *data, int le,
1118              unsigned char **retbuf, size_t *retbuflen)
1119 {
1120   unsigned char result[256+10]; /* 10 extra in case of bugs in the driver. */
1121   size_t resultlen = 256;
1122   unsigned char apdu[5+256+1];
1123   size_t apdulen;
1124   int sw;
1125   long rc; /* we need a long here due to PC/SC. */
1126
1127   if (DBG_CARD_IO)
1128     log_debug ("send apdu: c=%02X i=%02X p0=%02X p1=%02X lc=%d le=%d\n",
1129                class, ins, p0, p1, lc, le);
1130
1131   if (lc != -1 && (lc > 255 || lc < 0))
1132     return SW_WRONG_LENGTH; 
1133   if (le != -1 && (le > 256 || le < 1))
1134     return SW_WRONG_LENGTH; 
1135   if ((!data && lc != -1) || (data && lc == -1))
1136     return SW_HOST_INV_VALUE;
1137
1138   apdulen = 0;
1139   apdu[apdulen++] = class;
1140   apdu[apdulen++] = ins;
1141   apdu[apdulen++] = p0;
1142   apdu[apdulen++] = p1;
1143   if (lc != -1)
1144     {
1145       apdu[apdulen++] = lc;
1146       memcpy (apdu+apdulen, data, lc);
1147       apdulen += lc;
1148     }
1149   if (le != -1)
1150     apdu[apdulen++] = le; /* Truncation is okay becuase 0 means 256. */
1151   assert (sizeof (apdu) >= apdulen);
1152   /* As safeguard don't pass any garbage from the stack to the driver. */
1153   memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
1154   rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
1155   if (rc || resultlen < 2)
1156     {
1157       log_error ("apdu_send_simple(%d) failed: %s\n",
1158                  slot, error_string (slot, rc));
1159       return SW_HOST_INCOMPLETE_CARD_RESPONSE;
1160     }
1161   sw = (result[resultlen-2] << 8) | result[resultlen-1];
1162   /* store away the returned data but strip the statusword. */
1163   resultlen -= 2;
1164   if (DBG_CARD_IO)
1165     {
1166       log_debug (" response: sw=%04X  datalen=%d\n", sw, resultlen);
1167       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
1168         log_printhex ("     dump: ", result, resultlen);
1169     }
1170
1171   if (sw == SW_SUCCESS)
1172     {
1173       if (retbuf)
1174         {
1175           *retbuf = xtrymalloc (resultlen? resultlen : 1);
1176           if (!*retbuf)
1177             return SW_HOST_OUT_OF_CORE;
1178           *retbuflen = resultlen;
1179           memcpy (*retbuf, result, resultlen);
1180         }
1181     }
1182   else if ((sw & 0xff00) == SW_MORE_DATA)
1183     {
1184       unsigned char *p = NULL, *tmp;
1185       size_t bufsize = 4096;
1186
1187       /* It is likely that we need to return much more data, so we
1188          start off with a large buffer. */
1189       if (retbuf)
1190         {
1191           *retbuf = p = xtrymalloc (bufsize);
1192           if (!*retbuf)
1193             return SW_HOST_OUT_OF_CORE;
1194           assert (resultlen < bufsize);
1195           memcpy (p, result, resultlen);
1196           p += resultlen;
1197         }
1198
1199       do
1200         {
1201           int len = (sw & 0x00ff);
1202           
1203           log_debug ("apdu_send_simple(%d): %d more bytes available\n",
1204                      slot, len);
1205           apdulen = 0;
1206           apdu[apdulen++] = class;
1207           apdu[apdulen++] = 0xC0;
1208           apdu[apdulen++] = 0;
1209           apdu[apdulen++] = 0;
1210           apdu[apdulen++] = 64; /* that is 256 bytes for Le */
1211           memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
1212           rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
1213           if (rc || resultlen < 2)
1214             {
1215               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
1216                          slot, error_string (slot, rc));
1217               return SW_HOST_INCOMPLETE_CARD_RESPONSE;
1218             }
1219           sw = (result[resultlen-2] << 8) | result[resultlen-1];
1220           resultlen -= 2;
1221           if (DBG_CARD_IO)
1222             {
1223               log_debug ("     more: sw=%04X  datalen=%d\n", sw, resultlen);
1224               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
1225                 log_printhex ("     dump: ", result, resultlen);
1226             }
1227
1228           if ((sw & 0xff00) == SW_MORE_DATA || sw == SW_SUCCESS)
1229             {
1230               if (retbuf)
1231                 {
1232                   if (p - *retbuf + resultlen > bufsize)
1233                     {
1234                       bufsize += resultlen > 4096? resultlen: 4096;
1235                       tmp = xtryrealloc (*retbuf, bufsize);
1236                       if (!tmp)
1237                         return SW_HOST_OUT_OF_CORE;
1238                       p = tmp + (p - *retbuf);
1239                       *retbuf = tmp;
1240                     }
1241                   memcpy (p, result, resultlen);
1242                   p += resultlen;
1243                 }
1244             }
1245           else
1246             log_info ("apdu_send_simple(%d) "
1247                       "got unexpected status %04X from get response\n",
1248                       slot, sw);
1249         }
1250       while ((sw & 0xff00) == SW_MORE_DATA);
1251       
1252       if (retbuf)
1253         {
1254           *retbuflen = p - *retbuf;
1255           tmp = xtryrealloc (*retbuf, *retbuflen);
1256           if (tmp)
1257             *retbuf = tmp;
1258         }
1259     }
1260   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
1261     log_printhex ("      dump: ", *retbuf, *retbuflen);
1262  
1263   return sw;
1264 }
1265
1266 /* Send an APDU to the card in SLOT.  The APDU is created from all
1267    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
1268    LC won't sent this field and the data field; in this case DATA must
1269    also be passed as NULL. The return value is the status word or -1
1270    for an invalid SLOT or other non card related error.  If RETBUF is
1271    not NULL, it will receive an allocated buffer with the returned
1272    data.  The length of that data will be put into *RETBUFLEN.  The
1273    caller is reponsible for releasing the buffer even in case of
1274    errors.  */
1275 int 
1276 apdu_send (int slot, int class, int ins, int p0, int p1,
1277            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
1278 {
1279   return apdu_send_le (slot, class, ins, p0, p1, lc, data, 256, 
1280                        retbuf, retbuflen);
1281 }
1282
1283 /* Send an APDU to the card in SLOT.  The APDU is created from all
1284    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
1285    LC won't sent this field and the data field; in this case DATA must
1286    also be passed as NULL. The return value is the status word or -1
1287    for an invalid SLOT or other non card related error.  No data will be
1288    returned. */
1289 int 
1290 apdu_send_simple (int slot, int class, int ins, int p0, int p1,
1291                   int lc, const char *data)
1292 {
1293   return apdu_send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL);
1294 }
1295
1296
1297
1298