gpg: Do not pre-check keys given on the command line.
[gnupg.git] / g10 / gpg.c
index 7741251..2b48421 100644 (file)
--- a/g10/gpg.c
+++ b/g10/gpg.c
@@ -1968,26 +1968,37 @@ parse_trust_model(const char *model)
 }
 #endif /*NO_TRUST_MODELS*/
 
+
 static int
-parse_tofu_policy (const char *policy)
+parse_tofu_policy (const char *policystr)
 {
 #ifdef USE_TOFU
-  if (ascii_strcasecmp (policy, "auto") == 0)
-    return TOFU_POLICY_AUTO;
-  else if (ascii_strcasecmp (policy, "good") == 0)
-    return TOFU_POLICY_GOOD;
-  else if (ascii_strcasecmp (policy, "unknown") == 0)
-    return TOFU_POLICY_UNKNOWN;
-  else if (ascii_strcasecmp (policy, "bad") == 0)
-    return TOFU_POLICY_BAD;
-  else if (ascii_strcasecmp (policy, "ask") == 0)
-    return TOFU_POLICY_ASK;
-  else
-#endif /*USE_TOFU*/
+  struct { const char *keyword; int policy; } list[] = {
+    { "auto",    TOFU_POLICY_AUTO },
+    { "good",    TOFU_POLICY_GOOD },
+    { "unknown", TOFU_POLICY_UNKNOWN },
+    { "bad",     TOFU_POLICY_BAD },
+    { "ask",     TOFU_POLICY_ASK }
+  };
+  int i;
+
+  if (!ascii_strcasecmp (policystr, "help"))
     {
-      log_error (_("unknown TOFU policy '%s'\n"), policy);
+      log_info (_("available TOFU policies:\n"));
+      for (i=0; i < DIM (list); i++)
+        log_info ("  %s\n", list[i].keyword);
       g10_exit (1);
     }
+
+  for (i=0; i < DIM (list); i++)
+    if (!ascii_strcasecmp (policystr, list[i].keyword))
+      return list[i].policy;
+#endif /*USE_TOFU*/
+
+  log_error (_("unknown TOFU policy '%s'\n"), policystr);
+  if (!opt.quiet)
+    log_info (_("(use \"help\" to list choices)\n"));
+  g10_exit (1);
 }
 
 static int
@@ -2000,10 +2011,17 @@ parse_tofu_db_format (const char *db_format)
     return TOFU_DB_SPLIT;
   else if (ascii_strcasecmp (db_format, "flat") == 0)
     return TOFU_DB_FLAT;
+  else if (ascii_strcasecmp (db_format, "help") == 0)
+    {
+      log_info ("available TOFU DB fomats: auto, split, flat\n");
+      g10_exit (1);
+    }
   else
 #endif /*USE_TOFU*/
     {
       log_error (_("unknown TOFU DB format '%s'\n"), db_format);
+      if (!opt.quiet)
+        log_info (_("(use \"help\" to list choices)\n"));
       g10_exit (1);
     }
 }
@@ -2083,7 +2101,8 @@ get_default_configname (void)
   return configname;
 }
 
-gpg_error_t
+
+static gpg_error_t
 check_user_ids (strlist_t *sp,
                 int warn_possibly_ambiguous,
                 int error_if_not_found)
@@ -2097,7 +2116,12 @@ check_user_ids (strlist_t *sp,
 
   KEYDB_HANDLE hd = NULL;
 
-  if (! s)
+  /* A quick check to avoid allocating a new strlist if we can skip
+     all keys.  Handles also the case of !SP.  See below for details.  */
+  for (t = s; t && (!(t->flags & PK_LIST_CONFIG)
+                    && !(t->flags & PK_LIST_ENCRYPT_TO)); t = t->next)
+    ;
+  if (!t)
     return 0;
 
   for (t = s; t; t = t->next)
@@ -2112,8 +2136,19 @@ check_user_ids (strlist_t *sp,
       /* We also potentially need a ! at the end.  */
       char fingerprint[2 * MAX_FINGERPRINT_LEN + 1 + 1];
 
+      /* If the key has been given on the command line and it has not
+         been given by one of the encrypt-to options, we skip the
+         checks.  The reason is that the actual key selection code
+         does its own checks and provides proper status message to the
+         caller to detect the wrong keys.  */
+      if (!(t->flags & PK_LIST_CONFIG) && !(t->flags & PK_LIST_ENCRYPT_TO))
+        {
+          add_to_strlist (&s2, t->d);
+          s2->flags = t->flags;
+          continue;
+        }
 
-      switch (t->flags >> 2)
+      switch (t->flags >> PK_LIST_SHIFT)
         {
         case oDefaultKey: option = "--default-key"; break;
         case oEncryptTo: option = "--encrypt-to"; break;
@@ -2122,7 +2157,8 @@ check_user_ids (strlist_t *sp,
         case oRecipient: option = "--recipient"; break;
         case oHiddenRecipient: option = "--hidden-recipient"; break;
         case oLocalUser: option = "--local-user"; break;
-        default: log_bug ("Unsupport option: %d\n", t->flags >> 2);
+        default:
+          log_bug ("Unsupport option: %d\n", (t->flags >> PK_LIST_SHIFT));
         }
 
       if (DBG_LOOKUP)
@@ -2137,7 +2173,8 @@ check_user_ids (strlist_t *sp,
           if (! rc)
             rc = err;
 
-          log_error (_("Invalid value ('%s')."), t->d);
+          log_error (_("key \"%s\" not found: %s\n"),
+                       t->d, gpg_strerror (err));
           if (!opt.quiet)
             log_info (_("(check argument of option '%s')\n"), option);
           continue;
@@ -2148,12 +2185,19 @@ check_user_ids (strlist_t *sp,
                 || desc.mode == KEYDB_SEARCH_MODE_FPR16
                 || desc.mode == KEYDB_SEARCH_MODE_FPR20
                 || desc.mode == KEYDB_SEARCH_MODE_FPR))
-        log_info (_("Warning: value '%s' for %s"
-                    " should be a long keyid or a fingerprint.\n"),
+        log_info (_("Warning: value '%s' for option '%s'"
+                    " should be a long key ID or a fingerprint\n"),
                   t->d, option);
 
       if (! hd)
-        hd = keydb_new ();
+        {
+          hd = keydb_new ();
+          if (!hd)
+            {
+              rc = gpg_error_from_syserror ();
+              break;
+            }
+        }
       else
         keydb_search_reset (hd);
 
@@ -2168,7 +2212,7 @@ check_user_ids (strlist_t *sp,
               if (! rc)
                 rc = err;
 
-              log_error (_("no such key corresponding to '%s'\n"), t->d);
+              log_error (_("key \"%s\" not found\n"), t->d);
               if (!opt.quiet)
                 log_info (_("(check argument of option '%s')\n"), option);
             }
@@ -2179,8 +2223,7 @@ check_user_ids (strlist_t *sp,
           if (! rc)
             rc = err;
 
-          log_error (_("error looking up '%s' in keyring: %s.\n"),
-                     t->d, gpg_strerror (err));
+          log_error (_("key \"%s\" not found: %s\n"), t->d, gpg_strerror (err));
           break;
         }
 
@@ -2190,8 +2233,7 @@ check_user_ids (strlist_t *sp,
           if (! rc)
             rc = err;
 
-          log_error (_("error reading key block for '%s': %s\n"),
-                     t->d, gpg_strerror (err));
+          log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
           continue;
         }
 
@@ -2254,8 +2296,7 @@ check_user_ids (strlist_t *sp,
           size_t fingerprint_bin2_len = sizeof (fingerprint_bin2);
           char fingerprint2[2 * MAX_FINGERPRINT_LEN + 1];
 
-          log_error (_("Error: the key specification '%s' is ambiguous.\n"),
-                     t->d);
+          log_error (_("key specification '%s' is ambiguous\n"), t->d);
           if (!opt.quiet)
             log_info (_("(check argument of option '%s')\n"), option);
 
@@ -2264,8 +2305,7 @@ check_user_ids (strlist_t *sp,
 
           err = keydb_get_keyblock (hd, &kb);
           if (err)
-            log_error (_("error reading key block for '%s': %s.\n"),
-                       t->d, gpg_strerror (err));
+            log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
           else
             {
               pk = kb->pkt->pkt.public_key;
@@ -2273,8 +2313,12 @@ check_user_ids (strlist_t *sp,
               assert (fingerprint_bin2_len == sizeof (fingerprint_bin2));
               bin2hex (fingerprint_bin2, MAX_FINGERPRINT_LEN, fingerprint2);
 
-              log_error ("'%s' matches at least: %s and %s.\n",
-                         t->d, fingerprint, fingerprint2);
+              /* TRANSLATORS: The %s prints a key specification which
+                 for example has been given at the command line.  Two
+                 lines with fingerprints are printed after this message.  */
+              log_info (_("'%s' matches at least:\n"), t->d);
+              log_info ("  %s\n", fingerprint);
+              log_info ("  %s\n", fingerprint2);
 
               release_kbnode (kb);
             }
@@ -2283,7 +2327,7 @@ check_user_ids (strlist_t *sp,
                   || gpg_err_code (err) == GPG_ERR_EOF))
         /* An error (other than "not found").  */
         {
-          log_error (_("Error reading from keyring: %s\n"),
+          log_error (_("error searching the keyring: %s\n"),
                      gpg_strerror (err));
           if (! rc)
             rc = err;
@@ -2292,14 +2336,14 @@ check_user_ids (strlist_t *sp,
 
   strlist_rev (&s2);
 
-  if (hd)
-    keydb_release (hd);
+  keydb_release (hd);
 
   free_strlist (s);
   *sp = s2;
   return rc;
 }
 
+
 int
 main (int argc, char **argv)
 {
@@ -2311,7 +2355,9 @@ main (int argc, char **argv)
     const char *fname;
     char *username;
     int may_coredump;
-    strlist_t sl, remusr= NULL, locusr=NULL;
+    strlist_t sl;
+    strlist_t remusr = NULL;
+    strlist_t locusr = NULL;
     strlist_t nrings = NULL;
     armor_filter_context_t *afx = NULL;
     int detached_sig = 0;
@@ -2801,7 +2847,7 @@ main (int argc, char **argv)
 #endif /*!NO_TRUST_MODELS*/
          case oDefaultKey:
             sl = add_to_strlist (&opt.def_secret_key, pargs.r.ret_str);
-            sl->flags = (pargs.r_opt << 2);
+            sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
             break;
          case oDefRecipient:
             if( *pargs.r.ret_str )
@@ -2993,23 +3039,32 @@ main (int argc, char **argv)
          case oNoEncryptTo: opt.no_encrypt_to = 1; break;
          case oEncryptTo: /* store the recipient in the second list */
            sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
-           sl->flags = (pargs.r_opt << 2) | 1;
+           sl->flags = ((pargs.r_opt << PK_LIST_SHIFT) | PK_LIST_ENCRYPT_TO);
+            if (configfp)
+              sl->flags |= PK_LIST_CONFIG;
            break;
          case oHiddenEncryptTo: /* store the recipient in the second list */
            sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
-           sl->flags = (pargs.r_opt << 2) | 1|2;
+           sl->flags = ((pargs.r_opt << PK_LIST_SHIFT)
+                         | PK_LIST_ENCRYPT_TO|PK_LIST_HIDDEN);
+            if (configfp)
+              sl->flags |= PK_LIST_CONFIG;
            break;
           case oEncryptToDefaultKey:
             opt.encrypt_to_default_key = 1;
             break;
          case oRecipient: /* store the recipient */
            sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
-           sl->flags = (pargs.r_opt << 2);
+           sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
+            if (configfp)
+              sl->flags |= PK_LIST_CONFIG;
             any_explicit_recipient = 1;
            break;
          case oHiddenRecipient: /* store the recipient with a flag */
            sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
-           sl->flags = (pargs.r_opt << 2) | 2;
+           sl->flags = ((pargs.r_opt << PK_LIST_SHIFT) | PK_LIST_HIDDEN);
+            if (configfp)
+              sl->flags |= PK_LIST_CONFIG;
             any_explicit_recipient = 1;
            break;
 
@@ -3053,7 +3108,9 @@ main (int argc, char **argv)
          case oNoAskCertLevel: opt.ask_cert_level = 0; break;
          case oLocalUser: /* store the local users */
            sl = add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
-            sl->flags = (pargs.r_opt << 2);
+            sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
+            if (configfp)
+              sl->flags |= PK_LIST_CONFIG;
            break;
          case oCompress:
            /* this is the -z command line option */
@@ -3983,12 +4040,15 @@ main (int argc, char **argv)
           if (default_key)
             {
               sl = add_to_strlist2 (&remusr, default_key, utf8_strings);
-              sl->flags = (oEncryptToDefaultKey << 2) | 1;
+              sl->flags = ((oEncryptToDefaultKey << PK_LIST_SHIFT)
+                           | PK_LIST_ENCRYPT_TO);
             }
           else if (have_def_secret_key)
-            log_info (_("--encrypt-to-default-key specified, but no valid default keys specified.\n"));
+            log_info (_("option '%s' given, but no valid default keys given\n"),
+                      "--encrypt-to-default-key");
           else
-            log_info (_("--encrypt-to-default-key specified, but --default-key not specified.\n"));
+            log_info (_("option '%s' given, but option '%s' not given\n"),
+                      "--encrypt-to-default-key", "--default-key");
         }
     }
 
@@ -4716,16 +4776,13 @@ main (int argc, char **argv)
          KEYDB_HANDLE hd;
 
          if (argc < 2)
-           wrong_args("--tofu-policy POLICY KEYID [KEYID...]");
+           wrong_args ("--tofu-policy POLICY KEYID [KEYID...]");
 
          policy = parse_tofu_policy (argv[0]);
 
          hd = keydb_new ();
          if (! hd)
-           {
-             log_error (_("Failed to open the keyring DB.\n"));
-             g10_exit (1);
-           }
+            g10_exit (1);
 
          for (i = 1; i < argc; i ++)
            {
@@ -4735,7 +4792,8 @@ main (int argc, char **argv)
              rc = classify_user_id (argv[i], &desc, 0);
              if (rc)
                {
-                 log_error (_("Failed to parse '%s'.\n"), argv[i]);
+                 log_error (_("error parsing key specification '%s': %s\n"),
+                             argv[i], gpg_strerror (rc));
                  g10_exit (1);
                }
 
@@ -4747,7 +4805,7 @@ main (int argc, char **argv)
                     || desc.mode == KEYDB_SEARCH_MODE_KEYGRIP))
                {
                  log_error (_("'%s' does not appear to be a valid"
-                              " key id, fingerprint or key grip.\n"),
+                              " key ID, fingerprint or keygrip\n"),
                             argv[i]);
                  g10_exit (1);
                }
@@ -4755,27 +4813,26 @@ main (int argc, char **argv)
              rc = keydb_search_reset (hd);
              if (rc)
                {
-                 log_error (_("Failed to reset keyring handle.\n"));
+                  /* This should not happen, thus no need to tranalate
+                     the string.  */
+                  log_error ("keydb_search_reset failed: %s\n",
+                             gpg_strerror (rc));
                  g10_exit (1);
                }
 
              rc = keydb_search (hd, &desc, 1, NULL);
-             if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY)
-               {
-                 log_error (_("Key '%s' is not available\n"), argv[i]);
-                 g10_exit (1);
-               }
-             else if (rc)
+             if (rc)
                {
-                 log_error (_("Failed to find key '%s'\n"), argv[i]);
+                 log_error (_("key \"%s\" not found: %s\n"), argv[i],
+                             gpg_strerror (rc));
                  g10_exit (1);
                }
 
              rc = keydb_get_keyblock (hd, &kb);
              if (rc)
                {
-                 log_error (_("Failed to read key '%s' from the keyring\n"),
-                            argv[i]);
+                 log_error (_("error reading keyblock: %s\n"),
+                             gpg_strerror (rc));
                  g10_exit (1);
                }