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