Fix strerror vs. gpg_strerror usage.
[gnupg.git] / agent / trustlist.c
index 027dec0..8604d84 100644 (file)
@@ -1,5 +1,5 @@
 /* trustlist.c - Maintain the list of trusted keys
- * Copyright (C) 2002, 2004, 2006, 2007 Free Software Foundation, Inc.
+ * Copyright (C) 2002, 2004, 2006, 2007, 2009 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -26,7 +26,7 @@
 #include <assert.h>
 #include <unistd.h>
 #include <sys/stat.h>
-#include <pth.h>
+#include <npth.h>
 
 #include "agent.h"
 #include <assuan.h> /* fixme: need a way to avoid assuan calls here */
@@ -38,6 +38,7 @@ struct trustitem_s
 {
   struct
   {
+    int disabled:1;       /* This entry is disabled.  */
     int for_pgp:1;        /* Set by '*' or 'P' as first flag. */
     int for_smime:1;      /* Set by '*' or 'S' as first flag. */
     int relax:1;          /* Relax checking of root certificate
@@ -49,21 +50,23 @@ struct trustitem_s
 typedef struct trustitem_s trustitem_t;
 
 /* Malloced table and its allocated size with all trust items. */
-static trustitem_t *trusttable; 
-static size_t trusttablesize; 
+static trustitem_t *trusttable;
+static size_t trusttablesize;
 /* A mutex used to protect the table. */
-static pth_mutex_t trusttable_lock;
+static npth_mutex_t trusttable_lock;
 
 
 
 static const char headerblurb[] =
 "# This is the list of trusted keys.  Comment lines, like this one, as\n"
 "# well as empty lines are ignored.  Lines have a length limit but this\n"
-"# is not serious limitation as the format of the entries is fixed and\n"
+"# is not serious limitation as the format of the entries is fixed and\n"
 "# checked by gpg-agent.  A non-comment line starts with optional white\n"
-"# space, followed by the SHA-1 fingerpint in hex, optionally followed\n"
-"# by a flag character which my either be 'P', 'S' or '*'.  You should\n"
-"# give the gpg-agent a HUP after editing this file.\n"
+"# space, followed by the SHA-1 fingerpint in hex, followed by a flag\n"
+"# which may be one of 'P', 'S' or '*' and optionally followed by a list of\n"
+"# other flags.  The fingerprint may be prefixed with a '!' to mark the\n"
+"# key as not trusted.  You should give the gpg-agent a HUP or run the\n"
+"# command \"gpgconf --reload gpg-agent\" after changing this file.\n"
 "\n\n"
 "# Include the default trust list\n"
 "include-default\n"
@@ -78,11 +81,13 @@ void
 initialize_module_trustlist (void)
 {
   static int initialized;
+  int err;
 
   if (!initialized)
     {
-      if (!pth_mutex_init (&trusttable_lock))
-        log_fatal ("error initializing mutex: %s\n", strerror (errno));
+      err = npth_mutex_init (&trusttable_lock, NULL);
+      if (err)
+        log_fatal ("error initializing mutex: %s\n", strerror (err));
       initialized = 1;
     }
 }
@@ -93,27 +98,33 @@ initialize_module_trustlist (void)
 static void
 lock_trusttable (void)
 {
-  if (!pth_mutex_acquire (&trusttable_lock, 0, NULL))
-    log_fatal ("failed to acquire mutex in %s\n", __FILE__);
+  int err;
+
+  err = npth_mutex_lock (&trusttable_lock);
+  if (err)
+    log_fatal ("failed to acquire mutex in %s: %s\n", __FILE__, strerror (err));
 }
 
 static void
 unlock_trusttable (void)
 {
-  if (!pth_mutex_release (&trusttable_lock))
-    log_fatal ("failed to release mutex in %s\n", __FILE__);
+  int err;
+
+  err = npth_mutex_unlock (&trusttable_lock);
+  if (err)
+    log_fatal ("failed to release mutex in %s: %s\n", __FILE__, strerror (err));
 }
 
 
 
 static gpg_error_t
 read_one_trustfile (const char *fname, int allow_include,
-                    trustitem_t **addr_of_table, 
+                    trustitem_t **addr_of_table,
                     size_t *addr_of_tablesize,
                     int *addr_of_tableidx)
 {
   gpg_error_t err = 0;
-  FILE *fp;
+  estream_t fp;
   int n, c;
   char *p, line[256];
   trustitem_t *table, *ti;
@@ -125,7 +136,7 @@ read_one_trustfile (const char *fname, int allow_include,
   tablesize = *addr_of_tablesize;
   tableidx = *addr_of_tableidx;
 
-  fp = fopen (fname, "r");
+  fp = es_fopen (fname, "r");
   if (!fp)
     {
       err = gpg_error_from_syserror ();
@@ -133,14 +144,15 @@ read_one_trustfile (const char *fname, int allow_include,
       goto leave;
     }
 
-  while (fgets (line, DIM(line)-1, fp))
+  while (es_fgets (line, DIM(line)-1, fp))
     {
       lnr++;
-      
-      if (!*line || line[strlen(line)-1] != '\n')
+
+      n = strlen (line);
+      if (!n || line[n-1] != '\n')
         {
           /* Eat until end of line. */
-          while ( (c=getc (fp)) != EOF && c != '\n')
+          while ( (c=es_getc (fp)) != EOF && c != '\n')
             ;
           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
                            : GPG_ERR_INCOMPLETE_LINE);
@@ -148,14 +160,16 @@ read_one_trustfile (const char *fname, int allow_include,
                      fname, lnr, gpg_strerror (err));
           continue;
         }
-      line[strlen(line)-1] = 0; /* Chop the LF. */
-      
+      line[--n] = 0; /* Chop the LF. */
+      if (n && line[n-1] == '\r')
+        line[--n] = 0; /* Chop an optional CR. */
+
       /* Allow for empty lines and spaces */
       for (p=line; spacep (p); p++)
         ;
       if (!*p || *p == '#')
         continue;
-  
+
       if (!strncmp (p, "include-default", 15)
           && (!p[15] || spacep (p+15)))
         {
@@ -188,7 +202,7 @@ read_one_trustfile (const char *fname, int allow_include,
                 err = err2;
             }
           xfree (etcname);
-          
+
           continue;
         }
 
@@ -196,7 +210,7 @@ read_one_trustfile (const char *fname, int allow_include,
         {
           trustitem_t *tmp;
           size_t tmplen;
-          
+
           tmplen = tablesize + 20;
           tmp = xtryrealloc (table, tmplen * sizeof *table);
           if (!tmp)
@@ -210,18 +224,26 @@ read_one_trustfile (const char *fname, int allow_include,
 
       ti = table + tableidx;
 
+      memset (&ti->flags, 0, sizeof ti->flags);
+      if (*p == '!')
+        {
+          ti->flags.disabled = 1;
+          p++;
+          while (spacep (p))
+            p++;
+        }
+
       n = hexcolon2bin (p, ti->fpr, 20);
       if (n < 0)
         {
           log_error (_("bad fingerprint in `%s', line %d\n"), fname, lnr);
-          err = gpg_error (GPG_ERR_BAD_DATA); 
+          err = gpg_error (GPG_ERR_BAD_DATA);
           continue;
         }
       p += n;
       for (; spacep (p); p++)
         ;
-      
-      memset (&ti->flags, 0, sizeof ti->flags);
+
       /* Process the first flag which needs to be the first for
          backward compatibility. */
       if (!*p || *p == '*' )
@@ -277,7 +299,7 @@ read_one_trustfile (const char *fname, int allow_include,
         }
       tableidx++;
     }
-  if ( !err && !feof (fp) )
+  if ( !err && !es_feof (fp) )
     {
       err = gpg_error_from_syserror ();
       log_error (_("error reading `%s', line %d: %s\n"),
@@ -285,8 +307,7 @@ read_one_trustfile (const char *fname, int allow_include,
     }
 
  leave:
-  if (fp)
-    fclose (fp);
+  es_fclose (fp);
   *addr_of_table = table;
   *addr_of_tablesize = tablesize;
   *addr_of_tableidx = tableidx;
@@ -349,13 +370,14 @@ read_trustfiles (void)
   ti = xtryrealloc (table, (tableidx?tableidx:1) * sizeof *table);
   if (!ti)
     {
+      err = gpg_error_from_syserror ();
       xfree (table);
       return err;
     }
 
   lock_trusttable ();
   xfree (trusttable);
-  trusttable = table;
+  trusttable = ti;
   trusttablesize = tableidx;
   unlock_trusttable ();
   return 0;
@@ -365,14 +387,17 @@ read_trustfiles (void)
 
 /* Check whether the given fpr is in our trustdb.  We expect FPR to be
    an all uppercase hexstring of 40 characters. */
-gpg_error_t 
-agent_istrusted (ctrl_t ctrl, const char *fpr)
+gpg_error_t
+agent_istrusted (ctrl_t ctrl, const char *fpr, int *r_disabled)
 {
   gpg_error_t err;
   trustitem_t *ti;
   size_t len;
   unsigned char fprbin[20];
 
+  if (r_disabled)
+    *r_disabled = 0;
+
   if ( hexcolon2bin (fpr, fprbin, 20) < 0 )
     return gpg_error (GPG_ERR_INV_VALUE);
 
@@ -391,10 +416,13 @@ agent_istrusted (ctrl_t ctrl, const char *fpr)
       for (ti=trusttable, len = trusttablesize; len; ti++, len--)
         if (!memcmp (ti->fpr, fprbin, 20))
           {
+            if (ti->flags.disabled && r_disabled)
+              *r_disabled = 1;
+
             if (ti->flags.relax)
               {
                 err = agent_write_status (ctrl,
-                                          "TRUSTLISTFLAG", "relax", 
+                                          "TRUSTLISTFLAG", "relax",
                                           NULL);
                 if (err)
                   return err;
@@ -402,12 +430,12 @@ agent_istrusted (ctrl_t ctrl, const char *fpr)
             else if (ti->flags.cm)
               {
                 err = agent_write_status (ctrl,
-                                          "TRUSTLISTFLAG", "cm", 
+                                          "TRUSTLISTFLAG", "cm",
                                           NULL);
                 if (err)
                   return err;
               }
-            return 0; /* Trusted. */
+            return ti->flags.disabled? gpg_error (GPG_ERR_NOT_TRUSTED) : 0;
           }
     }
   return gpg_error (GPG_ERR_NOT_TRUSTED);
@@ -415,7 +443,7 @@ agent_istrusted (ctrl_t ctrl, const char *fpr)
 
 
 /* Write all trust entries to FP. */
-gpg_error_t 
+gpg_error_t
 agent_listtrusted (void *assuan_context)
 {
   trustitem_t *ti;
@@ -440,6 +468,8 @@ agent_listtrusted (void *assuan_context)
       lock_trusttable ();
       for (ti=trusttable, len = trusttablesize; len; ti++, len--)
         {
+          if (ti->flags.disabled)
+            continue;
           bin2hex (ti->fpr, 20, key);
           key[40] = ' ';
           key[41] = ((ti->flags.for_smime && ti->flags.for_pgp)? '*'
@@ -485,21 +515,59 @@ insert_colons (const char *string)
 }
 
 
+/* To pretty print DNs in the Pinentry, we replace slashes by
+   REPLSTRING.  The caller needs to free the returned string.  NULL is
+   returned on error with ERRNO set.  */
+static char *
+reformat_name (const char *name, const char *replstring)
+{
+  const char *s;
+  char *newname;
+  char *d;
+  size_t count;
+  size_t replstringlen = strlen (replstring);
+
+  /* If the name does not start with a slash it is not a preformatted
+     DN and thus we don't bother to reformat it.  */
+  if (*name != '/')
+    return xtrystrdup (name);
+
+  /* Count the names.  Note that a slash contained in a DN part is
+     expected to be C style escaped and thus the slashes we see here
+     are the actual part delimiters.  */
+  for (s=name+1, count=0; *s; s++)
+    if (*s == '/')
+      count++;
+  newname = xtrymalloc (strlen (name) + count*replstringlen + 1);
+  if (!newname)
+    return NULL;
+  for (s=name+1, d=newname; *s; s++)
+    if (*s == '/')
+      d = stpcpy (d, replstring);
+    else
+      *d++ = *s;
+  *d = 0;
+  return newname;
+}
+
+
 /* Insert the given fpr into our trustdb.  We expect FPR to be an all
    uppercase hexstring of 40 characters. FLAG is either 'P' or 'C'.
    This function does first check whether that key has already been put
    into the trustdb and returns success in this case.  Before a FPR
    actually gets inserted, the user is asked by means of the Pinentry
-   whether this is actual wants he want to do.  */
+   whether this is actual want he wants to do.  */
 gpg_error_t
 agent_marktrusted (ctrl_t ctrl, const char *name, const char *fpr, int flag)
 {
   gpg_error_t err = 0;
   char *desc;
   char *fname;
-  FILE *fp;
+  estream_t fp;
   char *fprformatted;
-
+  char *nameformatted;
+  int is_disabled;
+  int yes_i_trust;
 
   /* Check whether we are at all allowed to modify the trustlist.
      This is useful so that the trustlist may be a symlink to a global
@@ -511,10 +579,10 @@ agent_marktrusted (ctrl_t ctrl, const char *name, const char *fpr, int flag)
     {
       xfree (fname);
       return gpg_error (GPG_ERR_EPERM);
-    }    
+    }
   xfree (fname);
 
-  if (!agent_istrusted (ctrl, fpr))
+  if (!agent_istrusted (ctrl, fpr, &is_disabled))
     {
       return 0; /* We already got this fingerprint.  Silently return
                    success. */
@@ -524,47 +592,22 @@ agent_marktrusted (ctrl_t ctrl, const char *name, const char *fpr, int flag)
   if (!opt.allow_mark_trusted)
     return gpg_error (GPG_ERR_NOT_SUPPORTED);
 
-  /* Insert a new one. */
-  fprformatted = insert_colons (fpr);
-  if (!fprformatted)
-    return out_of_core ();
-  desc = xtryasprintf (
-                /* TRANSLATORS: This prompt is shown by the Pinentry
-                   and has one special property: A "%%0A" is used by
-                   Pinentry to insert a line break.  The double
-                   percent sign is actually needed because it is also
-                   a printf format string.  If you need to insert a
-                   plain % sign, you need to encode it as "%%25".  The
-                   second "%s" gets replaced by a hexdecimal
-                   fingerprint string whereas the first one receives
-                   the name as stored in the certificate. */
-                _("Please verify that the certificate identified as:%%0A"
-                  "  \"%s\"%%0A"
-                  "has the fingerprint:%%0A"
-                  "  %s"), name, fprformatted);
-  if (!desc)
-    {
-      xfree (fprformatted);
-      return out_of_core ();
-    }
-
-  /* TRANSLATORS: "Correct" is the label of a button and intended to
-     be hit if the fingerprint matches the one of the CA.  The other
-     button is "the default "Cancel" of the Pinentry. */
-  err = agent_get_confirmation (ctrl, desc, _("Correct"), NULL);
-  xfree (desc);
-  /* If the user did not confirmed this, we return cancel here so that
-     gpgsm may stop asking further questions.  We won't do this for
-     the second question of course. */
-  if (err)
+  if (is_disabled)
     {
-      xfree (fprformatted);
-      return (gpg_err_code (err) == GPG_ERR_NOT_CONFIRMED ? 
-              gpg_err_make (gpg_err_source (err), GPG_ERR_CANCELED) : err);
+      /* There is an disabled entry in the trustlist.  Return an error
+         so that the user won't be asked again for that one.  Changing
+         this flag with the integrated marktrusted feature is and will
+         not be made possible.  */
+      return gpg_error (GPG_ERR_NOT_TRUSTED);
     }
 
 
+  /* Insert a new one. */
+  nameformatted = reformat_name (name, "%0A   ");
+  if (!nameformatted)
+    return gpg_error_from_syserror ();
 
+  /* First a general question whether this is trusted.  */
   desc = xtryasprintf (
                 /* TRANSLATORS: This prompt is shown by the Pinentry
                    and has one special property: A "%%0A" is used by
@@ -572,43 +615,94 @@ agent_marktrusted (ctrl_t ctrl, const char *name, const char *fpr, int flag)
                    percent sign is actually needed because it is also
                    a printf format string.  If you need to insert a
                    plain % sign, you need to encode it as "%%25".  The
-                   "%s" gets replaced by the name as store in the
+                   "%s" gets replaced by the name as stored in the
                    certificate. */
                 _("Do you ultimately trust%%0A"
                   "  \"%s\"%%0A"
                   "to correctly certify user certificates?"),
-                name);
+                nameformatted);
   if (!desc)
     {
-      xfree (fprformatted);
+      xfree (nameformatted);
       return out_of_core ();
     }
-
-  err = agent_get_confirmation (ctrl, desc, _("Yes"), _("No"));
+  err = agent_get_confirmation (ctrl, desc, _("Yes"), _("No"), 1);
   xfree (desc);
-  if (err)
+  if (!err)
+    yes_i_trust = 1;
+  else if (gpg_err_code (err) == GPG_ERR_NOT_CONFIRMED)
+    yes_i_trust = 0;
+  else
     {
-      xfree (fprformatted);
+      xfree (nameformatted);
       return err;
     }
 
+
+  fprformatted = insert_colons (fpr);
+  if (!fprformatted)
+    {
+      xfree (nameformatted);
+      return out_of_core ();
+    }
+
+  /* If the user trusts this certificate he has to verify the
+     fingerprint of course.  */
+  if (yes_i_trust)
+    {
+      desc = xtryasprintf
+        (
+         /* TRANSLATORS: This prompt is shown by the Pinentry and has
+            one special property: A "%%0A" is used by Pinentry to
+            insert a line break.  The double percent sign is actually
+            needed because it is also a printf format string.  If you
+            need to insert a plain % sign, you need to encode it as
+            "%%25".  The second "%s" gets replaced by a hexdecimal
+            fingerprint string whereas the first one receives the name
+            as stored in the certificate. */
+         _("Please verify that the certificate identified as:%%0A"
+           "  \"%s\"%%0A"
+           "has the fingerprint:%%0A"
+           "  %s"), nameformatted, fprformatted);
+      if (!desc)
+        {
+          xfree (fprformatted);
+          xfree (nameformatted);
+          return out_of_core ();
+        }
+
+      /* TRANSLATORS: "Correct" is the label of a button and intended
+         to be hit if the fingerprint matches the one of the CA.  The
+         other button is "the default "Cancel" of the Pinentry. */
+      err = agent_get_confirmation (ctrl, desc, _("Correct"), _("Wrong"), 1);
+      xfree (desc);
+      if (gpg_err_code (err) == GPG_ERR_NOT_CONFIRMED)
+        yes_i_trust = 0;
+      else if (err)
+        {
+          xfree (fprformatted);
+          xfree (nameformatted);
+          return err;
+        }
+    }
+
+
   /* Now check again to avoid duplicates.  We take the lock to make
-     sure that nobody else plays with our file.  Frankly we don't work
-     with the trusttable but using this lock is just fine for our
-     purpose.  */
+     sure that nobody else plays with our file and force a reread.  */
   lock_trusttable ();
-  if (!agent_istrusted (ctrl, fpr))
+  agent_reload_trustlist ();
+  if (!agent_istrusted (ctrl, fpr, &is_disabled) || is_disabled)
     {
       unlock_trusttable ();
       xfree (fprformatted);
-      return 0; 
+      xfree (nameformatted);
+      return is_disabled? gpg_error (GPG_ERR_NOT_TRUSTED) : 0;
     }
 
-
   fname = make_filename (opt.homedir, "trustlist.txt", NULL);
   if ( access (fname, F_OK) && errno == ENOENT)
     {
-      fp = fopen (fname, "wx"); /* Warning: "x" is a GNU extension. */
+      fp = es_fopen (fname, "wx,mode=-rw-r");
       if (!fp)
         {
           err = gpg_error_from_syserror ();
@@ -616,12 +710,13 @@ agent_marktrusted (ctrl_t ctrl, const char *name, const char *fpr, int flag)
           xfree (fname);
           unlock_trusttable ();
           xfree (fprformatted);
+          xfree (nameformatted);
           return err;
         }
-      fputs (headerblurb, fp);
-      fclose (fp);
+      es_fputs (headerblurb, fp);
+      es_fclose (fp);
     }
-  fp = fopen (fname, "a+");
+  fp = es_fopen (fname, "a+,mode=-rw-r");
   if (!fp)
     {
       err = gpg_error_from_syserror ();
@@ -629,24 +724,34 @@ agent_marktrusted (ctrl_t ctrl, const char *name, const char *fpr, int flag)
       xfree (fname);
       unlock_trusttable ();
       xfree (fprformatted);
+      xfree (nameformatted);
       return err;
     }
 
   /* Append the key. */
-  fputs ("\n# ", fp);
-  print_sanitized_string (fp, name, 0);
-  fprintf (fp, "\n%s %c\n", fprformatted, flag);
-  if (ferror (fp))
+  es_fputs ("\n# ", fp);
+  xfree (nameformatted);
+  nameformatted = reformat_name (name, "\n# ");
+  if (!nameformatted || strchr (name, '\n'))
+    {
+      /* Note that there should never be a LF in NAME but we better
+         play safe and print a sanitized version in this case.  */
+      es_write_sanitized (fp, name, strlen (name), NULL, NULL);
+    }
+  else
+    es_fputs (nameformatted, fp);
+  es_fprintf (fp, "\n%s%s %c\n", yes_i_trust?"":"!", fprformatted, flag);
+  if (es_ferror (fp))
     err = gpg_error_from_syserror ();
-  
-  if (fclose (fp))
+
+  if (es_fclose (fp))
     err = gpg_error_from_syserror ();
 
-  if (!err)
-    agent_reload_trustlist ();
+  agent_reload_trustlist ();
   xfree (fname);
   unlock_trusttable ();
   xfree (fprformatted);
+  xfree (nameformatted);
   return err;
 }