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