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