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