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 (opt.homedir, "trustlist.txt", NULL);
 348   if ( access (fname, F_OK) )
 349     {
 350       if ( errno == ENOENT )
 351         ; /* Silently ignore a non-existing trustfile.  */
 352       else
 353         {
 354           err = gpg_error_from_syserror ();
 355           log_error (_("error opening '%s': %s\n"), fname, gpg_strerror (err));
 356         }
 357       xfree (fname);
 358       fname = make_filename (gnupg_sysconfdir (), "trustlist.txt", NULL);
 359       allow_include = 0;
 360     }
 361   err = read_one_trustfile (fname, allow_include,
 362                             &table, &tablesize, &tableidx);
 363   xfree (fname);
 364
 365   if (err)
 366     {
 367       xfree (table);
 368       if (gpg_err_code (err) == GPG_ERR_ENOENT)
 369         {
 370           /* Take a missing trustlist as an empty one.  */
 371           clear_trusttable ();
 372           err = 0;
 373         }
 374       return err;
 375     }
 376
 377   /* Fixme: we should drop duplicates and sort the table. */
 378   ti = xtryrealloc (table, (tableidx?tableidx:1) * sizeof *table);
 379   if (!ti)
 380     {
 381       err = gpg_error_from_syserror ();
 382       xfree (table);
 383       return err;
 384     }
 385
 386   /* Replace the trusttable.  */
 387   xfree (trusttable);
 388   trusttable = ti;
 389   trusttablesize = tableidx;
 390   return 0;
 391 }
 392
 393
 394 /* Check whether the given fpr is in our trustdb.  We expect FPR to be
 395    an all uppercase hexstring of 40 characters.  If ALREADY_LOCKED is
 396    true the function assumes that the trusttable is already locked. */
 397 static gpg_error_t
 398 istrusted_internal (ctrl_t ctrl, const char *fpr, int *r_disabled,
 399                     int already_locked)
 400 {
 401   gpg_error_t err;
 402   int locked = already_locked;
 403   trustitem_t *ti;
 404   size_t len;
 405   unsigned char fprbin[20];
 406
 407   if (r_disabled)
 408     *r_disabled = 0;
 409
 410   if ( hexcolon2bin (fpr, fprbin, 20) < 0 )
 411     {
 412       err = gpg_error (GPG_ERR_INV_VALUE);
 413       goto leave;
 414     }
 415
 416   if (!already_locked)
 417     {
 418       lock_trusttable ();
 419       locked = 1;
 420     }
 421
 422   if (!trusttable)
 423     {
 424       err = read_trustfiles ();
 425       if (err)
 426         {
 427           log_error (_("error reading list of trusted root certificates\n"));
 428           goto leave;
 429         }
 430     }
 431
 432   if (trusttable)
 433     {
 434       for (ti=trusttable, len = trusttablesize; len; ti++, len--)
 435         if (!memcmp (ti->fpr, fprbin, 20))
 436           {
 437             if (ti->flags.disabled && r_disabled)
 438               *r_disabled = 1;
 439
 440             /* Print status messages only if we have not been called
 441                in a locked state.  */
 442             if (already_locked)
 443               ;
 444             else if (ti->flags.relax)
 445               {
 446                 unlock_trusttable ();
 447                 locked = 0;
 448                 err = agent_write_status (ctrl, "TRUSTLISTFLAG", "relax", NULL);
 449               }
 450             else if (ti->flags.cm)
 451               {
 452                 unlock_trusttable ();
 453                 locked = 0;
 454                 err = agent_write_status (ctrl, "TRUSTLISTFLAG", "cm", NULL);
 455               }
 456
 457             if (!err)
 458               err = ti->flags.disabled? gpg_error (GPG_ERR_NOT_TRUSTED) : 0;
 459             goto leave;
 460           }
 461     }
 462   err = gpg_error (GPG_ERR_NOT_TRUSTED);
 463
 464  leave:
 465   if (locked && !already_locked)
 466     unlock_trusttable ();
 467   return err;
 468 }
 469
 470
 471 /* Check whether the given fpr is in our trustdb.  We expect FPR to be
 472    an all uppercase hexstring of 40 characters.  */
 473 gpg_error_t
 474 agent_istrusted (ctrl_t ctrl, const char *fpr, int *r_disabled)
 475 {
 476   return istrusted_internal (ctrl, fpr, r_disabled, 0);
 477 }
 478
 479
 480 /* Write all trust entries to FP. */
 481 gpg_error_t
 482 agent_listtrusted (void *assuan_context)
 483 {
 484   trustitem_t *ti;
 485   char key[51];
 486   gpg_error_t err;
 487   size_t len;
 488
 489   lock_trusttable ();
 490   if (!trusttable)
 491     {
 492       err = read_trustfiles ();
 493       if (err)
 494         {
 495           unlock_trusttable ();
 496           log_error (_("error reading list of trusted root certificates\n"));
 497           return err;
 498         }
 499     }
 500
 501   if (trusttable)
 502     {
 503       for (ti=trusttable, len = trusttablesize; len; ti++, len--)
 504         {
 505           if (ti->flags.disabled)
 506             continue;
 507           bin2hex (ti->fpr, 20, key);
 508           key[40] = ' ';
 509           key[41] = ((ti->flags.for_smime && ti->flags.for_pgp)? '*'
 510                      : ti->flags.for_smime? 'S': ti->flags.for_pgp? 'P':' ');
 511           key[42] = '\n';
 512           assuan_send_data (assuan_context, key, 43);
 513           assuan_send_data (assuan_context, NULL, 0); /* flush */
 514         }
 515     }
 516
 517   unlock_trusttable ();
 518   return 0;
 519 }
 520
 521
 522 /* Create a copy of string with colons inserted after each two bytes.
 523    Caller needs to release the string.  In case of a memory failure,
 524    NULL is returned.  */
 525 static char *
 526 insert_colons (const char *string)
 527 {
 528   char *buffer, *p;
 529   size_t n = strlen (string);
 530   size_t nnew = n + (n+1)/2;
 531
 532   p = buffer = xtrymalloc ( nnew + 1 );
 533   if (!buffer)
 534     return NULL;
 535   while (*string)
 536     {
 537       *p++ = *string++;
 538       if (*string)
 539         {
 540           *p++ = *string++;
 541           if (*string)
 542             *p++ = ':';
 543         }
 544     }
 545   *p = 0;
 546   assert (strlen (buffer) <= nnew);
 547
 548   return buffer;
 549 }
 550
 551
 552 /* To pretty print DNs in the Pinentry, we replace slashes by
 553    REPLSTRING.  The caller needs to free the returned string.  NULL is
 554    returned on error with ERRNO set.  */
 555 static char *
 556 reformat_name (const char *name, const char *replstring)
 557 {
 558   const char *s;
 559   char *newname;
 560   char *d;
 561   size_t count;
 562   size_t replstringlen = strlen (replstring);
 563
 564   /* If the name does not start with a slash it is not a preformatted
 565      DN and thus we don't bother to reformat it.  */
 566   if (*name != '/')
 567     return xtrystrdup (name);
 568
 569   /* Count the names.  Note that a slash contained in a DN part is
 570      expected to be C style escaped and thus the slashes we see here
 571      are the actual part delimiters.  */
 572   for (s=name+1, count=0; *s; s++)
 573     if (*s == '/')
 574       count++;
 575   newname = xtrymalloc (strlen (name) + count*replstringlen + 1);
 576   if (!newname)
 577     return NULL;
 578   for (s=name+1, d=newname; *s; s++)
 579     if (*s == '/')
 580       d = stpcpy (d, replstring);
 581     else
 582       *d++ = *s;
 583   *d = 0;
 584   return newname;
 585 }
 586
 587
 588 /* Insert the given fpr into our trustdb.  We expect FPR to be an all
 589    uppercase hexstring of 40 characters. FLAG is either 'P' or 'C'.
 590    This function does first check whether that key has already been
 591    put into the trustdb and returns success in this case.  Before a
 592    FPR actually gets inserted, the user is asked by means of the
 593    Pinentry whether this is actual what he wants to do.  */
 594 gpg_error_t
 595 agent_marktrusted (ctrl_t ctrl, const char *name, const char *fpr, int flag)
 596 {
 597   gpg_error_t err = 0;
 598   char *desc;
 599   char *fname;
 600   estream_t fp;
 601   char *fprformatted;
 602   char *nameformatted;
 603   int is_disabled;
 604   int yes_i_trust;
 605
 606   /* Check whether we are at all allowed to modify the trustlist.
 607      This is useful so that the trustlist may be a symlink to a global
 608      trustlist with only admin priviliges to modify it.  Of course
 609      this is not a secure way of denying access, but it avoids the
 610      usual clicking on an Okay button most users are used to. */
 611   fname = make_filename (opt.homedir, "trustlist.txt", NULL);
 612   if ( access (fname, W_OK) && errno != ENOENT)
 613     {
 614       xfree (fname);
 615       return gpg_error (GPG_ERR_EPERM);
 616     }
 617   xfree (fname);
 618
 619   if (!agent_istrusted (ctrl, fpr, &is_disabled))
 620     {
 621       return 0; /* We already got this fingerprint.  Silently return
 622                    success. */
 623     }
 624
 625   /* This feature must explicitly been enabled. */
 626   if (!opt.allow_mark_trusted)
 627     return gpg_error (GPG_ERR_NOT_SUPPORTED);
 628
 629   if (is_disabled)
 630     {
 631       /* There is an disabled entry in the trustlist.  Return an error
 632          so that the user won't be asked again for that one.  Changing
 633          this flag with the integrated marktrusted feature is and will
 634          not be made possible.  */
 635       return gpg_error (GPG_ERR_NOT_TRUSTED);
 636     }
 637
 638
 639   /* Insert a new one. */
 640   nameformatted = reformat_name (name, "%0A   ");
 641   if (!nameformatted)
 642     return gpg_error_from_syserror ();
 643
 644   /* First a general question whether this is trusted.  */
 645   desc = xtryasprintf (
 646                 /* TRANSLATORS: This prompt is shown by the Pinentry
 647                    and has one special property: A "%%0A" is used by
 648                    Pinentry to insert a line break.  The double
 649                    percent sign is actually needed because it is also
 650                    a printf format string.  If you need to insert a
 651                    plain % sign, you need to encode it as "%%25".  The
 652                    "%s" gets replaced by the name as stored in the
 653                    certificate. */
 654                 L_("Do you ultimately trust%%0A"
 655                    "  \"%s\"%%0A"
 656                    "to correctly certify user certificates?"),
 657                 nameformatted);
 658   if (!desc)
 659     {
 660       xfree (nameformatted);
 661       return out_of_core ();
 662     }
 663   err = agent_get_confirmation (ctrl, desc, L_("Yes"), L_("No"), 1);
 664   xfree (desc);
 665   if (!err)
 666     yes_i_trust = 1;
 667   else if (gpg_err_code (err) == GPG_ERR_NOT_CONFIRMED)
 668     yes_i_trust = 0;
 669   else
 670     {
 671       xfree (nameformatted);
 672       return err;
 673     }
 674
 675
 676   fprformatted = insert_colons (fpr);
 677   if (!fprformatted)
 678     {
 679       xfree (nameformatted);
 680       return out_of_core ();
 681     }
 682
 683   /* If the user trusts this certificate he has to verify the
 684      fingerprint of course.  */
 685   if (yes_i_trust)
 686     {
 687       desc = xtryasprintf
 688         (
 689          /* TRANSLATORS: This prompt is shown by the Pinentry and has
 690             one special property: A "%%0A" is used by Pinentry to
 691             insert a line break.  The double percent sign is actually
 692             needed because it is also a printf format string.  If you
 693             need to insert a plain % sign, you need to encode it as
 694             "%%25".  The second "%s" gets replaced by a hexdecimal
 695             fingerprint string whereas the first one receives the name
 696             as stored in the certificate. */
 697          L_("Please verify that the certificate identified as:%%0A"
 698             "  \"%s\"%%0A"
 699             "has the fingerprint:%%0A"
 700             "  %s"), nameformatted, fprformatted);
 701       if (!desc)
 702         {
 703           xfree (fprformatted);
 704           xfree (nameformatted);
 705           return out_of_core ();
 706         }
 707
 708       /* TRANSLATORS: "Correct" is the label of a button and intended
 709          to be hit if the fingerprint matches the one of the CA.  The
 710          other button is "the default "Cancel" of the Pinentry. */
 711       err = agent_get_confirmation (ctrl, desc, L_("Correct"), L_("Wrong"), 1);
 712       xfree (desc);
 713       if (gpg_err_code (err) == GPG_ERR_NOT_CONFIRMED)
 714         yes_i_trust = 0;
 715       else if (err)
 716         {
 717           xfree (fprformatted);
 718           xfree (nameformatted);
 719           return err;
 720         }
 721     }
 722
 723
 724   /* Now check again to avoid duplicates.  We take the lock to make
 725      sure that nobody else plays with our file and force a reread.  */
 726   lock_trusttable ();
 727   clear_trusttable ();
 728   if (!istrusted_internal (ctrl, fpr, &is_disabled, 1) || is_disabled)
 729     {
 730       unlock_trusttable ();
 731       xfree (fprformatted);
 732       xfree (nameformatted);
 733       return is_disabled? gpg_error (GPG_ERR_NOT_TRUSTED) : 0;
 734     }
 735
 736   fname = make_filename (opt.homedir, "trustlist.txt", NULL);
 737   if ( access (fname, F_OK) && errno == ENOENT)
 738     {
 739       fp = es_fopen (fname, "wx,mode=-rw-r");
 740       if (!fp)
 741         {
 742           err = gpg_error_from_syserror ();
 743           log_error ("can't create '%s': %s\n", fname, gpg_strerror (err));
 744           xfree (fname);
 745           unlock_trusttable ();
 746           xfree (fprformatted);
 747           xfree (nameformatted);
 748           return err;
 749         }
 750       es_fputs (headerblurb, fp);
 751       es_fclose (fp);
 752     }
 753   fp = es_fopen (fname, "a+,mode=-rw-r");
 754   if (!fp)
 755     {
 756       err = gpg_error_from_syserror ();
 757       log_error ("can't open '%s': %s\n", fname, gpg_strerror (err));
 758       xfree (fname);
 759       unlock_trusttable ();
 760       xfree (fprformatted);
 761       xfree (nameformatted);
 762       return err;
 763     }
 764
 765   /* Append the key. */
 766   es_fputs ("\n# ", fp);
 767   xfree (nameformatted);
 768   nameformatted = reformat_name (name, "\n# ");
 769   if (!nameformatted || strchr (name, '\n'))
 770     {
 771       /* Note that there should never be a LF in NAME but we better
 772          play safe and print a sanitized version in this case.  */
 773       es_write_sanitized (fp, name, strlen (name), NULL, NULL);
 774     }
 775   else
 776     es_fputs (nameformatted, fp);
 777   es_fprintf (fp, "\n%s%s %c%s\n", yes_i_trust?"":"!", fprformatted, flag,
 778               flag == 'S'? " relax":"");
 779   if (es_ferror (fp))
 780     err = gpg_error_from_syserror ();
 781
 782   if (es_fclose (fp))
 783     err = gpg_error_from_syserror ();
 784
 785   clear_trusttable ();
 786   xfree (fname);
 787   unlock_trusttable ();
 788   xfree (fprformatted);
 789   xfree (nameformatted);
 790   if (!err)
 791     bump_key_eventcounter ();
 792   return err;
 793 }
 794
 795
 796 /* This function may be called to force reloading of the
 797    trustlist.  */
 798 void
 799 agent_reload_trustlist (void)
 800 {
 801   /* All we need to do is to delete the trusttable.  At the next
 802      access it will get re-read. */
 803   lock_trusttable ();
 804   clear_trusttable ();
 805   unlock_trusttable ();
 806   bump_key_eventcounter ();
 807 }