w32: Also change the directory on daemon startup.
[gnupg.git] / scd / app.c
1 /* app.c - Application selection.
2  * Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <https://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <errno.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <npth.h>
26
27 #include "scdaemon.h"
28 #include "../common/exechelp.h"
29 #include "app-common.h"
30 #include "iso7816.h"
31 #include "apdu.h"
32 #include "../common/tlv.h"
33
34 static npth_mutex_t app_list_lock;
35 static app_t app_top;
36 \f
37 static void
38 print_progress_line (void *opaque, const char *what, int pc, int cur, int tot)
39 {
40   ctrl_t ctrl = opaque;
41   char line[100];
42
43   if (ctrl)
44     {
45       snprintf (line, sizeof line, "%s %c %d %d", what, pc, cur, tot);
46       send_status_direct (ctrl, "PROGRESS", line);
47     }
48 }
49
50
51 /* Lock the reader SLOT.  This function shall be used right before
52    calling any of the actual application functions to serialize access
53    to the reader.  We do this always even if the reader is not
54    actually used.  This allows an actual connection to assume that it
55    never shares a reader (while performing one command).  Returns 0 on
56    success; only then the unlock_reader function must be called after
57    returning from the handler. */
58 static gpg_error_t
59 lock_app (app_t app, ctrl_t ctrl)
60 {
61   if (npth_mutex_lock (&app->lock))
62     {
63       gpg_error_t err = gpg_error_from_syserror ();
64       log_error ("failed to acquire APP lock for %p: %s\n",
65                  app, gpg_strerror (err));
66       return err;
67     }
68
69   apdu_set_progress_cb (app->slot, print_progress_line, ctrl);
70
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 whether 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);
212       if (!err)
213         err = iso7816_select_file (slot, 0x2F02, 0);
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, a_prev = NULL;
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       a_prev = a;
379     }
380
381   if (a)
382     {
383       err = check_conflict (a, name);
384       if (!err)
385         {
386           a->ref_count++;
387           *r_app = a;
388           if (a_prev)
389             {
390               a_prev->next = a->next;
391               a->next = app_top;
392               app_top = a;
393             }
394       }
395       unlock_app (a);
396     }
397   else
398     err = gpg_error (GPG_ERR_ENODEV);
399
400   npth_mutex_unlock (&app_list_lock);
401
402   return err;
403 }
404
405
406 char *
407 get_supported_applications (void)
408 {
409   const char *list[] = {
410     "openpgp",
411     "nks",
412     "p15",
413     "geldkarte",
414     "dinsig",
415     "sc-hsm",
416     /* Note: "undefined" is not listed here because it needs special
417        treatment by the client.  */
418     NULL
419   };
420   int idx;
421   size_t nbytes;
422   char *buffer, *p;
423
424   for (nbytes=1, idx=0; list[idx]; idx++)
425     nbytes += strlen (list[idx]) + 1 + 1;
426
427   buffer = xtrymalloc (nbytes);
428   if (!buffer)
429     return NULL;
430
431   for (p=buffer, idx=0; list[idx]; idx++)
432     if (is_app_allowed (list[idx]))
433       p = stpcpy (stpcpy (p, list[idx]), ":\n");
434   *p = 0;
435
436   return buffer;
437 }
438
439
440 /* Deallocate the application.  */
441 static void
442 deallocate_app (app_t app)
443 {
444   app_t a, a_prev = NULL;
445
446   for (a = app_top; a; a = a->next)
447     if (a == app)
448       {
449         if (a_prev == NULL)
450           app_top = a->next;
451         else
452           a_prev->next = a->next;
453         break;
454       }
455     else
456       a_prev = a;
457
458   if (app->ref_count)
459     log_error ("trying to release context used yet (%d)\n", app->ref_count);
460
461   if (app->fnc.deinit)
462     {
463       app->fnc.deinit (app);
464       app->fnc.deinit = NULL;
465     }
466
467   xfree (app->serialno);
468
469   unlock_app (app);
470   xfree (app);
471 }
472
473 /* Free the resources associated with the application APP.  APP is
474    allowed to be NULL in which case this is a no-op.  Note that we are
475    using reference counting to track the users of the application and
476    actually deferring the deallocation to allow for a later reuse by
477    a new connection. */
478 void
479 release_application (app_t app, int locked_already)
480 {
481   if (!app)
482     return;
483
484   /* We don't deallocate app here.  Instead, we keep it.  This is
485      useful so that a card does not get reset even if only one session
486      is using the card - this way the PIN cache and other cached data
487      are preserved.  */
488
489   if (!locked_already)
490     lock_app (app, NULL);
491
492   if (!app->ref_count)
493     log_bug ("trying to release an already released context\n");
494
495   --app->ref_count;
496   if (!locked_already)
497     unlock_app (app);
498 }
499
500
501
502 /* The serial number may need some cosmetics.  Do it here.  This
503    function shall only be called once after a new serial number has
504    been put into APP->serialno.
505
506    Prefixes we use:
507
508      FF 00 00 = For serial numbers starting with an FF
509      FF 01 00 = Some german p15 cards return an empty serial number so the
510                 serial number from the EF(TokenInfo) is used instead.
511      FF 7F 00 = No serialno.
512
513      All other serial number not starting with FF are used as they are.
514 */
515 gpg_error_t
516 app_munge_serialno (app_t app)
517 {
518   if (app->serialnolen && app->serialno[0] == 0xff)
519     {
520       /* The serial number starts with our special prefix.  This
521          requires that we put our default prefix "FF0000" in front. */
522       unsigned char *p = xtrymalloc (app->serialnolen + 3);
523       if (!p)
524         return gpg_error_from_syserror ();
525       memcpy (p, "\xff\0", 3);
526       memcpy (p+3, app->serialno, app->serialnolen);
527       app->serialnolen += 3;
528       xfree (app->serialno);
529       app->serialno = p;
530     }
531   else if (!app->serialnolen)
532     {
533       unsigned char *p = xtrymalloc (3);
534       if (!p)
535         return gpg_error_from_syserror ();
536       memcpy (p, "\xff\x7f", 3);
537       app->serialnolen = 3;
538       xfree (app->serialno);
539       app->serialno = p;
540     }
541   return 0;
542 }
543
544
545
546 /* Retrieve the serial number of the card.  The serial number is
547    returned as a malloced string (hex encoded) in SERIAL.  Caller must
548    free SERIAL unless the function returns an error.  */
549 char *
550 app_get_serialno (app_t app)
551 {
552   char *serial;
553
554   if (!app)
555     return NULL;
556
557   if (!app->serialnolen)
558     serial = xtrystrdup ("FF7F00");
559   else
560     serial = bin2hex (app->serialno, app->serialnolen, NULL);
561
562   return serial;
563 }
564
565
566 /* Write out the application specifig status lines for the LEARN
567    command. */
568 gpg_error_t
569 app_write_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
570 {
571   gpg_error_t err;
572
573   if (!app)
574     return gpg_error (GPG_ERR_INV_VALUE);
575   if (!app->fnc.learn_status)
576     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
577
578   /* We do not send APPTYPE if only keypairinfo is requested.  */
579   if (app->apptype && !(flags & 1))
580     send_status_direct (ctrl, "APPTYPE", app->apptype);
581   err = lock_app (app, ctrl);
582   if (err)
583     return err;
584   err = app->fnc.learn_status (app, ctrl, flags);
585   unlock_app (app);
586   return err;
587 }
588
589
590 /* Read the certificate with id CERTID (as returned by learn_status in
591    the CERTINFO status lines) and return it in the freshly allocated
592    buffer put into CERT and the length of the certificate put into
593    CERTLEN. */
594 gpg_error_t
595 app_readcert (app_t app, ctrl_t ctrl, const char *certid,
596               unsigned char **cert, size_t *certlen)
597 {
598   gpg_error_t err;
599
600   if (!app)
601     return gpg_error (GPG_ERR_INV_VALUE);
602   if (!app->ref_count)
603     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
604   if (!app->fnc.readcert)
605     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
606   err = lock_app (app, ctrl);
607   if (err)
608     return err;
609   err = app->fnc.readcert (app, certid, cert, certlen);
610   unlock_app (app);
611   return err;
612 }
613
614
615 /* Read the key with ID KEYID.  On success a canonical encoded
616    S-expression with the public key will get stored at PK and its
617    length (for assertions) at PKLEN; the caller must release that
618    buffer. On error NULL will be stored at PK and PKLEN and an error
619    code returned.
620
621    This function might not be supported by all applications.  */
622 gpg_error_t
623 app_readkey (app_t app, ctrl_t ctrl, int advanced, const char *keyid,
624              unsigned char **pk, size_t *pklen)
625 {
626   gpg_error_t err;
627
628   if (pk)
629     *pk = NULL;
630   if (pklen)
631     *pklen = 0;
632
633   if (!app || !keyid || !pk || !pklen)
634     return gpg_error (GPG_ERR_INV_VALUE);
635   if (!app->ref_count)
636     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
637   if (!app->fnc.readkey)
638     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
639   err = lock_app (app, ctrl);
640   if (err)
641     return err;
642   err= app->fnc.readkey (app, advanced, keyid, pk, pklen);
643   unlock_app (app);
644   return err;
645 }
646
647
648 /* Perform a GETATTR operation.  */
649 gpg_error_t
650 app_getattr (app_t app, ctrl_t ctrl, const char *name)
651 {
652   gpg_error_t err;
653
654   if (!app || !name || !*name)
655     return gpg_error (GPG_ERR_INV_VALUE);
656   if (!app->ref_count)
657     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
658
659   if (app->apptype && name && !strcmp (name, "APPTYPE"))
660     {
661       send_status_direct (ctrl, "APPTYPE", app->apptype);
662       return 0;
663     }
664   if (name && !strcmp (name, "SERIALNO"))
665     {
666       char *serial;
667
668       serial = app_get_serialno (app);
669       if (!serial)
670         return gpg_error (GPG_ERR_INV_VALUE);
671
672       send_status_direct (ctrl, "SERIALNO", serial);
673       xfree (serial);
674       return 0;
675     }
676
677   if (!app->fnc.getattr)
678     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
679   err = lock_app (app, ctrl);
680   if (err)
681     return err;
682   err =  app->fnc.getattr (app, ctrl, name);
683   unlock_app (app);
684   return err;
685 }
686
687 /* Perform a SETATTR operation.  */
688 gpg_error_t
689 app_setattr (app_t app, ctrl_t ctrl, const char *name,
690              gpg_error_t (*pincb)(void*, const char *, char **),
691              void *pincb_arg,
692              const unsigned char *value, size_t valuelen)
693 {
694   gpg_error_t err;
695
696   if (!app || !name || !*name || !value)
697     return gpg_error (GPG_ERR_INV_VALUE);
698   if (!app->ref_count)
699     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
700   if (!app->fnc.setattr)
701     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
702   err = lock_app (app, ctrl);
703   if (err)
704     return err;
705   err = app->fnc.setattr (app, name, pincb, pincb_arg, value, valuelen);
706   unlock_app (app);
707   return err;
708 }
709
710 /* Create the signature and return the allocated result in OUTDATA.
711    If a PIN is required the PINCB will be used to ask for the PIN; it
712    should return the PIN in an allocated buffer and put it into PIN.  */
713 gpg_error_t
714 app_sign (app_t app, ctrl_t ctrl, const char *keyidstr, int hashalgo,
715           gpg_error_t (*pincb)(void*, const char *, char **),
716           void *pincb_arg,
717           const void *indata, size_t indatalen,
718           unsigned char **outdata, size_t *outdatalen )
719 {
720   gpg_error_t err;
721
722   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
723     return gpg_error (GPG_ERR_INV_VALUE);
724   if (!app->ref_count)
725     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
726   if (!app->fnc.sign)
727     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
728   err = lock_app (app, ctrl);
729   if (err)
730     return err;
731   err = app->fnc.sign (app, keyidstr, hashalgo,
732                        pincb, pincb_arg,
733                        indata, indatalen,
734                        outdata, outdatalen);
735   unlock_app (app);
736   if (opt.verbose)
737     log_info ("operation sign result: %s\n", gpg_strerror (err));
738   return err;
739 }
740
741 /* Create the signature using the INTERNAL AUTHENTICATE command and
742    return the allocated result in OUTDATA.  If a PIN is required the
743    PINCB will be used to ask for the PIN; it should return the PIN in
744    an allocated buffer and put it into PIN.  */
745 gpg_error_t
746 app_auth (app_t app, ctrl_t ctrl, const char *keyidstr,
747           gpg_error_t (*pincb)(void*, const char *, char **),
748           void *pincb_arg,
749           const void *indata, size_t indatalen,
750           unsigned char **outdata, size_t *outdatalen )
751 {
752   gpg_error_t err;
753
754   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
755     return gpg_error (GPG_ERR_INV_VALUE);
756   if (!app->ref_count)
757     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
758   if (!app->fnc.auth)
759     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
760   err = lock_app (app, ctrl);
761   if (err)
762     return err;
763   err = app->fnc.auth (app, keyidstr,
764                        pincb, pincb_arg,
765                        indata, indatalen,
766                        outdata, outdatalen);
767   unlock_app (app);
768   if (opt.verbose)
769     log_info ("operation auth result: %s\n", gpg_strerror (err));
770   return err;
771 }
772
773
774 /* Decrypt the data in INDATA and return the allocated result in OUTDATA.
775    If a PIN is required the PINCB will be used to ask for the PIN; it
776    should return the PIN in an allocated buffer and put it into PIN.  */
777 gpg_error_t
778 app_decipher (app_t app, ctrl_t ctrl, const char *keyidstr,
779               gpg_error_t (*pincb)(void*, const char *, char **),
780               void *pincb_arg,
781               const void *indata, size_t indatalen,
782               unsigned char **outdata, size_t *outdatalen,
783               unsigned int *r_info)
784 {
785   gpg_error_t err;
786
787   *r_info = 0;
788
789   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
790     return gpg_error (GPG_ERR_INV_VALUE);
791   if (!app->ref_count)
792     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
793   if (!app->fnc.decipher)
794     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
795   err = lock_app (app, ctrl);
796   if (err)
797     return err;
798   err = app->fnc.decipher (app, keyidstr,
799                            pincb, pincb_arg,
800                            indata, indatalen,
801                            outdata, outdatalen,
802                            r_info);
803   unlock_app (app);
804   if (opt.verbose)
805     log_info ("operation decipher result: %s\n", gpg_strerror (err));
806   return err;
807 }
808
809
810 /* Perform the WRITECERT operation.  */
811 gpg_error_t
812 app_writecert (app_t app, ctrl_t ctrl,
813               const char *certidstr,
814               gpg_error_t (*pincb)(void*, const char *, char **),
815               void *pincb_arg,
816               const unsigned char *data, size_t datalen)
817 {
818   gpg_error_t err;
819
820   if (!app || !certidstr || !*certidstr || !pincb)
821     return gpg_error (GPG_ERR_INV_VALUE);
822   if (!app->ref_count)
823     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
824   if (!app->fnc.writecert)
825     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
826   err = lock_app (app, ctrl);
827   if (err)
828     return err;
829   err = app->fnc.writecert (app, ctrl, certidstr,
830                             pincb, pincb_arg, data, datalen);
831   unlock_app (app);
832   if (opt.verbose)
833     log_info ("operation writecert result: %s\n", gpg_strerror (err));
834   return err;
835 }
836
837
838 /* Perform the WRITEKEY operation.  */
839 gpg_error_t
840 app_writekey (app_t app, ctrl_t ctrl,
841               const char *keyidstr, unsigned int flags,
842               gpg_error_t (*pincb)(void*, const char *, char **),
843               void *pincb_arg,
844               const unsigned char *keydata, size_t keydatalen)
845 {
846   gpg_error_t err;
847
848   if (!app || !keyidstr || !*keyidstr || !pincb)
849     return gpg_error (GPG_ERR_INV_VALUE);
850   if (!app->ref_count)
851     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
852   if (!app->fnc.writekey)
853     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
854   err = lock_app (app, ctrl);
855   if (err)
856     return err;
857   err = app->fnc.writekey (app, ctrl, keyidstr, flags,
858                            pincb, pincb_arg, keydata, keydatalen);
859   unlock_app (app);
860   if (opt.verbose)
861     log_info ("operation writekey result: %s\n", gpg_strerror (err));
862   return err;
863 }
864
865
866 /* Perform a SETATTR operation.  */
867 gpg_error_t
868 app_genkey (app_t app, ctrl_t ctrl, const char *keynostr, unsigned int flags,
869             time_t createtime,
870             gpg_error_t (*pincb)(void*, const char *, char **),
871             void *pincb_arg)
872 {
873   gpg_error_t err;
874
875   if (!app || !keynostr || !*keynostr || !pincb)
876     return gpg_error (GPG_ERR_INV_VALUE);
877   if (!app->ref_count)
878     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
879   if (!app->fnc.genkey)
880     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
881   err = lock_app (app, ctrl);
882   if (err)
883     return err;
884   err = app->fnc.genkey (app, ctrl, keynostr, flags,
885                          createtime, pincb, pincb_arg);
886   unlock_app (app);
887   if (opt.verbose)
888     log_info ("operation genkey result: %s\n", gpg_strerror (err));
889   return err;
890 }
891
892
893 /* Perform a GET CHALLENGE operation.  This function is special as it
894    directly accesses the card without any application specific
895    wrapper. */
896 gpg_error_t
897 app_get_challenge (app_t app, ctrl_t ctrl, size_t nbytes, unsigned char *buffer)
898 {
899   gpg_error_t err;
900
901   if (!app || !nbytes || !buffer)
902     return gpg_error (GPG_ERR_INV_VALUE);
903   if (!app->ref_count)
904     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
905   err = lock_app (app, ctrl);
906   if (err)
907     return err;
908   err = iso7816_get_challenge (app->slot, nbytes, buffer);
909   unlock_app (app);
910   return err;
911 }
912
913
914
915 /* Perform a CHANGE REFERENCE DATA or RESET RETRY COUNTER operation.  */
916 gpg_error_t
917 app_change_pin (app_t app, ctrl_t ctrl, const char *chvnostr, int reset_mode,
918                 gpg_error_t (*pincb)(void*, const char *, char **),
919                 void *pincb_arg)
920 {
921   gpg_error_t err;
922
923   if (!app || !chvnostr || !*chvnostr || !pincb)
924     return gpg_error (GPG_ERR_INV_VALUE);
925   if (!app->ref_count)
926     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
927   if (!app->fnc.change_pin)
928     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
929   err = lock_app (app, ctrl);
930   if (err)
931     return err;
932   err = app->fnc.change_pin (app, ctrl, chvnostr, reset_mode,
933                              pincb, pincb_arg);
934   unlock_app (app);
935   if (opt.verbose)
936     log_info ("operation change_pin result: %s\n", gpg_strerror (err));
937   return err;
938 }
939
940
941 /* Perform a VERIFY operation without doing anything lese.  This may
942    be used to initialize a the PIN cache for long lasting other
943    operations.  Its use is highly application dependent. */
944 gpg_error_t
945 app_check_pin (app_t app, ctrl_t ctrl, const char *keyidstr,
946                gpg_error_t (*pincb)(void*, const char *, char **),
947                void *pincb_arg)
948 {
949   gpg_error_t err;
950
951   if (!app || !keyidstr || !*keyidstr || !pincb)
952     return gpg_error (GPG_ERR_INV_VALUE);
953   if (!app->ref_count)
954     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
955   if (!app->fnc.check_pin)
956     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
957   err = lock_app (app, ctrl);
958   if (err)
959     return err;
960   err = app->fnc.check_pin (app, keyidstr, pincb, pincb_arg);
961   unlock_app (app);
962   if (opt.verbose)
963     log_info ("operation check_pin result: %s\n", gpg_strerror (err));
964   return err;
965 }
966
967 static void
968 report_change (int slot, int old_status, int cur_status)
969 {
970   char *homestr, *envstr;
971   char *fname;
972   char templ[50];
973   FILE *fp;
974
975   snprintf (templ, sizeof templ, "reader_%d.status", slot);
976   fname = make_filename (gnupg_homedir (), templ, NULL );
977   fp = fopen (fname, "w");
978   if (fp)
979     {
980       fprintf (fp, "%s\n",
981                (cur_status & 1)? "USABLE":
982                (cur_status & 4)? "ACTIVE":
983                (cur_status & 2)? "PRESENT": "NOCARD");
984       fclose (fp);
985     }
986   xfree (fname);
987
988   homestr = make_filename (gnupg_homedir (), NULL);
989   if (gpgrt_asprintf (&envstr, "GNUPGHOME=%s", homestr) < 0)
990     log_error ("out of core while building environment\n");
991   else
992     {
993       gpg_error_t err;
994       const char *args[9], *envs[2];
995       char numbuf1[30], numbuf2[30], numbuf3[30];
996
997       envs[0] = envstr;
998       envs[1] = NULL;
999
1000       sprintf (numbuf1, "%d", slot);
1001       sprintf (numbuf2, "0x%04X", old_status);
1002       sprintf (numbuf3, "0x%04X", cur_status);
1003       args[0] = "--reader-port";
1004       args[1] = numbuf1;
1005       args[2] = "--old-code";
1006       args[3] = numbuf2;
1007       args[4] = "--new-code";
1008       args[5] = numbuf3;
1009       args[6] = "--status";
1010       args[7] = ((cur_status & 1)? "USABLE":
1011                  (cur_status & 4)? "ACTIVE":
1012                  (cur_status & 2)? "PRESENT": "NOCARD");
1013       args[8] = NULL;
1014
1015       fname = make_filename (gnupg_homedir (), "scd-event", NULL);
1016       err = gnupg_spawn_process_detached (fname, args, envs);
1017       if (err && gpg_err_code (err) != GPG_ERR_ENOENT)
1018         log_error ("failed to run event handler '%s': %s\n",
1019                    fname, gpg_strerror (err));
1020       xfree (fname);
1021       xfree (envstr);
1022     }
1023   xfree (homestr);
1024 }
1025
1026 int
1027 scd_update_reader_status_file (void)
1028 {
1029   app_t a, app_next;
1030   int periodical_check_needed = 0;
1031
1032   npth_mutex_lock (&app_list_lock);
1033   for (a = app_top; a; a = app_next)
1034     {
1035       int sw;
1036       unsigned int status;
1037
1038       lock_app (a, NULL);
1039       app_next = a->next;
1040
1041       if (a->reset_requested)
1042         status = 0;
1043       else
1044         {
1045           sw = apdu_get_status (a->slot, 0, &status);
1046           if (sw == SW_HOST_NO_READER)
1047             {
1048               /* Most likely the _reader_ has been unplugged.  */
1049               status = 0;
1050             }
1051           else if (sw)
1052             {
1053               /* Get status failed.  Ignore that.  */
1054               if (a->periodical_check_needed)
1055                 periodical_check_needed = 1;
1056               unlock_app (a);
1057               continue;
1058             }
1059         }
1060
1061       if (a->card_status != status)
1062         {
1063           report_change (a->slot, a->card_status, status);
1064           send_client_notifications (a, status == 0);
1065
1066           if (status == 0)
1067             {
1068               log_debug ("Removal of a card: %d\n", a->slot);
1069               apdu_close_reader (a->slot);
1070               deallocate_app (a);
1071             }
1072           else
1073             {
1074               a->card_status = status;
1075               if (a->periodical_check_needed)
1076                 periodical_check_needed = 1;
1077               unlock_app (a);
1078             }
1079         }
1080       else
1081         {
1082           if (a->periodical_check_needed)
1083             periodical_check_needed = 1;
1084           unlock_app (a);
1085         }
1086     }
1087   npth_mutex_unlock (&app_list_lock);
1088
1089   return periodical_check_needed;
1090 }
1091
1092 /* This function must be called once to initialize this module.  This
1093    has to be done before a second thread is spawned.  We can't do the
1094    static initialization because Pth emulation code might not be able
1095    to do a static init; in particular, it is not possible for W32. */
1096 gpg_error_t
1097 initialize_module_command (void)
1098 {
1099   gpg_error_t err;
1100
1101   if (npth_mutex_init (&app_list_lock, NULL))
1102     {
1103       err = gpg_error_from_syserror ();
1104       log_error ("app: error initializing mutex: %s\n", gpg_strerror (err));
1105       return err;
1106     }
1107
1108   return apdu_init ();
1109 }
1110
1111 void
1112 app_send_card_list (ctrl_t ctrl)
1113 {
1114   app_t a;
1115   char buf[65];
1116
1117   npth_mutex_lock (&app_list_lock);
1118   for (a = app_top; a; a = a->next)
1119     {
1120       if (DIM (buf) < 2 * a->serialnolen + 1)
1121         continue;
1122
1123       bin2hex (a->serialno, a->serialnolen, buf);
1124       send_status_direct (ctrl, "SERIALNO", buf);
1125     }
1126   npth_mutex_unlock (&app_list_lock);
1127 }