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