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