gpg: Extend --quick-gen-key for creating keys from a card.
[gnupg.git] / agent / trustlist.c
1 /* trustlist.c - Maintain the list of trusted keys
2  * Copyright (C) 2002, 2004, 2006, 2007, 2009,
3  *               2012 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <unistd.h>
28 #include <sys/stat.h>
29 #include <npth.h>
30
31 #include "agent.h"
32 #include <assuan.h> /* fixme: need a way to avoid assuan calls here */
33 #include "../common/i18n.h"
34
35
36 /* A structure to store the information from the trust file. */
37 struct trustitem_s
38 {
39   struct
40   {
41     int disabled:1;       /* This entry is disabled.  */
42     int for_pgp:1;        /* Set by '*' or 'P' as first flag. */
43     int for_smime:1;      /* Set by '*' or 'S' as first flag. */
44     int relax:1;          /* Relax checking of root certificate
45                              constraints. */
46     int cm:1;             /* Use chain model for validation. */
47   } flags;
48   unsigned char fpr[20];  /* The binary fingerprint. */
49 };
50 typedef struct trustitem_s trustitem_t;
51
52 /* Malloced table and its allocated size with all trust items. */
53 static trustitem_t *trusttable;
54 static size_t trusttablesize;
55 /* A mutex used to protect the table. */
56 static npth_mutex_t trusttable_lock;
57
58
59 static const char headerblurb[] =
60 "# This is the list of trusted keys.  Comment lines, like this one, as\n"
61 "# well as empty lines are ignored.  Lines have a length limit but this\n"
62 "# is not a serious limitation as the format of the entries is fixed and\n"
63 "# checked by gpg-agent.  A non-comment line starts with optional white\n"
64 "# space, followed by the SHA-1 fingerpint in hex, followed by a flag\n"
65 "# which may be one of 'P', 'S' or '*' and optionally followed by a list of\n"
66 "# other flags.  The fingerprint may be prefixed with a '!' to mark the\n"
67 "# key as not trusted.  You should give the gpg-agent a HUP or run the\n"
68 "# command \"gpgconf --reload gpg-agent\" after changing this file.\n"
69 "\n\n"
70 "# Include the default trust list\n"
71 "include-default\n"
72 "\n";
73
74
75 /* This function must be called once to initialize this module.  This
76    has to be done before a second thread is spawned.  We can't do the
77    static initialization because Pth emulation code might not be able
78    to do a static init; in particular, it is not possible for W32. */
79 void
80 initialize_module_trustlist (void)
81 {
82   static int initialized;
83   int err;
84
85   if (!initialized)
86     {
87       err = npth_mutex_init (&trusttable_lock, NULL);
88       if (err)
89         log_fatal ("failed to init mutex in %s: %s\n", __FILE__,strerror (err));
90       initialized = 1;
91     }
92 }
93
94
95
96 \f
97 static void
98 lock_trusttable (void)
99 {
100   int err;
101
102   err = npth_mutex_lock (&trusttable_lock);
103   if (err)
104     log_fatal ("failed to acquire mutex in %s: %s\n", __FILE__, strerror (err));
105 }
106
107
108 static void
109 unlock_trusttable (void)
110 {
111   int err;
112
113   err = npth_mutex_unlock (&trusttable_lock);
114   if (err)
115     log_fatal ("failed to release mutex in %s: %s\n", __FILE__, strerror (err));
116 }
117
118
119 /* Clear the trusttable.  The caller needs to make sure that the
120    trusttable is locked.  */
121 static inline void
122 clear_trusttable (void)
123 {
124   xfree (trusttable);
125   trusttable = NULL;
126   trusttablesize = 0;
127 }
128
129
130 static gpg_error_t
131 read_one_trustfile (const char *fname, int allow_include,
132                     trustitem_t **addr_of_table,
133                     size_t *addr_of_tablesize,
134                     int *addr_of_tableidx)
135 {
136   gpg_error_t err = 0;
137   estream_t fp;
138   int n, c;
139   char *p, line[256];
140   trustitem_t *table, *ti;
141   int tableidx;
142   size_t tablesize;
143   int lnr = 0;
144
145   table = *addr_of_table;
146   tablesize = *addr_of_tablesize;
147   tableidx = *addr_of_tableidx;
148
149   fp = es_fopen (fname, "r");
150   if (!fp)
151     {
152       err = gpg_error_from_syserror ();
153       log_error (_("error opening '%s': %s\n"), fname, gpg_strerror (err));
154       goto leave;
155     }
156
157   while (es_fgets (line, DIM(line)-1, fp))
158     {
159       lnr++;
160
161       n = strlen (line);
162       if (!n || line[n-1] != '\n')
163         {
164           /* Eat until end of line. */
165           while ( (c=es_getc (fp)) != EOF && c != '\n')
166             ;
167           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
168                            : GPG_ERR_INCOMPLETE_LINE);
169           log_error (_("file '%s', line %d: %s\n"),
170                      fname, lnr, gpg_strerror (err));
171           continue;
172         }
173       line[--n] = 0; /* Chop the LF. */
174       if (n && line[n-1] == '\r')
175         line[--n] = 0; /* Chop an optional CR. */
176
177       /* Allow for empty lines and spaces */
178       for (p=line; spacep (p); p++)
179         ;
180       if (!*p || *p == '#')
181         continue;
182
183       if (!strncmp (p, "include-default", 15)
184           && (!p[15] || spacep (p+15)))
185         {
186           char *etcname;
187           gpg_error_t err2;
188
189           if (!allow_include)
190             {
191               log_error (_("statement \"%s\" ignored in '%s', line %d\n"),
192                          "include-default", fname, lnr);
193               continue;
194             }
195           /* fixme: Should check for trailing garbage.  */
196
197           etcname = make_filename (gnupg_sysconfdir (), "trustlist.txt", NULL);
198           if ( !strcmp (etcname, fname) ) /* Same file. */
199             log_info (_("statement \"%s\" ignored in '%s', line %d\n"),
200                       "include-default", fname, lnr);
201           else if ( access (etcname, F_OK) && errno == ENOENT )
202             {
203               /* A non existent system trustlist is not an error.
204                  Just print a note. */
205               log_info (_("system trustlist '%s' not available\n"), etcname);
206             }
207           else
208             {
209               err2 = read_one_trustfile (etcname, 0,
210                                          &table, &tablesize, &tableidx);
211               if (err2)
212                 err = err2;
213             }
214           xfree (etcname);
215
216           continue;
217         }
218
219       if (tableidx == tablesize)  /* Need more space. */
220         {
221           trustitem_t *tmp;
222           size_t tmplen;
223
224           tmplen = tablesize + 20;
225           tmp = xtryrealloc (table, tmplen * sizeof *table);
226           if (!tmp)
227             {
228               err = gpg_error_from_syserror ();
229               goto leave;
230             }
231           table = tmp;
232           tablesize = tmplen;
233         }
234
235       ti = table + tableidx;
236
237       memset (&ti->flags, 0, sizeof ti->flags);
238       if (*p == '!')
239         {
240           ti->flags.disabled = 1;
241           p++;
242           while (spacep (p))
243             p++;
244         }
245
246       n = hexcolon2bin (p, ti->fpr, 20);
247       if (n < 0)
248         {
249           log_error (_("bad fingerprint in '%s', line %d\n"), fname, lnr);
250           err = gpg_error (GPG_ERR_BAD_DATA);
251           continue;
252         }
253       p += n;
254       for (; spacep (p); p++)
255         ;
256
257       /* Process the first flag which needs to be the first for
258          backward compatibility. */
259       if (!*p || *p == '*' )
260         {
261           ti->flags.for_smime = 1;
262           ti->flags.for_pgp = 1;
263         }
264       else if ( *p == 'P' || *p == 'p')
265         {
266           ti->flags.for_pgp = 1;
267         }
268       else if ( *p == 'S' || *p == 's')
269         {
270           ti->flags.for_smime = 1;
271         }
272       else
273         {
274           log_error (_("invalid keyflag in '%s', line %d\n"), fname, lnr);
275           err = gpg_error (GPG_ERR_BAD_DATA);
276           continue;
277         }
278       p++;
279       if ( *p && !spacep (p) )
280         {
281           log_error (_("invalid keyflag in '%s', line %d\n"), fname, lnr);
282           err = gpg_error (GPG_ERR_BAD_DATA);
283           continue;
284         }
285
286       /* Now check for more key-value pairs of the form NAME[=VALUE]. */
287       while (*p)
288         {
289           for (; spacep (p); p++)
290             ;
291           if (!*p)
292             break;
293           n = strcspn (p, "= \t");
294           if (p[n] == '=')
295             {
296               log_error ("assigning a value to a flag is not yet supported; "
297                          "in '%s', line %d\n", fname, lnr);
298               err = gpg_error (GPG_ERR_BAD_DATA);
299               p++;
300             }
301           else if (n == 5 && !memcmp (p, "relax", 5))
302             ti->flags.relax = 1;
303           else if (n == 2 && !memcmp (p, "cm", 2))
304             ti->flags.cm = 1;
305           else
306             log_error ("flag '%.*s' in '%s', line %d ignored\n",
307                        n, p, fname, lnr);
308           p += n;
309         }
310       tableidx++;
311     }
312   if ( !err && !es_feof (fp) )
313     {
314       err = gpg_error_from_syserror ();
315       log_error (_("error reading '%s', line %d: %s\n"),
316                  fname, lnr, gpg_strerror (err));
317     }
318
319  leave:
320   es_fclose (fp);
321   *addr_of_table = table;
322   *addr_of_tablesize = tablesize;
323   *addr_of_tableidx = tableidx;
324   return err;
325 }
326
327
328 /* Read the trust files and update the global table on success.  The
329    trusttable is assumed to be locked. */
330 static gpg_error_t
331 read_trustfiles (void)
332 {
333   gpg_error_t err;
334   trustitem_t *table, *ti;
335   int tableidx;
336   size_t tablesize;
337   char *fname;
338   int allow_include = 1;
339
340   tablesize = 20;
341   table = xtrycalloc (tablesize, sizeof *table);
342   if (!table)
343     return gpg_error_from_syserror ();
344   tableidx = 0;
345
346   fname = make_filename_try (gnupg_homedir (), "trustlist.txt", NULL);
347   if (!fname)
348     {
349       err = gpg_error_from_syserror ();
350       xfree (table);
351       return err;
352     }
353
354   if ( access (fname, F_OK) )
355     {
356       if ( errno == ENOENT )
357         ; /* Silently ignore a non-existing trustfile.  */
358       else
359         {
360           err = gpg_error_from_syserror ();
361           log_error (_("error opening '%s': %s\n"), fname, gpg_strerror (err));
362         }
363       xfree (fname);
364       fname = make_filename (gnupg_sysconfdir (), "trustlist.txt", NULL);
365       allow_include = 0;
366     }
367   err = read_one_trustfile (fname, allow_include,
368                             &table, &tablesize, &tableidx);
369   xfree (fname);
370
371   if (err)
372     {
373       xfree (table);
374       if (gpg_err_code (err) == GPG_ERR_ENOENT)
375         {
376           /* Take a missing trustlist as an empty one.  */
377           clear_trusttable ();
378           err = 0;
379         }
380       return err;
381     }
382
383   /* Fixme: we should drop duplicates and sort the table. */
384   ti = xtryrealloc (table, (tableidx?tableidx:1) * sizeof *table);
385   if (!ti)
386     {
387       err = gpg_error_from_syserror ();
388       xfree (table);
389       return err;
390     }
391
392   /* Replace the trusttable.  */
393   xfree (trusttable);
394   trusttable = ti;
395   trusttablesize = tableidx;
396   return 0;
397 }
398
399
400 /* Check whether the given fpr is in our trustdb.  We expect FPR to be
401    an all uppercase hexstring of 40 characters.  If ALREADY_LOCKED is
402    true the function assumes that the trusttable is already locked. */
403 static gpg_error_t
404 istrusted_internal (ctrl_t ctrl, const char *fpr, int *r_disabled,
405                     int already_locked)
406 {
407   gpg_error_t err = 0;
408   int locked = already_locked;
409   trustitem_t *ti;
410   size_t len;
411   unsigned char fprbin[20];
412
413   if (r_disabled)
414     *r_disabled = 0;
415
416   if ( hexcolon2bin (fpr, fprbin, 20) < 0 )
417     {
418       err = gpg_error (GPG_ERR_INV_VALUE);
419       goto leave;
420     }
421
422   if (!already_locked)
423     {
424       lock_trusttable ();
425       locked = 1;
426     }
427
428   if (!trusttable)
429     {
430       err = read_trustfiles ();
431       if (err)
432         {
433           log_error (_("error reading list of trusted root certificates\n"));
434           goto leave;
435         }
436     }
437
438   if (trusttable)
439     {
440       for (ti=trusttable, len = trusttablesize; len; ti++, len--)
441         if (!memcmp (ti->fpr, fprbin, 20))
442           {
443             if (ti->flags.disabled && r_disabled)
444               *r_disabled = 1;
445
446             /* Print status messages only if we have not been called
447                in a locked state.  */
448             if (already_locked)
449               ;
450             else if (ti->flags.relax)
451               {
452                 unlock_trusttable ();
453                 locked = 0;
454                 err = agent_write_status (ctrl, "TRUSTLISTFLAG", "relax", NULL);
455               }
456             else if (ti->flags.cm)
457               {
458                 unlock_trusttable ();
459                 locked = 0;
460                 err = agent_write_status (ctrl, "TRUSTLISTFLAG", "cm", NULL);
461               }
462
463             if (!err)
464               err = ti->flags.disabled? gpg_error (GPG_ERR_NOT_TRUSTED) : 0;
465             goto leave;
466           }
467     }
468   err = gpg_error (GPG_ERR_NOT_TRUSTED);
469
470  leave:
471   if (locked && !already_locked)
472     unlock_trusttable ();
473   return err;
474 }
475
476
477 /* Check whether the given fpr is in our trustdb.  We expect FPR to be
478    an all uppercase hexstring of 40 characters.  */
479 gpg_error_t
480 agent_istrusted (ctrl_t ctrl, const char *fpr, int *r_disabled)
481 {
482   return istrusted_internal (ctrl, fpr, r_disabled, 0);
483 }
484
485
486 /* Write all trust entries to FP. */
487 gpg_error_t
488 agent_listtrusted (void *assuan_context)
489 {
490   trustitem_t *ti;
491   char key[51];
492   gpg_error_t err;
493   size_t len;
494
495   lock_trusttable ();
496   if (!trusttable)
497     {
498       err = read_trustfiles ();
499       if (err)
500         {
501           unlock_trusttable ();
502           log_error (_("error reading list of trusted root certificates\n"));
503           return err;
504         }
505     }
506
507   if (trusttable)
508     {
509       for (ti=trusttable, len = trusttablesize; len; ti++, len--)
510         {
511           if (ti->flags.disabled)
512             continue;
513           bin2hex (ti->fpr, 20, key);
514           key[40] = ' ';
515           key[41] = ((ti->flags.for_smime && ti->flags.for_pgp)? '*'
516                      : ti->flags.for_smime? 'S': ti->flags.for_pgp? 'P':' ');
517           key[42] = '\n';
518           assuan_send_data (assuan_context, key, 43);
519           assuan_send_data (assuan_context, NULL, 0); /* flush */
520         }
521     }
522
523   unlock_trusttable ();
524   return 0;
525 }
526
527
528 /* Create a copy of string with colons inserted after each two bytes.
529    Caller needs to release the string.  In case of a memory failure,
530    NULL is returned.  */
531 static char *
532 insert_colons (const char *string)
533 {
534   char *buffer, *p;
535   size_t n = strlen (string);
536   size_t nnew = n + (n+1)/2;
537
538   p = buffer = xtrymalloc ( nnew + 1 );
539   if (!buffer)
540     return NULL;
541   while (*string)
542     {
543       *p++ = *string++;
544       if (*string)
545         {
546           *p++ = *string++;
547           if (*string)
548             *p++ = ':';
549         }
550     }
551   *p = 0;
552   log_assert (strlen (buffer) <= nnew);
553
554   return buffer;
555 }
556
557
558 /* To pretty print DNs in the Pinentry, we replace slashes by
559    REPLSTRING.  The caller needs to free the returned string.  NULL is
560    returned on error with ERRNO set.  */
561 static char *
562 reformat_name (const char *name, const char *replstring)
563 {
564   const char *s;
565   char *newname;
566   char *d;
567   size_t count;
568   size_t replstringlen = strlen (replstring);
569
570   /* If the name does not start with a slash it is not a preformatted
571      DN and thus we don't bother to reformat it.  */
572   if (*name != '/')
573     return xtrystrdup (name);
574
575   /* Count the names.  Note that a slash contained in a DN part is
576      expected to be C style escaped and thus the slashes we see here
577      are the actual part delimiters.  */
578   for (s=name+1, count=0; *s; s++)
579     if (*s == '/')
580       count++;
581   newname = xtrymalloc (strlen (name) + count*replstringlen + 1);
582   if (!newname)
583     return NULL;
584   for (s=name+1, d=newname; *s; s++)
585     if (*s == '/')
586       d = stpcpy (d, replstring);
587     else
588       *d++ = *s;
589   *d = 0;
590   return newname;
591 }
592
593
594 /* Insert the given fpr into our trustdb.  We expect FPR to be an all
595    uppercase hexstring of 40 characters. FLAG is either 'P' or 'C'.
596    This function does first check whether that key has already been
597    put into the trustdb and returns success in this case.  Before a
598    FPR actually gets inserted, the user is asked by means of the
599    Pinentry whether this is actual what he wants to do.  */
600 gpg_error_t
601 agent_marktrusted (ctrl_t ctrl, const char *name, const char *fpr, int flag)
602 {
603   gpg_error_t err = 0;
604   char *desc;
605   char *fname;
606   estream_t fp;
607   char *fprformatted;
608   char *nameformatted;
609   int is_disabled;
610   int yes_i_trust;
611
612   /* Check whether we are at all allowed to modify the trustlist.
613      This is useful so that the trustlist may be a symlink to a global
614      trustlist with only admin privileges to modify it.  Of course
615      this is not a secure way of denying access, but it avoids the
616      usual clicking on an Okay button most users are used to. */
617   fname = make_filename_try (gnupg_homedir (), "trustlist.txt", NULL);
618   if (!fname)
619     return gpg_error_from_syserror ();
620
621   if ( access (fname, W_OK) && errno != ENOENT)
622     {
623       xfree (fname);
624       return gpg_error (GPG_ERR_EPERM);
625     }
626   xfree (fname);
627
628   if (!agent_istrusted (ctrl, fpr, &is_disabled))
629     {
630       return 0; /* We already got this fingerprint.  Silently return
631                    success. */
632     }
633
634   /* This feature must explicitly been enabled. */
635   if (!opt.allow_mark_trusted)
636     return gpg_error (GPG_ERR_NOT_SUPPORTED);
637
638   if (is_disabled)
639     {
640       /* There is an disabled entry in the trustlist.  Return an error
641          so that the user won't be asked again for that one.  Changing
642          this flag with the integrated marktrusted feature is and will
643          not be made possible.  */
644       return gpg_error (GPG_ERR_NOT_TRUSTED);
645     }
646
647
648   /* Insert a new one. */
649   nameformatted = reformat_name (name, "%0A   ");
650   if (!nameformatted)
651     return gpg_error_from_syserror ();
652
653   /* First a general question whether this is trusted.  */
654   desc = xtryasprintf (
655                 /* TRANSLATORS: This prompt is shown by the Pinentry
656                    and has one special property: A "%%0A" is used by
657                    Pinentry to insert a line break.  The double
658                    percent sign is actually needed because it is also
659                    a printf format string.  If you need to insert a
660                    plain % sign, you need to encode it as "%%25".  The
661                    "%s" gets replaced by the name as stored in the
662                    certificate. */
663                 L_("Do you ultimately trust%%0A"
664                    "  \"%s\"%%0A"
665                    "to correctly certify user certificates?"),
666                 nameformatted);
667   if (!desc)
668     {
669       xfree (nameformatted);
670       return out_of_core ();
671     }
672   err = agent_get_confirmation (ctrl, desc, L_("Yes"), L_("No"), 1);
673   xfree (desc);
674   if (!err)
675     yes_i_trust = 1;
676   else if (gpg_err_code (err) == GPG_ERR_NOT_CONFIRMED)
677     yes_i_trust = 0;
678   else
679     {
680       xfree (nameformatted);
681       return err;
682     }
683
684
685   fprformatted = insert_colons (fpr);
686   if (!fprformatted)
687     {
688       xfree (nameformatted);
689       return out_of_core ();
690     }
691
692   /* If the user trusts this certificate he has to verify the
693      fingerprint of course.  */
694   if (yes_i_trust)
695     {
696       desc = xtryasprintf
697         (
698          /* TRANSLATORS: This prompt is shown by the Pinentry and has
699             one special property: A "%%0A" is used by Pinentry to
700             insert a line break.  The double percent sign is actually
701             needed because it is also a printf format string.  If you
702             need to insert a plain % sign, you need to encode it as
703             "%%25".  The second "%s" gets replaced by a hexdecimal
704             fingerprint string whereas the first one receives the name
705             as stored in the certificate. */
706          L_("Please verify that the certificate identified as:%%0A"
707             "  \"%s\"%%0A"
708             "has the fingerprint:%%0A"
709             "  %s"), nameformatted, fprformatted);
710       if (!desc)
711         {
712           xfree (fprformatted);
713           xfree (nameformatted);
714           return out_of_core ();
715         }
716
717       /* TRANSLATORS: "Correct" is the label of a button and intended
718          to be hit if the fingerprint matches the one of the CA.  The
719          other button is "the default "Cancel" of the Pinentry. */
720       err = agent_get_confirmation (ctrl, desc, L_("Correct"), L_("Wrong"), 1);
721       xfree (desc);
722       if (gpg_err_code (err) == GPG_ERR_NOT_CONFIRMED)
723         yes_i_trust = 0;
724       else if (err)
725         {
726           xfree (fprformatted);
727           xfree (nameformatted);
728           return err;
729         }
730     }
731
732
733   /* Now check again to avoid duplicates.  We take the lock to make
734      sure that nobody else plays with our file and force a reread.  */
735   lock_trusttable ();
736   clear_trusttable ();
737   if (!istrusted_internal (ctrl, fpr, &is_disabled, 1) || is_disabled)
738     {
739       unlock_trusttable ();
740       xfree (fprformatted);
741       xfree (nameformatted);
742       return is_disabled? gpg_error (GPG_ERR_NOT_TRUSTED) : 0;
743     }
744
745   fname = make_filename_try (gnupg_homedir (), "trustlist.txt", NULL);
746   if (!fname)
747     {
748       err = gpg_error_from_syserror ();
749       unlock_trusttable ();
750       xfree (fprformatted);
751       xfree (nameformatted);
752       return err;
753     }
754   if ( access (fname, F_OK) && errno == ENOENT)
755     {
756       fp = es_fopen (fname, "wx,mode=-rw-r");
757       if (!fp)
758         {
759           err = gpg_error_from_syserror ();
760           log_error ("can't create '%s': %s\n", fname, gpg_strerror (err));
761           xfree (fname);
762           unlock_trusttable ();
763           xfree (fprformatted);
764           xfree (nameformatted);
765           return err;
766         }
767       es_fputs (headerblurb, fp);
768       es_fclose (fp);
769     }
770   fp = es_fopen (fname, "a+,mode=-rw-r");
771   if (!fp)
772     {
773       err = gpg_error_from_syserror ();
774       log_error ("can't open '%s': %s\n", fname, gpg_strerror (err));
775       xfree (fname);
776       unlock_trusttable ();
777       xfree (fprformatted);
778       xfree (nameformatted);
779       return err;
780     }
781
782   /* Append the key. */
783   es_fputs ("\n# ", fp);
784   xfree (nameformatted);
785   nameformatted = reformat_name (name, "\n# ");
786   if (!nameformatted || strchr (name, '\n'))
787     {
788       /* Note that there should never be a LF in NAME but we better
789          play safe and print a sanitized version in this case.  */
790       es_write_sanitized (fp, name, strlen (name), NULL, NULL);
791     }
792   else
793     es_fputs (nameformatted, fp);
794   es_fprintf (fp, "\n%s%s %c%s\n", yes_i_trust?"":"!", fprformatted, flag,
795               flag == 'S'? " relax":"");
796   if (es_ferror (fp))
797     err = gpg_error_from_syserror ();
798
799   if (es_fclose (fp))
800     err = gpg_error_from_syserror ();
801
802   clear_trusttable ();
803   xfree (fname);
804   unlock_trusttable ();
805   xfree (fprformatted);
806   xfree (nameformatted);
807   if (!err)
808     bump_key_eventcounter ();
809   return err;
810 }
811
812
813 /* This function may be called to force reloading of the
814    trustlist.  */
815 void
816 agent_reload_trustlist (void)
817 {
818   /* All we need to do is to delete the trusttable.  At the next
819      access it will get re-read. */
820   lock_trusttable ();
821   clear_trusttable ();
822   unlock_trusttable ();
823   bump_key_eventcounter ();
824 }