* keyserver.c (keyserver_spawn): Don't mess about with the $PATH.
[gnupg.git] / g10 / trustdb.c
index ab3b125..d69b872 100644 (file)
@@ -254,7 +254,7 @@ add_utk (u32 *kid)
   k->next = utk_list;
   utk_list = k;
   if( opt.verbose > 1 )
-    log_info(_("key %08lX: accepted as trusted key\n"), (ulong)kid[1]);
+    log_info(_("key %s: accepted as trusted key\n"), keystr(kid));
   return 1;
 }
 
@@ -292,8 +292,8 @@ verify_own_keys(void)
             fprlen = (!fpr[16] && !fpr[17] && !fpr[18] && !fpr[19])? 16:20;
             keyid_from_fingerprint (fpr, fprlen, kid);
             if (!add_utk (kid))
-                log_info(_("key %08lX occurs more than once in the trustdb\n"),
-                            (ulong)kid[1]);
+             log_info(_("key %s occurs more than once in the trustdb\n"),
+                      keystr(kid));
         }
     }
 
@@ -306,22 +306,21 @@ verify_own_keys(void)
 
           memset (&pk, 0, sizeof pk);
           rc = get_pubkey (&pk, k->kid);
-          if (rc) {
-            log_info(_("key %08lX: no public key for trusted key - skipped\n"),
-                     (ulong)k->kid[1] );
-          }
-          else {
-            update_ownertrust (&pk,
-                               ((get_ownertrust (&pk) & ~TRUST_MASK)
-                                | TRUST_ULTIMATE ));
-            release_public_key_parts (&pk);
-          }
-          log_info (_("key %08lX marked as ultimately trusted\n"),
-                    (ulong)k->kid[1]);
+          if (rc)
+           log_info(_("key %s: no public key for trusted key - skipped\n"),
+                    keystr(k->kid));
+          else
+           {
+             update_ownertrust (&pk,
+                                ((get_ownertrust (&pk) & ~TRUST_MASK)
+                                 | TRUST_ULTIMATE ));
+             release_public_key_parts (&pk);
+           }
+
+          log_info (_("key %s marked as ultimately trusted\n"),keystr(k->kid));
         }
     }
 
-
   /* release the helper table table */
   release_key_items (user_utk_list);
   user_utk_list = NULL;
@@ -392,6 +391,7 @@ trust_model_string(void)
     case TM_PGP:      return "PGP";
     case TM_EXTERNAL: return "external";
     case TM_ALWAYS:   return "always";
+    case TM_DIRECT:   return "direct";
     default:          return "unknown";
     }
 }
@@ -489,6 +489,37 @@ trust_letter (unsigned int value)
     }
 }
 
+/* NOTE TO TRANSLATOR: these strings are similar to those in
+   trust_value_to_string(), but are a fixed length.  This is needed to
+   make attractive information listings where columns line up
+   properly.  The value "10" should be the length of the strings you
+   choose to translate to.  This is the length in printable columns.
+   It gets passed to atoi() so everything after the number is
+   essentially a comment and need not be translated.  Either key and
+   uid are both NULL, or neither are NULL. */
+const char *
+uid_trust_string_fixed(PKT_public_key *key,PKT_user_id *uid)
+{
+  if(!key && !uid)
+    return _("10 translator see trustdb.c:uid_trust_string_fixed");
+  else if(uid->is_revoked || (key && key->is_revoked))
+    return                         _("[ revoked]");
+  else if(uid->is_expired)
+    return                         _("[ expired]");
+  else if(key)
+    switch(get_validity(key,uid)&TRUST_MASK)
+      {
+      case TRUST_UNKNOWN:   return _("[ unknown]");
+      case TRUST_EXPIRED:   return _("[ expired]");
+      case TRUST_UNDEFINED: return _("[  undef ]");
+      case TRUST_MARGINAL:  return _("[marginal]");
+      case TRUST_FULLY:     return _("[  full  ]");
+      case TRUST_ULTIMATE:  return _("[ultimate]");
+      }
+
+  return "err";
+}
+
 /* The strings here are similar to those in
    pkclist.c:do_edit_ownertrust() */
 const char *
@@ -557,7 +588,7 @@ check_trustdb ()
       validate_keys (0);
     }
   else
-    log_info (_("no need for a trustdb check with \"%s\" trust model\n"),
+    log_info (_("no need for a trustdb check with `%s' trust model\n"),
              trust_model_string());
 }
 
@@ -572,7 +603,7 @@ update_trustdb()
   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
     validate_keys (1);
   else
-    log_info (_("no need for a trustdb update with \"%s\" trust model\n"),
+    log_info (_("no need for a trustdb update with `%s' trust model\n"),
              trust_model_string());
 }
 
@@ -593,6 +624,20 @@ trustdb_pending_check(void)
   return pending_check_trustdb;
 }
 
+/* If the trustdb is dirty, and we're interactive, update it.
+   Otherwise, check it unless no-auto-check-trustdb is set. */
+void
+trustdb_check_or_update(void)
+{
+  if(trustdb_pending_check())
+    {
+      if(opt.interactive)
+       update_trustdb();
+      else if(!opt.no_auto_check_trustdb)
+       check_trustdb();
+    }
+}
+
 void
 read_trust_options(byte *trust_model,ulong *created,ulong *nextcheck,
                   byte *marginals,byte *completes,byte *cert_depth)
@@ -790,8 +835,7 @@ update_min_ownertrust (u32 *kid, unsigned int new_trust )
   rc = get_pubkey (pk, kid);
   if (rc)
     {
-      log_error (_("public key %08lX not found: %s\n"),
-                 (ulong)kid[1], g10_errstr(rc) );
+      log_error(_("public key %s not found: %s\n"),keystr(kid),g10_errstr(rc));
       return;
     }
 
@@ -799,8 +843,9 @@ update_min_ownertrust (u32 *kid, unsigned int new_trust )
   if (!rc)
     {
       if (DBG_TRUST)
-        log_debug ("key %08lX: update min_ownertrust from %u to %u\n",
-                   (ulong)kid[1],(unsigned int)rec.r.trust.min_ownertrust,
+        log_debug ("key %08lX%08lX: update min_ownertrust from %u to %u\n",
+                   (ulong)kid[0],(ulong)kid[1],
+                  (unsigned int)rec.r.trust.min_ownertrust,
                   new_trust );
       if (rec.r.trust.min_ownertrust != new_trust)
         {
@@ -1024,8 +1069,10 @@ get_validity (PKT_public_key *pk, PKT_user_id *uid)
       rc = get_pubkey (main_pk, pk->main_keyid);
       if (rc)
         {
-          log_error ("error getting main key %08lX of subkey %08lX: %s\n",
-                     (ulong)pk->main_keyid[1], (ulong)kid[1], g10_errstr(rc));
+         char *tempkeystr=m_strdup(keystr(pk->main_keyid));
+          log_error ("error getting main key %s of subkey %s: %s\n",
+                     tempkeystr, keystr(kid), g10_errstr(rc));
+         m_free(tempkeystr);
           validity = TRUST_UNKNOWN; 
           goto leave;
        }
@@ -1033,6 +1080,14 @@ get_validity (PKT_public_key *pk, PKT_user_id *uid)
   else
     main_pk = pk;
 
+  if(opt.trust_model==TM_DIRECT)
+    {
+      /* Note that this happens BEFORE any user ID stuff is checked.
+        The direct trust model applies to keys as a whole. */
+      validity=get_ownertrust(main_pk);
+      goto leave;
+    }
+
   rc = read_trust_record (main_pk, &trec);
   if (rc && rc != -1)
     {
@@ -1218,16 +1273,15 @@ ask_ownertrust (u32 *kid,int minimum)
   rc = get_pubkey (pk, kid);
   if (rc)
     {
-      log_error (_("public key %08lX not found: %s\n"),
-                 (ulong)kid[1], g10_errstr(rc) );
+      log_error (_("public key %s not found: %s\n"),
+                 keystr(kid), g10_errstr(rc) );
       return TRUST_UNKNOWN;
     }
  
   if(opt.force_ownertrust)
     {
-      log_info("force trust for key %08lX%08lX to %s\n",
-              (ulong)kid[0],(ulong)kid[1],
-              trust_value_to_string(opt.force_ownertrust));
+      log_info("force trust for key %s to %s\n",
+              keystr(kid),trust_value_to_string(opt.force_ownertrust));
       update_ownertrust(pk,opt.force_ownertrust);
       ot=opt.force_ownertrust;
     }
@@ -1382,7 +1436,7 @@ mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
         continue; /* we only look at these signature classes */
       if(sig->sig_class>=0x11 && sig->sig_class<=0x13 &&
-        sig->sig_class-0x10<opt.min_cert_check_level)
+        sig->sig_class-0x10<opt.min_cert_level)
        continue;
       if (!is_in_klist (klist, sig))
         continue;  /* no need to check it then */
@@ -1507,19 +1561,19 @@ mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
    signature.  Returns 1 for match, and 0 for no match or regex
    error. */
 static int
-check_regexp(const char *exp,const char *string)
+check_regexp(const char *expr,const char *string)
 {
 #ifdef DISABLE_REGEX
   /* When DISABLE_REGEX is defined, assume all regexps do not
      match. */
   return 0;
 #elif defined(__riscos__)
-  return riscos_check_regexp(exp, string, DBG_TRUST);
+  return riscos_check_regexp(expr, string, DBG_TRUST);
 #else
   int ret;
   regex_t pat;
 
-  if(regcomp(&pat,exp,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
+  if(regcomp(&pat,expr,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
     return 0;
 
   ret=regexec(&pat,string,0,NULL,0);
@@ -1527,7 +1581,7 @@ check_regexp(const char *exp,const char *string)
   regfree(&pat);
 
   if(DBG_TRUST)
-    log_debug("regexp \"%s\" on \"%s\": %s\n",exp,string,ret==0?"YES":"NO");
+    log_debug("regexp `%s' on `%s': %s\n",expr,string,ret==0?"YES":"NO");
 
   return (ret==0);
 #endif
@@ -1923,7 +1977,7 @@ validate_keys (int interactive)
       if (!keyblock)
         {
           log_error (_("public key of ultimately"
-                       " trusted key %08lX not found\n"), (ulong)k->kid[1]);
+                       " trusted key %s not found\n"), keystr(k->kid));
           continue;
         }
       mark_keyblock_seen (used, keyblock);
@@ -1986,9 +2040,9 @@ validate_keys (int interactive)
          if(k->ownertrust<min)
            {
              if(DBG_TRUST)
-               log_debug("key %08lX"
-                         "overriding ownertrust \"%s\" with \"%s\"\n",
-                         (ulong)k->kid[1],
+               log_debug("key %08lX%08lX:"
+                         " overriding ownertrust `%s' with `%s'\n",
+                         (ulong)k->kid[0],(ulong)k->kid[1],
                          trust_value_to_string(k->ownertrust),
                          trust_value_to_string(min));