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