800c954b4f818ffbdc7576a8b829bf9367d116af
[gnupg.git] / scd / app.c
1 /* app.c - Application selection.
2  * Copyright (C) 2003, 2004, 2005 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 3 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, see <https://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <errno.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <npth.h>
26
27 #include "scdaemon.h"
28 #include "../common/exechelp.h"
29 #include "app-common.h"
30 #include "iso7816.h"
31 #include "apdu.h"
32 #include "../common/tlv.h"
33
34 static npth_mutex_t app_list_lock;
35 static app_t app_top;
36 \f
37 static void
38 print_progress_line (void *opaque, const char *what, int pc, int cur, int tot)
39 {
40   ctrl_t ctrl = opaque;
41   char line[100];
42
43   if (ctrl)
44     {
45       snprintf (line, sizeof line, "%s %c %d %d", what, pc, cur, tot);
46       send_status_direct (ctrl, "PROGRESS", line);
47     }
48 }
49
50
51 /* Lock the reader SLOT.  This function shall be used right before
52    calling any of the actual application functions to serialize access
53    to the reader.  We do this always even if the reader is not
54    actually used.  This allows an actual connection to assume that it
55    never shares a reader (while performing one command).  Returns 0 on
56    success; only then the unlock_reader function must be called after
57    returning from the handler. */
58 static gpg_error_t
59 lock_app (app_t app, ctrl_t ctrl)
60 {
61   if (npth_mutex_lock (&app->lock))
62     {
63       gpg_error_t err = gpg_error_from_syserror ();
64       log_error ("failed to acquire APP lock for %p: %s\n",
65                  app, gpg_strerror (err));
66       return err;
67     }
68
69   apdu_set_progress_cb (app->slot, print_progress_line, ctrl);
70   apdu_set_prompt_cb (app->slot, popup_prompt, ctrl);
71
72   return 0;
73 }
74
75 /* Release a lock on the reader.  See lock_reader(). */
76 static void
77 unlock_app (app_t app)
78 {
79   apdu_set_progress_cb (app->slot, NULL, NULL);
80   apdu_set_prompt_cb (app->slot, NULL, NULL);
81
82   if (npth_mutex_unlock (&app->lock))
83     {
84       gpg_error_t err = gpg_error_from_syserror ();
85       log_error ("failed to release APP lock for %p: %s\n",
86                  app, gpg_strerror (err));
87     }
88 }
89
90
91 /* This function may be called to print information pertaining to the
92    current state of this module to the log. */
93 void
94 app_dump_state (void)
95 {
96   app_t a;
97
98   npth_mutex_lock (&app_list_lock);
99   for (a = app_top; a; a = a->next)
100     log_info ("app_dump_state: app=%p type='%s'\n", a, a->apptype);
101   npth_mutex_unlock (&app_list_lock);
102 }
103
104 /* Check whether the application NAME is allowed.  This does not mean
105    we have support for it though.  */
106 static int
107 is_app_allowed (const char *name)
108 {
109   strlist_t l;
110
111   for (l=opt.disabled_applications; l; l = l->next)
112     if (!strcmp (l->d, name))
113       return 0; /* no */
114   return 1; /* yes */
115 }
116
117
118 static gpg_error_t
119 check_conflict (app_t app, const char *name)
120 {
121   if (!app || !name || (app->apptype && !ascii_strcasecmp (app->apptype, name)))
122     return 0;
123
124   log_info ("application '%s' in use - can't switch\n",
125             app->apptype? app->apptype : "<null>");
126
127   return gpg_error (GPG_ERR_CONFLICT);
128 }
129
130 /* This function is used by the serialno command to check for an
131    application conflict which may appear if the serialno command is
132    used to request a specific application and the connection has
133    already done a select_application. */
134 gpg_error_t
135 check_application_conflict (const char *name, app_t app)
136 {
137   return check_conflict (app, name);
138 }
139
140
141 gpg_error_t
142 app_reset (app_t app, ctrl_t ctrl, int send_reset)
143 {
144   gpg_error_t err = 0;
145
146   if (send_reset)
147     {
148       int sw;
149
150       lock_app (app, ctrl);
151       sw = apdu_reset (app->slot);
152       if (sw)
153         err = gpg_error (GPG_ERR_CARD_RESET);
154
155       app->reset_requested = 1;
156       unlock_app (app);
157
158       scd_kick_the_loop ();
159       gnupg_sleep (1);
160     }
161   else
162     {
163       ctrl->app_ctx = NULL;
164       release_application (app, 0);
165     }
166
167   return err;
168 }
169
170 static gpg_error_t
171 app_new_register (int slot, ctrl_t ctrl, const char *name,
172                   int periodical_check_needed)
173 {
174   gpg_error_t err = 0;
175   app_t app = NULL;
176   unsigned char *result = NULL;
177   size_t resultlen;
178   int want_undefined;
179
180   /* Need to allocate a new one.  */
181   app = xtrycalloc (1, sizeof *app);
182   if (!app)
183     {
184       err = gpg_error_from_syserror ();
185       log_info ("error allocating context: %s\n", gpg_strerror (err));
186       return err;
187     }
188
189   app->slot = slot;
190   app->card_status = (unsigned int)-1;
191
192   if (npth_mutex_init (&app->lock, NULL))
193     {
194       err = gpg_error_from_syserror ();
195       log_error ("error initializing mutex: %s\n", gpg_strerror (err));
196       xfree (app);
197       return err;
198     }
199
200   err = lock_app (app, ctrl);
201   if (err)
202     {
203       xfree (app);
204       return err;
205     }
206
207   want_undefined = (name && !strcmp (name, "undefined"));
208
209   /* Try to read the GDO file first to get a default serial number.
210      We skip this if the undefined application has been requested. */
211   if (!want_undefined)
212     {
213       err = iso7816_select_file (slot, 0x3F00, 1);
214       if (gpg_err_code (err) == GPG_ERR_CARD)
215         {
216           /* Might be SW==0x7D00.  Let's test whether it is a Yubikey
217            * by selecting its manager application and then reading the
218            * config.  */
219           static char const yk_aid[] =
220             { 0xA0, 0x00, 0x00, 0x05, 0x27, 0x47, 0x11, 0x17 }; /*MGR*/
221           unsigned char *buf;
222           size_t buflen;
223           const unsigned char *s0, *s1;
224           size_t n;
225
226           if (!iso7816_select_application (slot, yk_aid, sizeof yk_aid,
227                                            0x0001)
228               && !iso7816_apdu_direct (slot, "\x00\x1d\x00\x00\x00", 5, 0,
229                                        NULL, &buf, &buflen))
230             {
231               if (opt.verbose)
232                 {
233                   log_info ("Yubico: config=");
234                   log_printhex (buf, buflen, "");
235                 }
236
237               /* We skip the first byte which seems to be the total
238                * length of the config data.  */
239               if (buflen > 1)
240                 {
241                   s0 = find_tlv (buf+1, buflen-1, 0x04, &n);  /* Form factor */
242                   if (s0 && n == 1)
243                     {
244                       s1 = find_tlv (buf+1, buflen-1, 0x02, &n);  /* Serial */
245                       if (s1 && n >= 4)
246                         {
247                           app->serialno = xtrymalloc (3 + 1 + n);
248                           if (app->serialno)
249                             {
250                               app->serialnolen = 3 + 1 + n;
251                               app->serialno[0] = 0xff;
252                               app->serialno[1] = 0x02;
253                               app->serialno[2] = 0x0;
254                               app->serialno[3] = *s0;
255                               memcpy (app->serialno + 4, s1, n);
256                               /* Note that we do not clear the error
257                                * so that no further serial number
258                                * testing is done.  After all we just
259                                * set the serial number.  */
260                             }
261                         }
262                     }
263                 }
264               xfree (buf);
265             }
266         }
267
268       if (!err)
269         err = iso7816_select_file (slot, 0x2F02, 0);
270       if (!err)
271         err = iso7816_read_binary (slot, 0, 0, &result, &resultlen);
272       if (!err)
273         {
274           size_t n;
275           const unsigned char *p;
276
277           p = find_tlv_unchecked (result, resultlen, 0x5A, &n);
278           if (p)
279             resultlen -= (p-result);
280           if (p && n > resultlen && n == 0x0d && resultlen+1 == n)
281             {
282               /* The object it does not fit into the buffer.  This is an
283                  invalid encoding (or the buffer is too short.  However, I
284                  have some test cards with such an invalid encoding and
285                  therefore I use this ugly workaround to return something
286                  I can further experiment with. */
287               log_info ("enabling BMI testcard workaround\n");
288               n--;
289             }
290
291           if (p && n <= resultlen)
292             {
293               /* The GDO file is pretty short, thus we simply reuse it for
294                  storing the serial number. */
295               memmove (result, p, n);
296               app->serialno = result;
297               app->serialnolen = n;
298               err = app_munge_serialno (app);
299               if (err)
300                 goto leave;
301             }
302           else
303             xfree (result);
304           result = NULL;
305         }
306     }
307
308   /* For certain error codes, there is no need to try more.  */
309   if (gpg_err_code (err) == GPG_ERR_CARD_NOT_PRESENT
310       || gpg_err_code (err) == GPG_ERR_ENODEV)
311     goto leave;
312
313   /* Figure out the application to use.  */
314   if (want_undefined)
315     {
316       /* We switch to the "undefined" application only if explicitly
317          requested.  */
318       app->apptype = "UNDEFINED";
319       err = 0;
320     }
321   else
322     err = gpg_error (GPG_ERR_NOT_FOUND);
323
324   if (err && is_app_allowed ("openpgp")
325           && (!name || !strcmp (name, "openpgp")))
326     err = app_select_openpgp (app);
327   if (err && is_app_allowed ("piv") && (!name || !strcmp (name, "piv")))
328     err = app_select_piv (app);
329   if (err && is_app_allowed ("nks") && (!name || !strcmp (name, "nks")))
330     err = app_select_nks (app);
331   if (err && is_app_allowed ("p15") && (!name || !strcmp (name, "p15")))
332     err = app_select_p15 (app);
333   if (err && is_app_allowed ("geldkarte")
334       && (!name || !strcmp (name, "geldkarte")))
335     err = app_select_geldkarte (app);
336   if (err && is_app_allowed ("dinsig") && (!name || !strcmp (name, "dinsig")))
337     err = app_select_dinsig (app);
338   if (err && is_app_allowed ("sc-hsm") && (!name || !strcmp (name, "sc-hsm")))
339     err = app_select_sc_hsm (app);
340   if (err && name && gpg_err_code (err) != GPG_ERR_OBJ_TERM_STATE)
341     err = gpg_error (GPG_ERR_NOT_SUPPORTED);
342
343  leave:
344   if (err)
345     {
346       if (name)
347         log_info ("can't select application '%s': %s\n",
348                   name, gpg_strerror (err));
349       else
350         log_info ("no supported card application found: %s\n",
351                   gpg_strerror (err));
352       unlock_app (app);
353       xfree (app);
354       return err;
355     }
356
357   app->periodical_check_needed = periodical_check_needed;
358   app->next = app_top;
359   app_top = app;
360   unlock_app (app);
361   return 0;
362 }
363
364 /* If called with NAME as NULL, select the best fitting application
365    and return a context; otherwise select the application with NAME
366    and return a context.  Returns an error code and stores NULL at
367    R_APP if no application was found or no card is present. */
368 gpg_error_t
369 select_application (ctrl_t ctrl, const char *name, app_t *r_app,
370                     int scan, const unsigned char *serialno_bin,
371                     size_t serialno_bin_len)
372 {
373   gpg_error_t err = 0;
374   app_t a, a_prev = NULL;
375
376   *r_app = NULL;
377
378   npth_mutex_lock (&app_list_lock);
379
380   if (scan || !app_top)
381     {
382       struct dev_list *l;
383       int new_app = 0;
384
385       /* Scan the devices to find new device(s).  */
386       err = apdu_dev_list_start (opt.reader_port, &l);
387       if (err)
388         {
389           npth_mutex_unlock (&app_list_lock);
390           return err;
391         }
392
393       while (1)
394         {
395           int slot;
396           int periodical_check_needed_this;
397
398           slot = apdu_open_reader (l, !app_top);
399           if (slot < 0)
400             break;
401
402           periodical_check_needed_this = apdu_connect (slot);
403           if (periodical_check_needed_this < 0)
404             {
405               /* We close a reader with no card.  */
406               err = gpg_error (GPG_ERR_ENODEV);
407             }
408           else
409             {
410               err = app_new_register (slot, ctrl, name,
411                                       periodical_check_needed_this);
412               new_app++;
413             }
414
415           if (err)
416             apdu_close_reader (slot);
417         }
418
419       apdu_dev_list_finish (l);
420
421       /* If new device(s), kick the scdaemon loop.  */
422       if (new_app)
423         scd_kick_the_loop ();
424     }
425
426   for (a = app_top; a; a = a->next)
427     {
428       lock_app (a, ctrl);
429       if (serialno_bin == NULL)
430         break;
431       if (a->serialnolen == serialno_bin_len
432           && !memcmp (a->serialno, serialno_bin, a->serialnolen))
433         break;
434       unlock_app (a);
435       a_prev = a;
436     }
437
438   if (a)
439     {
440       err = check_conflict (a, name);
441       if (!err)
442         {
443           a->ref_count++;
444           *r_app = a;
445           if (a_prev)
446             {
447               a_prev->next = a->next;
448               a->next = app_top;
449               app_top = a;
450             }
451       }
452       unlock_app (a);
453     }
454   else
455     err = gpg_error (GPG_ERR_ENODEV);
456
457   npth_mutex_unlock (&app_list_lock);
458
459   return err;
460 }
461
462
463 char *
464 get_supported_applications (void)
465 {
466   const char *list[] = {
467     "openpgp",
468     "piv",
469     "nks",
470     "p15",
471     "geldkarte",
472     "dinsig",
473     "sc-hsm",
474     /* Note: "undefined" is not listed here because it needs special
475        treatment by the client.  */
476     NULL
477   };
478   int idx;
479   size_t nbytes;
480   char *buffer, *p;
481
482   for (nbytes=1, idx=0; list[idx]; idx++)
483     nbytes += strlen (list[idx]) + 1 + 1;
484
485   buffer = xtrymalloc (nbytes);
486   if (!buffer)
487     return NULL;
488
489   for (p=buffer, idx=0; list[idx]; idx++)
490     if (is_app_allowed (list[idx]))
491       p = stpcpy (stpcpy (p, list[idx]), ":\n");
492   *p = 0;
493
494   return buffer;
495 }
496
497
498 /* Deallocate the application.  */
499 static void
500 deallocate_app (app_t app)
501 {
502   app_t a, a_prev = NULL;
503
504   for (a = app_top; a; a = a->next)
505     if (a == app)
506       {
507         if (a_prev == NULL)
508           app_top = a->next;
509         else
510           a_prev->next = a->next;
511         break;
512       }
513     else
514       a_prev = a;
515
516   if (app->ref_count)
517     log_error ("trying to release context used yet (%d)\n", app->ref_count);
518
519   if (app->fnc.deinit)
520     {
521       app->fnc.deinit (app);
522       app->fnc.deinit = NULL;
523     }
524
525   xfree (app->serialno);
526
527   unlock_app (app);
528   xfree (app);
529 }
530
531 /* Free the resources associated with the application APP.  APP is
532    allowed to be NULL in which case this is a no-op.  Note that we are
533    using reference counting to track the users of the application and
534    actually deferring the deallocation to allow for a later reuse by
535    a new connection. */
536 void
537 release_application (app_t app, int locked_already)
538 {
539   if (!app)
540     return;
541
542   /* We don't deallocate app here.  Instead, we keep it.  This is
543      useful so that a card does not get reset even if only one session
544      is using the card - this way the PIN cache and other cached data
545      are preserved.  */
546
547   if (!locked_already)
548     lock_app (app, NULL);
549
550   if (!app->ref_count)
551     log_bug ("trying to release an already released context\n");
552
553   --app->ref_count;
554   if (!locked_already)
555     unlock_app (app);
556 }
557
558
559
560 /* The serial number may need some cosmetics.  Do it here.  This
561    function shall only be called once after a new serial number has
562    been put into APP->serialno.
563
564    Prefixes we use:
565
566      FF 00 00 = For serial numbers starting with an FF
567      FF 01 00 = Some german p15 cards return an empty serial number so the
568                 serial number from the EF(TokenInfo) is used instead.
569      FF 02 00 = Serial number from Yubikey config
570      FF 7F 00 = No serialno.
571
572      All other serial number not starting with FF are used as they are.
573 */
574 gpg_error_t
575 app_munge_serialno (app_t app)
576 {
577   if (app->serialnolen && app->serialno[0] == 0xff)
578     {
579       /* The serial number starts with our special prefix.  This
580          requires that we put our default prefix "FF0000" in front. */
581       unsigned char *p = xtrymalloc (app->serialnolen + 3);
582       if (!p)
583         return gpg_error_from_syserror ();
584       memcpy (p, "\xff\0", 3);
585       memcpy (p+3, app->serialno, app->serialnolen);
586       app->serialnolen += 3;
587       xfree (app->serialno);
588       app->serialno = p;
589     }
590   else if (!app->serialnolen)
591     {
592       unsigned char *p = xtrymalloc (3);
593       if (!p)
594         return gpg_error_from_syserror ();
595       memcpy (p, "\xff\x7f", 3);
596       app->serialnolen = 3;
597       xfree (app->serialno);
598       app->serialno = p;
599     }
600   return 0;
601 }
602
603
604
605 /* Retrieve the serial number of the card.  The serial number is
606    returned as a malloced string (hex encoded) in SERIAL.  Caller must
607    free SERIAL unless the function returns an error.  */
608 char *
609 app_get_serialno (app_t app)
610 {
611   char *serial;
612
613   if (!app)
614     return NULL;
615
616   if (!app->serialnolen)
617     serial = xtrystrdup ("FF7F00");
618   else
619     serial = bin2hex (app->serialno, app->serialnolen, NULL);
620
621   return serial;
622 }
623
624
625 /* Write out the application specifig status lines for the LEARN
626    command. */
627 gpg_error_t
628 app_write_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
629 {
630   gpg_error_t err;
631
632   if (!app)
633     return gpg_error (GPG_ERR_INV_VALUE);
634   if (!app->fnc.learn_status)
635     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
636
637   /* We do not send APPTYPE if only keypairinfo is requested.  */
638   if (app->apptype && !(flags & 1))
639     send_status_direct (ctrl, "APPTYPE", app->apptype);
640   err = lock_app (app, ctrl);
641   if (err)
642     return err;
643   err = app->fnc.learn_status (app, ctrl, flags);
644   unlock_app (app);
645   return err;
646 }
647
648
649 /* Read the certificate with id CERTID (as returned by learn_status in
650    the CERTINFO status lines) and return it in the freshly allocated
651    buffer put into CERT and the length of the certificate put into
652    CERTLEN. */
653 gpg_error_t
654 app_readcert (app_t app, ctrl_t ctrl, const char *certid,
655               unsigned char **cert, size_t *certlen)
656 {
657   gpg_error_t err;
658
659   if (!app)
660     return gpg_error (GPG_ERR_INV_VALUE);
661   if (!app->ref_count)
662     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
663   if (!app->fnc.readcert)
664     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
665   err = lock_app (app, ctrl);
666   if (err)
667     return err;
668   err = app->fnc.readcert (app, certid, cert, certlen);
669   unlock_app (app);
670   return err;
671 }
672
673
674 /* Read the key with ID KEYID.  On success a canonical encoded
675    S-expression with the public key will get stored at PK and its
676    length (for assertions) at PKLEN; the caller must release that
677    buffer. On error NULL will be stored at PK and PKLEN and an error
678    code returned.
679
680    This function might not be supported by all applications.  */
681 gpg_error_t
682 app_readkey (app_t app, ctrl_t ctrl, int advanced, const char *keyid,
683              unsigned char **pk, size_t *pklen)
684 {
685   gpg_error_t err;
686
687   if (pk)
688     *pk = NULL;
689   if (pklen)
690     *pklen = 0;
691
692   if (!app || !keyid || !pk || !pklen)
693     return gpg_error (GPG_ERR_INV_VALUE);
694   if (!app->ref_count)
695     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
696   if (!app->fnc.readkey)
697     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
698   err = lock_app (app, ctrl);
699   if (err)
700     return err;
701   err= app->fnc.readkey (app, advanced, keyid, pk, pklen);
702   unlock_app (app);
703   return err;
704 }
705
706
707 /* Perform a GETATTR operation.  */
708 gpg_error_t
709 app_getattr (app_t app, ctrl_t ctrl, const char *name)
710 {
711   gpg_error_t err;
712
713   if (!app || !name || !*name)
714     return gpg_error (GPG_ERR_INV_VALUE);
715   if (!app->ref_count)
716     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
717
718   if (app->apptype && name && !strcmp (name, "APPTYPE"))
719     {
720       send_status_direct (ctrl, "APPTYPE", app->apptype);
721       return 0;
722     }
723   if (name && !strcmp (name, "SERIALNO"))
724     {
725       char *serial;
726
727       serial = app_get_serialno (app);
728       if (!serial)
729         return gpg_error (GPG_ERR_INV_VALUE);
730
731       send_status_direct (ctrl, "SERIALNO", serial);
732       xfree (serial);
733       return 0;
734     }
735
736   if (!app->fnc.getattr)
737     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
738   err = lock_app (app, ctrl);
739   if (err)
740     return err;
741   err =  app->fnc.getattr (app, ctrl, name);
742   unlock_app (app);
743   return err;
744 }
745
746 /* Perform a SETATTR operation.  */
747 gpg_error_t
748 app_setattr (app_t app, ctrl_t ctrl, const char *name,
749              gpg_error_t (*pincb)(void*, const char *, char **),
750              void *pincb_arg,
751              const unsigned char *value, size_t valuelen)
752 {
753   gpg_error_t err;
754
755   if (!app || !name || !*name || !value)
756     return gpg_error (GPG_ERR_INV_VALUE);
757   if (!app->ref_count)
758     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
759   if (!app->fnc.setattr)
760     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
761   err = lock_app (app, ctrl);
762   if (err)
763     return err;
764   err = app->fnc.setattr (app, name, pincb, pincb_arg, value, valuelen);
765   unlock_app (app);
766   return err;
767 }
768
769 /* Create the signature and return the allocated result in OUTDATA.
770    If a PIN is required the PINCB will be used to ask for the PIN; it
771    should return the PIN in an allocated buffer and put it into PIN.  */
772 gpg_error_t
773 app_sign (app_t app, ctrl_t ctrl, const char *keyidstr, int hashalgo,
774           gpg_error_t (*pincb)(void*, const char *, char **),
775           void *pincb_arg,
776           const void *indata, size_t indatalen,
777           unsigned char **outdata, size_t *outdatalen )
778 {
779   gpg_error_t err;
780
781   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
782     return gpg_error (GPG_ERR_INV_VALUE);
783   if (!app->ref_count)
784     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
785   if (!app->fnc.sign)
786     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
787   err = lock_app (app, ctrl);
788   if (err)
789     return err;
790   err = app->fnc.sign (app, keyidstr, hashalgo,
791                        pincb, pincb_arg,
792                        indata, indatalen,
793                        outdata, outdatalen);
794   unlock_app (app);
795   if (opt.verbose)
796     log_info ("operation sign result: %s\n", gpg_strerror (err));
797   return err;
798 }
799
800 /* Create the signature using the INTERNAL AUTHENTICATE command and
801    return the allocated result in OUTDATA.  If a PIN is required the
802    PINCB will be used to ask for the PIN; it should return the PIN in
803    an allocated buffer and put it into PIN.  */
804 gpg_error_t
805 app_auth (app_t app, ctrl_t ctrl, const char *keyidstr,
806           gpg_error_t (*pincb)(void*, const char *, char **),
807           void *pincb_arg,
808           const void *indata, size_t indatalen,
809           unsigned char **outdata, size_t *outdatalen )
810 {
811   gpg_error_t err;
812
813   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
814     return gpg_error (GPG_ERR_INV_VALUE);
815   if (!app->ref_count)
816     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
817   if (!app->fnc.auth)
818     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
819   err = lock_app (app, ctrl);
820   if (err)
821     return err;
822   err = app->fnc.auth (app, keyidstr,
823                        pincb, pincb_arg,
824                        indata, indatalen,
825                        outdata, outdatalen);
826   unlock_app (app);
827   if (opt.verbose)
828     log_info ("operation auth result: %s\n", gpg_strerror (err));
829   return err;
830 }
831
832
833 /* Decrypt the data in INDATA and return the allocated result in OUTDATA.
834    If a PIN is required the PINCB will be used to ask for the PIN; it
835    should return the PIN in an allocated buffer and put it into PIN.  */
836 gpg_error_t
837 app_decipher (app_t app, ctrl_t ctrl, const char *keyidstr,
838               gpg_error_t (*pincb)(void*, const char *, char **),
839               void *pincb_arg,
840               const void *indata, size_t indatalen,
841               unsigned char **outdata, size_t *outdatalen,
842               unsigned int *r_info)
843 {
844   gpg_error_t err;
845
846   *r_info = 0;
847
848   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
849     return gpg_error (GPG_ERR_INV_VALUE);
850   if (!app->ref_count)
851     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
852   if (!app->fnc.decipher)
853     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
854   err = lock_app (app, ctrl);
855   if (err)
856     return err;
857   err = app->fnc.decipher (app, keyidstr,
858                            pincb, pincb_arg,
859                            indata, indatalen,
860                            outdata, outdatalen,
861                            r_info);
862   unlock_app (app);
863   if (opt.verbose)
864     log_info ("operation decipher result: %s\n", gpg_strerror (err));
865   return err;
866 }
867
868
869 /* Perform the WRITECERT operation.  */
870 gpg_error_t
871 app_writecert (app_t app, ctrl_t ctrl,
872               const char *certidstr,
873               gpg_error_t (*pincb)(void*, const char *, char **),
874               void *pincb_arg,
875               const unsigned char *data, size_t datalen)
876 {
877   gpg_error_t err;
878
879   if (!app || !certidstr || !*certidstr || !pincb)
880     return gpg_error (GPG_ERR_INV_VALUE);
881   if (!app->ref_count)
882     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
883   if (!app->fnc.writecert)
884     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
885   err = lock_app (app, ctrl);
886   if (err)
887     return err;
888   err = app->fnc.writecert (app, ctrl, certidstr,
889                             pincb, pincb_arg, data, datalen);
890   unlock_app (app);
891   if (opt.verbose)
892     log_info ("operation writecert result: %s\n", gpg_strerror (err));
893   return err;
894 }
895
896
897 /* Perform the WRITEKEY operation.  */
898 gpg_error_t
899 app_writekey (app_t app, ctrl_t ctrl,
900               const char *keyidstr, unsigned int flags,
901               gpg_error_t (*pincb)(void*, const char *, char **),
902               void *pincb_arg,
903               const unsigned char *keydata, size_t keydatalen)
904 {
905   gpg_error_t err;
906
907   if (!app || !keyidstr || !*keyidstr || !pincb)
908     return gpg_error (GPG_ERR_INV_VALUE);
909   if (!app->ref_count)
910     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
911   if (!app->fnc.writekey)
912     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
913   err = lock_app (app, ctrl);
914   if (err)
915     return err;
916   err = app->fnc.writekey (app, ctrl, keyidstr, flags,
917                            pincb, pincb_arg, keydata, keydatalen);
918   unlock_app (app);
919   if (opt.verbose)
920     log_info ("operation writekey result: %s\n", gpg_strerror (err));
921   return err;
922 }
923
924
925 /* Perform a SETATTR operation.  */
926 gpg_error_t
927 app_genkey (app_t app, ctrl_t ctrl, const char *keynostr, unsigned int flags,
928             time_t createtime,
929             gpg_error_t (*pincb)(void*, const char *, char **),
930             void *pincb_arg)
931 {
932   gpg_error_t err;
933
934   if (!app || !keynostr || !*keynostr || !pincb)
935     return gpg_error (GPG_ERR_INV_VALUE);
936   if (!app->ref_count)
937     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
938   if (!app->fnc.genkey)
939     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
940   err = lock_app (app, ctrl);
941   if (err)
942     return err;
943   err = app->fnc.genkey (app, ctrl, keynostr, flags,
944                          createtime, pincb, pincb_arg);
945   unlock_app (app);
946   if (opt.verbose)
947     log_info ("operation genkey result: %s\n", gpg_strerror (err));
948   return err;
949 }
950
951
952 /* Perform a GET CHALLENGE operation.  This function is special as it
953    directly accesses the card without any application specific
954    wrapper. */
955 gpg_error_t
956 app_get_challenge (app_t app, ctrl_t ctrl, size_t nbytes, unsigned char *buffer)
957 {
958   gpg_error_t err;
959
960   if (!app || !nbytes || !buffer)
961     return gpg_error (GPG_ERR_INV_VALUE);
962   if (!app->ref_count)
963     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
964   err = lock_app (app, ctrl);
965   if (err)
966     return err;
967   err = iso7816_get_challenge (app->slot, nbytes, buffer);
968   unlock_app (app);
969   return err;
970 }
971
972
973
974 /* Perform a CHANGE REFERENCE DATA or RESET RETRY COUNTER operation.  */
975 gpg_error_t
976 app_change_pin (app_t app, ctrl_t ctrl, const char *chvnostr, int reset_mode,
977                 gpg_error_t (*pincb)(void*, const char *, char **),
978                 void *pincb_arg)
979 {
980   gpg_error_t err;
981
982   if (!app || !chvnostr || !*chvnostr || !pincb)
983     return gpg_error (GPG_ERR_INV_VALUE);
984   if (!app->ref_count)
985     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
986   if (!app->fnc.change_pin)
987     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
988   err = lock_app (app, ctrl);
989   if (err)
990     return err;
991   err = app->fnc.change_pin (app, ctrl, chvnostr, reset_mode,
992                              pincb, pincb_arg);
993   unlock_app (app);
994   if (opt.verbose)
995     log_info ("operation change_pin result: %s\n", gpg_strerror (err));
996   return err;
997 }
998
999
1000 /* Perform a VERIFY operation without doing anything lese.  This may
1001    be used to initialize a the PIN cache for long lasting other
1002    operations.  Its use is highly application dependent. */
1003 gpg_error_t
1004 app_check_pin (app_t app, ctrl_t ctrl, const char *keyidstr,
1005                gpg_error_t (*pincb)(void*, const char *, char **),
1006                void *pincb_arg)
1007 {
1008   gpg_error_t err;
1009
1010   if (!app || !keyidstr || !*keyidstr || !pincb)
1011     return gpg_error (GPG_ERR_INV_VALUE);
1012   if (!app->ref_count)
1013     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
1014   if (!app->fnc.check_pin)
1015     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
1016   err = lock_app (app, ctrl);
1017   if (err)
1018     return err;
1019   err = app->fnc.check_pin (app, keyidstr, pincb, pincb_arg);
1020   unlock_app (app);
1021   if (opt.verbose)
1022     log_info ("operation check_pin result: %s\n", gpg_strerror (err));
1023   return err;
1024 }
1025
1026 static void
1027 report_change (int slot, int old_status, int cur_status)
1028 {
1029   char *homestr, *envstr;
1030   char *fname;
1031   char templ[50];
1032   FILE *fp;
1033
1034   snprintf (templ, sizeof templ, "reader_%d.status", slot);
1035   fname = make_filename (gnupg_homedir (), templ, NULL );
1036   fp = fopen (fname, "w");
1037   if (fp)
1038     {
1039       fprintf (fp, "%s\n",
1040                (cur_status & 1)? "USABLE":
1041                (cur_status & 4)? "ACTIVE":
1042                (cur_status & 2)? "PRESENT": "NOCARD");
1043       fclose (fp);
1044     }
1045   xfree (fname);
1046
1047   homestr = make_filename (gnupg_homedir (), NULL);
1048   if (gpgrt_asprintf (&envstr, "GNUPGHOME=%s", homestr) < 0)
1049     log_error ("out of core while building environment\n");
1050   else
1051     {
1052       gpg_error_t err;
1053       const char *args[9], *envs[2];
1054       char numbuf1[30], numbuf2[30], numbuf3[30];
1055
1056       envs[0] = envstr;
1057       envs[1] = NULL;
1058
1059       sprintf (numbuf1, "%d", slot);
1060       sprintf (numbuf2, "0x%04X", old_status);
1061       sprintf (numbuf3, "0x%04X", cur_status);
1062       args[0] = "--reader-port";
1063       args[1] = numbuf1;
1064       args[2] = "--old-code";
1065       args[3] = numbuf2;
1066       args[4] = "--new-code";
1067       args[5] = numbuf3;
1068       args[6] = "--status";
1069       args[7] = ((cur_status & 1)? "USABLE":
1070                  (cur_status & 4)? "ACTIVE":
1071                  (cur_status & 2)? "PRESENT": "NOCARD");
1072       args[8] = NULL;
1073
1074       fname = make_filename (gnupg_homedir (), "scd-event", NULL);
1075       err = gnupg_spawn_process_detached (fname, args, envs);
1076       if (err && gpg_err_code (err) != GPG_ERR_ENOENT)
1077         log_error ("failed to run event handler '%s': %s\n",
1078                    fname, gpg_strerror (err));
1079       xfree (fname);
1080       xfree (envstr);
1081     }
1082   xfree (homestr);
1083 }
1084
1085 int
1086 scd_update_reader_status_file (void)
1087 {
1088   app_t a, app_next;
1089   int periodical_check_needed = 0;
1090
1091   npth_mutex_lock (&app_list_lock);
1092   for (a = app_top; a; a = app_next)
1093     {
1094       int sw;
1095       unsigned int status;
1096
1097       lock_app (a, NULL);
1098       app_next = a->next;
1099
1100       if (a->reset_requested)
1101         status = 0;
1102       else
1103         {
1104           sw = apdu_get_status (a->slot, 0, &status);
1105           if (sw == SW_HOST_NO_READER)
1106             {
1107               /* Most likely the _reader_ has been unplugged.  */
1108               status = 0;
1109             }
1110           else if (sw)
1111             {
1112               /* Get status failed.  Ignore that.  */
1113               if (a->periodical_check_needed)
1114                 periodical_check_needed = 1;
1115               unlock_app (a);
1116               continue;
1117             }
1118         }
1119
1120       if (a->card_status != status)
1121         {
1122           report_change (a->slot, a->card_status, status);
1123           send_client_notifications (a, status == 0);
1124
1125           if (status == 0)
1126             {
1127               log_debug ("Removal of a card: %d\n", a->slot);
1128               apdu_close_reader (a->slot);
1129               deallocate_app (a);
1130             }
1131           else
1132             {
1133               a->card_status = status;
1134               if (a->periodical_check_needed)
1135                 periodical_check_needed = 1;
1136               unlock_app (a);
1137             }
1138         }
1139       else
1140         {
1141           if (a->periodical_check_needed)
1142             periodical_check_needed = 1;
1143           unlock_app (a);
1144         }
1145     }
1146   npth_mutex_unlock (&app_list_lock);
1147
1148   return periodical_check_needed;
1149 }
1150
1151 /* This function must be called once to initialize this module.  This
1152    has to be done before a second thread is spawned.  We can't do the
1153    static initialization because Pth emulation code might not be able
1154    to do a static init; in particular, it is not possible for W32. */
1155 gpg_error_t
1156 initialize_module_command (void)
1157 {
1158   gpg_error_t err;
1159
1160   if (npth_mutex_init (&app_list_lock, NULL))
1161     {
1162       err = gpg_error_from_syserror ();
1163       log_error ("app: error initializing mutex: %s\n", gpg_strerror (err));
1164       return err;
1165     }
1166
1167   return apdu_init ();
1168 }
1169
1170 void
1171 app_send_card_list (ctrl_t ctrl)
1172 {
1173   app_t a;
1174   char buf[65];
1175
1176   npth_mutex_lock (&app_list_lock);
1177   for (a = app_top; a; a = a->next)
1178     {
1179       if (DIM (buf) < 2 * a->serialnolen + 1)
1180         continue;
1181
1182       bin2hex (a->serialno, a->serialnolen, buf);
1183       send_status_direct (ctrl, "SERIALNO", buf);
1184     }
1185   npth_mutex_unlock (&app_list_lock);
1186 }