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