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