2b17ef53bd0d4fd1de41ec81aa6ae7815ccf9a11
[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           return -1;
302         }
303
304       /* Store the type and the ATR. */
305       if (buflen - 2 > DIM (reader_table[0].atr))
306         {
307           log_error ("ct_activate_card(%d): ATR too long\n", reader);
308           return -1;
309         }
310
311       reader_table[reader].status = buf[buflen - 1];
312       memcpy (reader_table[reader].atr, buf, buflen - 2);
313       reader_table[reader].atrlen = buflen - 2;
314       return 0;
315     }
316  
317   log_info ("ct_activate_card(%d): timeout waiting for card\n", reader);
318   return -1;
319 }
320
321
322 /* Open a reader and return an internal handle for it.  PORT is a
323    non-negative value with the port number of the reader. USB readers
324    do have port numbers starting at 32769. */
325 static int
326 open_ct_reader (int port)
327 {
328   int rc, reader;
329
330   if (port < 0 || port > 0xffff)
331     {
332       log_error ("open_ct_reader: invalid port %d requested\n", port);
333       return -1;
334     }
335   reader = new_reader_slot ();
336   if (reader == -1)
337     return reader;
338   reader_table[reader].port = port;
339
340   rc = CT_init (reader, (unsigned short)port);
341   if (rc)
342     {
343       log_error ("apdu_open_ct_reader failed on port %d: %s\n",
344                  port, ct_error_string (rc));
345       reader_table[reader].used = 0;
346       return -1;
347     }
348
349   rc = ct_activate_card (reader);
350   if (rc)
351     {
352       reader_table[reader].used = 0;
353       return -1;
354     }
355
356   reader_table[reader].is_ctapi = 1;
357   dump_reader_status (reader);
358   return reader;
359 }
360
361 static int
362 close_ct_reader (int slot)
363 {
364   /* FIXME: Implement. */
365   reader_table[slot].used = 0;
366   return 0;
367 }
368
369
370 /* Actually send the APDU of length APDULEN to SLOT and return a
371    maximum of *BUFLEN data in BUFFER, the actual retruned size will be
372    set to BUFLEN.  Returns: CT API error code. */
373 static int
374 ct_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
375               unsigned char *buffer, size_t *buflen)
376 {
377   int rc;
378   unsigned char dad[1], sad[1];
379   unsigned short ctbuflen;
380   
381   dad[0] = 0;     /* Destination address: Card. */    
382   sad[0] = 2;     /* Source address: Host. */
383   ctbuflen = *buflen;
384   if (DBG_CARD_IO)
385     log_printhex ("  CT_data:", apdu, apdulen);
386   rc = CT_data (slot, dad, sad, apdulen, apdu, &ctbuflen, buffer);
387   *buflen = ctbuflen;
388
389   /* FIXME: map the errorcodes to GNUPG ones, so that they can be
390      shared between CTAPI and PCSC. */
391   return rc;
392 }
393
394
395 \f
396 static const char *
397 pcsc_error_string (long err)
398 {
399   const char *s;
400
401   if (!err)
402     return "okay";
403   if ((err & 0x80100000) != 0x80100000)
404     return "invalid PC/SC error code";
405   err &= 0xffff;
406   switch (err)
407     {
408     case 0x0002: s = "cancelled"; break;
409     case 0x000e: s = "can't dispose"; break;
410     case 0x0008: s = "insufficient buffer"; break;   
411     case 0x0015: s = "invalid ATR"; break;
412     case 0x0003: s = "invalid handle"; break;
413     case 0x0004: s = "invalid parameter"; break; 
414     case 0x0005: s = "invalid target"; break;
415     case 0x0011: s = "invalid value"; break; 
416     case 0x0006: s = "no memory"; break;  
417     case 0x0013: s = "comm error"; break;      
418     case 0x0001: s = "internal error"; break;     
419     case 0x0014: s = "unknown error"; break; 
420     case 0x0007: s = "waited too long"; break;  
421     case 0x0009: s = "unknown reader"; break;
422     case 0x000a: s = "timeout"; break; 
423     case 0x000b: s = "sharing violation"; break;       
424     case 0x000c: s = "no smartcard"; break;
425     case 0x000d: s = "unknown card"; break;   
426     case 0x000f: s = "proto mismatch"; break;          
427     case 0x0010: s = "not ready"; break;               
428     case 0x0012: s = "system cancelled"; break;        
429     case 0x0016: s = "not transacted"; break;
430     case 0x0017: s = "reader unavailable"; break; 
431     case 0x0065: s = "unsupported card"; break;        
432     case 0x0066: s = "unresponsive card"; break;       
433     case 0x0067: s = "unpowered card"; break;          
434     case 0x0068: s = "reset card"; break;              
435     case 0x0069: s = "removed card"; break;            
436     case 0x006a: s = "inserted card"; break;           
437     case 0x001f: s = "unsupported feature"; break;     
438     case 0x0019: s = "PCI too small"; break;           
439     case 0x001a: s = "reader unsupported"; break;      
440     case 0x001b: s = "duplicate reader"; break;        
441     case 0x001c: s = "card unsupported"; break;        
442     case 0x001d: s = "no service"; break;              
443     case 0x001e: s = "service stopped"; break;      
444     default:     s = "unknown PC/SC error code"; break;
445     }
446   return s;
447 }
448
449 /* 
450        PC/SC Interface
451  */
452
453 static int
454 open_pcsc_reader (const char *portstr)
455 {
456   long err;
457   int slot;
458   char *list = NULL;
459   unsigned long nreader, listlen, atrlen;
460   char *p;
461   unsigned long card_state, card_protocol;
462
463   slot = new_reader_slot ();
464   if (slot == -1)
465     return -1;
466
467   err = pcsc_establish_context (PCSC_SCOPE_SYSTEM, NULL, NULL,
468                                 &reader_table[slot].pcsc.context);
469   if (err)
470     {
471       log_error ("pcsc_establish_context failed: %s (0x%lx)\n",
472                  pcsc_error_string (err), err);
473       reader_table[slot].used = 0;
474       return -1;
475     }
476   
477   err = pcsc_list_readers (reader_table[slot].pcsc.context,
478                            NULL, NULL, &nreader);
479   if (!err)
480     {
481       list = xtrymalloc (nreader+1); /* Better add 1 for safety reasons. */
482       if (!list)
483         {
484           log_error ("error allocating memory for reader list\n");
485           pcsc_release_context (reader_table[slot].pcsc.context);
486           reader_table[slot].used = 0;
487           return -1;
488         }
489       err = pcsc_list_readers (reader_table[slot].pcsc.context,
490                                NULL, list, &nreader);
491     }
492   if (err)
493     {
494       log_error ("pcsc_list_readers failed: %s (0x%lx)\n",
495                  pcsc_error_string (err), err);
496       pcsc_release_context (reader_table[slot].pcsc.context);
497       reader_table[slot].used = 0;
498       xfree (list);
499       return -1;
500     }
501
502   listlen = nreader;
503   p = list;
504   while (nreader)
505     {
506       if (!*p && !p[1])
507         break;
508       log_info ("detected reader `%s'\n", p);
509       if (nreader < (strlen (p)+1))
510         {
511           log_error ("invalid response from pcsc_list_readers\n");
512           break;
513         }
514       nreader -= strlen (p)+1;
515       p += strlen (p) + 1;
516     }
517
518   err = pcsc_connect (reader_table[slot].pcsc.context,
519                       portstr? portstr : list,
520                       PCSC_SHARE_EXCLUSIVE,
521                       PCSC_PROTOCOL_T0|PCSC_PROTOCOL_T1,
522                       &reader_table[slot].pcsc.card,
523                       &reader_table[slot].pcsc.protocol);
524   if (err)
525     {
526       log_error ("pcsc_connect failed: %s (0x%lx)\n",
527                   pcsc_error_string (err), err);
528       pcsc_release_context (reader_table[slot].pcsc.context);
529       reader_table[slot].used = 0;
530       xfree (list);
531       return -1;
532     }      
533   
534   atrlen = 32;
535   /* (We need to pass a dummy buffer.  We use LIST because it ought to
536      be large enough.) */
537   err = pcsc_status (reader_table[slot].pcsc.card,
538                      list, &listlen,
539                      &card_state, &card_protocol,
540                      reader_table[slot].atr, &atrlen);
541   xfree (list);
542   if (err)
543     {
544       log_error ("pcsc_status failed: %s (0x%lx)\n",
545                   pcsc_error_string (err), err);
546       pcsc_release_context (reader_table[slot].pcsc.context);
547       reader_table[slot].used = 0;
548       return -1;
549     }
550   if (atrlen >= DIM (reader_table[0].atr))
551     log_bug ("ATR returned by pcsc_status is too large\n");
552   reader_table[slot].atrlen = atrlen;
553 /*   log_debug ("state    from pcsc_status: 0x%lx\n", card_state); */
554 /*   log_debug ("protocol from pcsc_status: 0x%lx\n", card_protocol); */
555
556   dump_reader_status (slot); 
557   return slot;
558 }
559
560
561 /* Actually send the APDU of length APDULEN to SLOT and return a
562    maximum of *BUFLEN data in BUFFER, the actual returned size will be
563    set to BUFLEN.  Returns: CT API error code. */
564 static int
565 pcsc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
566                 unsigned char *buffer, size_t *buflen)
567 {
568   long err;
569   struct pcsc_io_request_s send_pci;
570   unsigned long recv_len;
571   
572   if (DBG_CARD_IO)
573     log_printhex ("  PCSC_data:", apdu, apdulen);
574
575   if ((reader_table[slot].pcsc.protocol & PCSC_PROTOCOL_T1))
576       send_pci.protocol = PCSC_PROTOCOL_T1;
577   else
578       send_pci.protocol = PCSC_PROTOCOL_T0;
579   send_pci.pci_len = sizeof send_pci;
580   recv_len = *buflen;
581   err = pcsc_transmit (reader_table[slot].pcsc.card,
582                        &send_pci, apdu, apdulen,
583                        NULL, buffer, &recv_len);
584   *buflen = recv_len;
585   if (err)
586     log_error ("pcsc_transmit failed: %s (0x%lx)\n",
587                pcsc_error_string (err), err);
588   
589   return err? -1:0; /* FIXME: Return appropriate error code. */
590 }
591
592 static int
593 close_pcsc_reader (int slot)
594 {
595   /* FIXME: Implement. */
596   reader_table[slot].used = 0;
597   return 0;
598 }
599
600
601
602
603 \f
604 #ifdef HAVE_LIBUSB
605 /* 
606      Internal CCID driver interface.
607  */
608
609 static int
610 open_ccid_reader (void)
611 {
612   int err;
613   int slot;
614   reader_table_t slotp;
615
616   slot = new_reader_slot ();
617   if (slot == -1)
618     return -1;
619   slotp = reader_table + slot;
620
621   err = ccid_open_reader (&slotp->ccid.handle, 0);
622   if (err)
623     {
624       slotp->used = 0;
625       return -1;
626     }
627
628   err = ccid_get_atr (slotp->ccid.handle,
629                       slotp->atr, sizeof slotp->atr, &slotp->atrlen);
630   if (err)
631     {
632       slotp->used = 0;
633       return -1;
634     }
635
636   slotp->is_ccid = 1;
637
638   dump_reader_status (slot); 
639   return slot;
640 }
641
642 static int
643 close_ccid_reader (int slot)
644 {
645   ccid_close_reader (reader_table[slot].ccid.handle);
646   reader_table[slot].used = 0;
647   return 0;
648 }                       
649   
650
651
652 /* Actually send the APDU of length APDULEN to SLOT and return a
653    maximum of *BUFLEN data in BUFFER, the actual returned size will be
654    set to BUFLEN.  Returns: Internal CCID driver error code. */
655 static int
656 send_apdu_ccid (int slot, unsigned char *apdu, size_t apdulen,
657                 unsigned char *buffer, size_t *buflen)
658 {
659   long err;
660   size_t maxbuflen;
661
662   if (DBG_CARD_IO)
663     log_printhex ("  APDU_data:", apdu, apdulen);
664
665   maxbuflen = *buflen;
666   err = ccid_transceive (reader_table[slot].ccid.handle,
667                          apdu, apdulen,
668                          buffer, maxbuflen, buflen);
669   if (err)
670     log_error ("ccid_transceive failed: (0x%lx)\n",
671                err);
672   
673   return err? -1:0; /* FIXME: Return appropriate error code. */
674 }
675
676 #endif /* HAVE_LIBUSB */
677
678
679 \f
680 #ifdef HAVE_OPENSC
681 /* 
682      OpenSC Interface.
683
684      This uses the OpenSC primitives to send APDUs.  We need this
685      because we can't mix OpenSC and native (i.e. ctAPI or PC/SC)
686      access to a card for resource conflict reasons.
687  */
688
689 static int
690 open_osc_reader (int portno)
691 {
692   int err;
693   int slot;
694   reader_table_t slotp;
695
696   slot = new_reader_slot ();
697   if (slot == -1)
698     return -1;
699   slotp = reader_table + slot;
700
701   err = sc_establish_context (&slotp->osc.ctx, "scdaemon");
702   if (err)
703     {
704       log_error ("failed to establish SC context: %s\n", sc_strerror (err));
705       slotp->used = 0;
706       return -1;
707     }
708   if (portno < 0 || portno >= slotp->osc.ctx->reader_count)
709     {
710       log_error ("no card reader available\n");
711       sc_release_context (slotp->osc.ctx);
712       slotp->used = 0;
713       return -1;
714     }
715
716   /* Redirect to our logging facility. */
717   slotp->osc.ctx->error_file = log_get_stream ();
718   slotp->osc.ctx->debug = opt.debug_sc;
719   slotp->osc.ctx->debug_file = log_get_stream ();
720
721   if (sc_detect_card_presence (slotp->osc.ctx->reader[portno], 0) != 1)
722     {
723       log_error ("no card present\n");
724       sc_release_context (slotp->osc.ctx);
725       slotp->used = 0;
726       return -1;
727     }
728   
729   /* We want the standard ISO driver. */
730   /*FIXME: OpenSC does not like "iso7816", so we use EMV for now. */
731   err = sc_set_card_driver(slotp->osc.ctx, "emv");
732   if (err)
733     {
734       log_error ("failed to select the iso7816 driver: %s\n",
735                  sc_strerror (err));
736       sc_release_context (slotp->osc.ctx);
737       slotp->used = 0;
738       return -1;
739     }
740
741   /* Now connect the card and hope that OpenSC won't try to be too
742      smart. */
743   err = sc_connect_card (slotp->osc.ctx->reader[portno], 0,
744                          &slotp->osc.scard);
745   if (err)
746     {
747       log_error ("failed to connect card in reader %d: %s\n",
748                  portno, sc_strerror (err));
749       sc_release_context (slotp->osc.ctx);
750       slotp->used = 0;
751       return -1;
752     }
753   if (opt.verbose)
754     log_info ("connected to card in opensc reader %d using driver `%s'\n",
755               portno, slotp->osc.scard->driver->name);
756
757   err = sc_lock (slotp->osc.scard);
758   if (err)
759     {
760       log_error ("can't lock card in reader %d: %s\n",
761                  portno, sc_strerror (err));
762       sc_disconnect_card (slotp->osc.scard, 0);
763       sc_release_context (slotp->osc.ctx);
764       slotp->used = 0;
765       return -1;
766     }
767
768   if (slotp->osc.scard->atr_len >= DIM (slotp->atr))
769     log_bug ("ATR returned by opensc is too large\n");
770   slotp->atrlen = slotp->osc.scard->atr_len;
771   memcpy (slotp->atr, slotp->osc.scard->atr, slotp->atrlen);
772
773   slotp->is_osc = 1;
774
775   dump_reader_status (slot); 
776   return slot;
777 }
778
779
780 static int
781 close_osc_reader (int slot)
782 {
783   /* FIXME: Implement. */
784   reader_table[slot].used = 0;
785   return 0;
786 }
787
788
789
790 /* Actually send the APDU of length APDULEN to SLOT and return a
791    maximum of *BUFLEN data in BUFFER, the actual returned size will be
792    set to BUFLEN.  Returns: OpenSC error code. */
793 static int
794 osc_send_apdu (int slot, unsigned char *apdu, size_t apdulen,
795                 unsigned char *buffer, size_t *buflen)
796 {
797   long err;
798   struct sc_apdu a;
799   unsigned char data[SC_MAX_APDU_BUFFER_SIZE];
800   unsigned char result[SC_MAX_APDU_BUFFER_SIZE];
801
802   if (DBG_CARD_IO)
803     log_printhex ("  APDU_data:", apdu, apdulen);
804
805   if (apdulen < 4)
806     {
807       log_error ("osc_send_apdu: APDU is too short\n");
808       return SC_ERROR_CMD_TOO_SHORT;
809     }
810
811   memset(&a, 0, sizeof a);
812   a.cla = *apdu++;
813   a.ins = *apdu++;
814   a.p1 = *apdu++;
815   a.p2 = *apdu++;
816   apdulen -= 4;
817
818   if (!apdulen)
819     a.cse = SC_APDU_CASE_1;
820   else if (apdulen == 1) 
821     {
822       a.le = *apdu? *apdu : 256;
823       apdu++; apdulen--;
824       a.cse = SC_APDU_CASE_2_SHORT;
825     }
826   else
827     {
828       a.lc = *apdu++; apdulen--;
829       if (apdulen < a.lc)
830         {
831           log_error ("osc_send_apdu: APDU shorter than specified in Lc\n");
832           return SC_ERROR_CMD_TOO_SHORT;
833
834         }
835       memcpy(data, apdu, a.lc);
836       apdu += a.lc; apdulen -= a.lc;
837
838       a.data = data;
839       a.datalen = a.lc;
840       
841       if (!apdulen)
842         a.cse = SC_APDU_CASE_3_SHORT;
843       else
844         {
845           a.le = *apdu? *apdu : 256;
846           apdu++; apdulen--;
847           if (apdulen)
848             {
849               log_error ("osc_send_apdu: APDU larger than specified\n");
850               return SC_ERROR_CMD_TOO_LONG;
851             }
852           a.cse = SC_APDU_CASE_4_SHORT;
853         }
854     }
855
856   a.resp = result;
857   a.resplen = DIM(result);
858
859   err = sc_transmit_apdu (reader_table[slot].osc.scard, &a);
860   if (err)
861     {
862       log_error ("sc_apdu_transmit failed: %s\n", sc_strerror (err));
863       return err;
864     }
865
866   if (*buflen < 2 || a.resplen > *buflen - 2)
867     {
868       log_error ("osc_send_apdu: provided buffer too short to store result\n");
869       return SC_ERROR_BUFFER_TOO_SMALL;
870     }
871   memcpy (buffer, a.resp, a.resplen);
872   buffer[a.resplen] = a.sw1;
873   buffer[a.resplen+1] = a.sw2;
874   *buflen = a.resplen + 2;
875   return 0;
876 }
877
878 #endif /* HAVE_OPENSC */
879
880
881 \f
882 /* 
883        Driver Access
884  */
885
886 /* Open the reader and return an internal slot number or -1 on
887    error. If PORTSTR is NULL we default to a suitable port (for ctAPI:
888    the first USB reader.  For PC/SC the first listed reader).  If
889    OpenSC support is compiled in, we first try to use OpenSC. */
890 int
891 apdu_open_reader (const char *portstr)
892 {
893   static int pcsc_api_loaded, ct_api_loaded;
894
895 #ifdef HAVE_LIBUSB
896   if (!opt.disable_ccid)
897     {
898       int slot;
899
900       slot = open_ccid_reader ();
901       if (slot != -1)
902         return slot; /* got one */
903     }
904 #endif /* HAVE_LIBUSB */
905
906 #ifdef HAVE_OPENSC
907   if (!opt.disable_opensc)
908     {
909       int port = portstr? atoi (portstr) : 0;
910
911       return open_osc_reader (port);
912     }
913 #endif /* HAVE_OPENSC */  
914
915
916   if (opt.ctapi_driver && *opt.ctapi_driver)
917     {
918       int port = portstr? atoi (portstr) : 32768;
919
920       if (!ct_api_loaded)
921         {
922           void *handle;
923           
924           handle = dlopen (opt.ctapi_driver, RTLD_LAZY);
925           if (!handle)
926             {
927               log_error ("apdu_open_reader: failed to open driver: %s",
928                          dlerror ());
929               return -1;
930             }
931           CT_init = dlsym (handle, "CT_init");
932           CT_data = dlsym (handle, "CT_data");
933           CT_close = dlsym (handle, "CT_close");
934           if (!CT_init || !CT_data || !CT_close)
935             {
936               log_error ("apdu_open_reader: invalid ctAPI driver\n");
937               dlclose (handle);
938               return -1;
939             }
940           ct_api_loaded = 1;
941         }
942       return open_ct_reader (port);
943     }
944
945   
946   /* No ctAPI configured, so lets try the PC/SC API */
947   if (!pcsc_api_loaded)
948     {
949       void *handle;
950
951       handle = dlopen (opt.pcsc_driver, RTLD_LAZY);
952       if (!handle)
953         {
954           log_error ("apdu_open_reader: failed to open driver `%s': %s",
955                      opt.pcsc_driver, dlerror ());
956           return -1;
957         }
958
959       pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
960       pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
961       pcsc_list_readers      = dlsym (handle, "SCardListReaders");
962       pcsc_connect           = dlsym (handle, "SCardConnect");
963       pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
964       pcsc_status            = dlsym (handle, "SCardStatus");
965       pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
966       pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
967       pcsc_transmit          = dlsym (handle, "SCardTransmit");
968       pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
969
970       if (!pcsc_establish_context
971           || !pcsc_release_context  
972           || !pcsc_list_readers     
973           || !pcsc_connect          
974           || !pcsc_disconnect
975           || !pcsc_status
976           || !pcsc_begin_transaction
977           || !pcsc_end_transaction
978           || !pcsc_transmit         
979           || !pcsc_set_timeout)
980         {
981           log_error ("apdu_open_reader: invalid PC/SC driver\n");
982           dlclose (handle);
983           return -1;
984         }
985       pcsc_api_loaded = 1;
986     }
987   
988   return open_pcsc_reader (portstr);
989 }
990
991
992 int
993 apdu_close_reader (int slot)
994 {
995   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
996     return SW_HOST_NO_DRIVER;
997   if (reader_table[slot].is_ctapi)
998     return close_ct_reader (slot);
999 #ifdef HAVE_LIBUSB
1000   else if (reader_table[slot].is_ccid)
1001     return close_ccid_reader (slot);
1002 #endif
1003 #ifdef HAVE_OPENSC
1004   else if (reader_table[slot].is_osc)
1005     return close_osc_reader (slot);
1006 #endif
1007   else
1008     return close_pcsc_reader (slot);
1009 }
1010
1011
1012 unsigned char *
1013 apdu_get_atr (int slot, size_t *atrlen)
1014 {
1015   char *buf;
1016
1017   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1018     return NULL;
1019   
1020   buf = xtrymalloc (reader_table[slot].atrlen);
1021   if (!buf)
1022     return NULL;
1023   memcpy (buf, reader_table[slot].atr, reader_table[slot].atrlen);
1024   *atrlen = reader_table[slot].atrlen;
1025   return buf;
1026 }
1027   
1028     
1029 static const char *
1030 error_string (int slot, long rc)
1031 {
1032   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1033     return "[invalid slot]";
1034   if (reader_table[slot].is_ctapi)
1035     return ct_error_string (rc);
1036 #ifdef HAVE_LIBUSB
1037   else if (reader_table[slot].is_ccid)
1038     return "no CCID driver error strings yet";
1039 #endif
1040 #ifdef HAVE_OPENSC
1041   else if (reader_table[slot].is_osc)
1042     return sc_strerror (rc);
1043 #endif
1044   else
1045     return pcsc_error_string (rc);
1046 }
1047
1048
1049 /* Dispatcher for the actual send_apdu fucntion. */
1050 static int
1051 send_apdu (int slot, unsigned char *apdu, size_t apdulen,
1052            unsigned char *buffer, size_t *buflen)
1053 {
1054   if (slot < 0 || slot >= MAX_READER || !reader_table[slot].used )
1055     return SW_HOST_NO_DRIVER;
1056   if (reader_table[slot].is_ctapi)
1057     return ct_send_apdu (slot, apdu, apdulen, buffer, buflen);
1058 #ifdef HAVE_LIBUSB
1059   else if (reader_table[slot].is_ccid)
1060     return send_apdu_ccid (slot, apdu, apdulen, buffer, buflen);
1061 #endif
1062 #ifdef HAVE_OPENSC
1063   else if (reader_table[slot].is_osc)
1064     return osc_send_apdu (slot, apdu, apdulen, buffer, buflen);
1065 #endif
1066   else
1067     return pcsc_send_apdu (slot, apdu, apdulen, buffer, buflen);
1068 }
1069
1070 /* Send an APDU to the card in SLOT.  The APDU is created from all
1071    given parameters: CLASS, INS, P0, P1, LC, DATA, LE.  A value of -1
1072    for LC won't sent this field and the data field; in this case DATA
1073    must also be passed as NULL.  The return value is the status word
1074    or -1 for an invalid SLOT or other non card related error.  If
1075    RETBUF is not NULL, it will receive an allocated buffer with the
1076    returned data.  The length of that data will be put into
1077    *RETBUFLEN.  The caller is reponsible for releasing the buffer even
1078    in case of errors.  */
1079 int 
1080 apdu_send_le(int slot, int class, int ins, int p0, int p1,
1081              int lc, const char *data, int le,
1082              unsigned char **retbuf, size_t *retbuflen)
1083 {
1084   unsigned char result[256+10]; /* 10 extra in case of bugs in the driver. */
1085   size_t resultlen = 256;
1086   unsigned char apdu[5+256+1];
1087   size_t apdulen;
1088   int sw;
1089   long rc; /* we need a long here due to PC/SC. */
1090
1091   if (DBG_CARD_IO)
1092     log_debug ("send apdu: c=%02X i=%02X p0=%02X p1=%02X lc=%d le=%d\n",
1093                class, ins, p0, p1, lc, le);
1094
1095   if (lc != -1 && (lc > 255 || lc < 0))
1096     return SW_WRONG_LENGTH; 
1097   if (le != -1 && (le > 256 || le < 1))
1098     return SW_WRONG_LENGTH; 
1099   if ((!data && lc != -1) || (data && lc == -1))
1100     return SW_HOST_INV_VALUE;
1101
1102   apdulen = 0;
1103   apdu[apdulen++] = class;
1104   apdu[apdulen++] = ins;
1105   apdu[apdulen++] = p0;
1106   apdu[apdulen++] = p1;
1107   if (lc != -1)
1108     {
1109       apdu[apdulen++] = lc;
1110       memcpy (apdu+apdulen, data, lc);
1111       apdulen += lc;
1112     }
1113   if (le != -1)
1114     apdu[apdulen++] = le; /* Truncation is okay becuase 0 means 256. */
1115   assert (sizeof (apdu) >= apdulen);
1116   /* As safeguard don't pass any garbage from the stack to the driver. */
1117   memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
1118   rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
1119   if (rc || resultlen < 2)
1120     {
1121       log_error ("apdu_send_simple(%d) failed: %s\n",
1122                  slot, error_string (slot, rc));
1123       return SW_HOST_INCOMPLETE_CARD_RESPONSE;
1124     }
1125   sw = (result[resultlen-2] << 8) | result[resultlen-1];
1126   /* store away the returned data but strip the statusword. */
1127   resultlen -= 2;
1128   if (DBG_CARD_IO)
1129     {
1130       log_debug (" response: sw=%04X  datalen=%d\n", sw, resultlen);
1131       if ( !retbuf && (sw == SW_SUCCESS || (sw & 0xff00) == SW_MORE_DATA))
1132         log_printhex ("     dump: ", result, resultlen);
1133     }
1134
1135   if (sw == SW_SUCCESS)
1136     {
1137       if (retbuf)
1138         {
1139           *retbuf = xtrymalloc (resultlen? resultlen : 1);
1140           if (!*retbuf)
1141             return SW_HOST_OUT_OF_CORE;
1142           *retbuflen = resultlen;
1143           memcpy (*retbuf, result, resultlen);
1144         }
1145     }
1146   else if ((sw & 0xff00) == SW_MORE_DATA)
1147     {
1148       unsigned char *p = NULL, *tmp;
1149       size_t bufsize = 4096;
1150
1151       /* It is likely that we need to return much more data, so we
1152          start off with a large buffer. */
1153       if (retbuf)
1154         {
1155           *retbuf = p = xtrymalloc (bufsize);
1156           if (!*retbuf)
1157             return SW_HOST_OUT_OF_CORE;
1158           assert (resultlen < bufsize);
1159           memcpy (p, result, resultlen);
1160           p += resultlen;
1161         }
1162
1163       do
1164         {
1165           int len = (sw & 0x00ff);
1166           
1167           log_debug ("apdu_send_simple(%d): %d more bytes available\n",
1168                      slot, len);
1169           apdulen = 0;
1170           apdu[apdulen++] = class;
1171           apdu[apdulen++] = 0xC0;
1172           apdu[apdulen++] = 0;
1173           apdu[apdulen++] = 0;
1174           apdu[apdulen++] = 64; /* that is 256 bytes for Le */
1175           memset (apdu+apdulen, 0, sizeof (apdu) - apdulen);
1176           rc = send_apdu (slot, apdu, apdulen, result, &resultlen);
1177           if (rc || resultlen < 2)
1178             {
1179               log_error ("apdu_send_simple(%d) for get response failed: %s\n",
1180                          slot, error_string (slot, rc));
1181               return SW_HOST_INCOMPLETE_CARD_RESPONSE;
1182             }
1183           sw = (result[resultlen-2] << 8) | result[resultlen-1];
1184           resultlen -= 2;
1185           if (DBG_CARD_IO)
1186             {
1187               log_debug ("     more: sw=%04X  datalen=%d\n", sw, resultlen);
1188               if (!retbuf && (sw==SW_SUCCESS || (sw&0xff00)==SW_MORE_DATA))
1189                 log_printhex ("     dump: ", result, resultlen);
1190             }
1191
1192           if ((sw & 0xff00) == SW_MORE_DATA || sw == SW_SUCCESS)
1193             {
1194               if (retbuf)
1195                 {
1196                   if (p - *retbuf + resultlen > bufsize)
1197                     {
1198                       bufsize += resultlen > 4096? resultlen: 4096;
1199                       tmp = xtryrealloc (*retbuf, bufsize);
1200                       if (!tmp)
1201                         return SW_HOST_OUT_OF_CORE;
1202                       p = tmp + (p - *retbuf);
1203                       *retbuf = tmp;
1204                     }
1205                   memcpy (p, result, resultlen);
1206                   p += resultlen;
1207                 }
1208             }
1209           else
1210             log_info ("apdu_send_simple(%d) "
1211                       "got unexpected status %04X from get response\n",
1212                       slot, sw);
1213         }
1214       while ((sw & 0xff00) == SW_MORE_DATA);
1215       
1216       if (retbuf)
1217         {
1218           *retbuflen = p - *retbuf;
1219           tmp = xtryrealloc (*retbuf, *retbuflen);
1220           if (tmp)
1221             *retbuf = tmp;
1222         }
1223     }
1224   if (DBG_CARD_IO && retbuf && sw == SW_SUCCESS)
1225     log_printhex ("      dump: ", *retbuf, *retbuflen);
1226  
1227   return sw;
1228 }
1229
1230 /* Send an APDU to the card in SLOT.  The APDU is created from all
1231    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
1232    LC won't sent this field and the data field; in this case DATA must
1233    also be passed as NULL. The return value is the status word or -1
1234    for an invalid SLOT or other non card related error.  If RETBUF is
1235    not NULL, it will receive an allocated buffer with the returned
1236    data.  The length of that data will be put into *RETBUFLEN.  The
1237    caller is reponsible for releasing the buffer even in case of
1238    errors.  */
1239 int 
1240 apdu_send (int slot, int class, int ins, int p0, int p1,
1241            int lc, const char *data, unsigned char **retbuf, size_t *retbuflen)
1242 {
1243   return apdu_send_le (slot, class, ins, p0, p1, lc, data, 256, 
1244                        retbuf, retbuflen);
1245 }
1246
1247 /* Send an APDU to the card in SLOT.  The APDU is created from all
1248    given parameters: CLASS, INS, P0, P1, LC, DATA.  A value of -1 for
1249    LC won't sent this field and the data field; in this case DATA must
1250    also be passed as NULL. The return value is the status word or -1
1251    for an invalid SLOT or other non card related error.  No data will be
1252    returned. */
1253 int 
1254 apdu_send_simple (int slot, int class, int ins, int p0, int p1,
1255                   int lc, const char *data)
1256 {
1257   return apdu_send_le (slot, class, ins, p0, p1, lc, data, -1, NULL, NULL);
1258 }
1259
1260
1261
1262