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