gpg: Convey --quick option to dirmngr for --auto-key-retrieve.
[gnupg.git] / g10 / import.c
index 14abd2b..d65a7ae 100644 (file)
@@ -76,16 +76,22 @@ struct import_stats_s
 #define NODE_FLAG_A  8
 
 
-/* Global variables to store selector created from
+/* A an object and a global instance to store selectors created from
  * --import-filter keep-uid=EXPR.
  * --import-filter drop-sig=EXPR.
  *
  * FIXME: We should put this into the CTRL object but that requires a
- * lot more changes right now.
+ * lot more changes right now.  For now we use save and restore
+ * fucntion to temporary change them.
  */
-static recsel_expr_t import_keep_uid;
-static recsel_expr_t import_drop_sig;
-
+/* Definition of the import filters.  */
+struct import_filter_s
+{
+  recsel_expr_t keep_uid;
+  recsel_expr_t drop_sig;
+};
+/* The current instance.  */
+struct import_filter_s import_filter;
 
 
 static int import (ctrl_t ctrl,
@@ -109,6 +115,7 @@ static int import_revoke_cert (kbnode_t node, struct import_stats_s *stats);
 static int chk_self_sigs (kbnode_t keyblock, u32 *keyid, int *non_self);
 static int delete_inv_parts (kbnode_t keyblock,
                              u32 *keyid, unsigned int options);
+static int any_uid_left (kbnode_t keyblock);
 static int merge_blocks (kbnode_t keyblock_orig,
                         kbnode_t keyblock, u32 *keyid,
                         int *n_uids, int *n_sigs, int *n_subk );
@@ -120,12 +127,18 @@ static int merge_keysigs (kbnode_t dst, kbnode_t src, int *n_sigs);
 
 \f
 static void
+release_import_filter (import_filter_t filt)
+{
+  recsel_release (filt->keep_uid);
+  filt->keep_uid = NULL;
+  recsel_release (filt->drop_sig);
+  filt->drop_sig = NULL;
+}
+
+static void
 cleanup_import_globals (void)
 {
-  recsel_release (import_keep_uid);
-  import_keep_uid = NULL;
-  recsel_release (import_drop_sig);
-  import_drop_sig = NULL;
+  release_import_filter (&import_filter);
 }
 
 
@@ -201,9 +214,9 @@ parse_and_set_import_filter (const char *string)
   register_mem_cleanup_func (cleanup_import_globals);
 
   if (!strncmp (string, "keep-uid=", 9))
-    err = recsel_parse_expr (&import_keep_uid, string+9);
+    err = recsel_parse_expr (&import_filter.keep_uid, string+9);
   else if (!strncmp (string, "drop-sig=", 9))
-    err = recsel_parse_expr (&import_drop_sig, string+9);
+    err = recsel_parse_expr (&import_filter.drop_sig, string+9);
   else
     err = gpg_error (GPG_ERR_INV_NAME);
 
@@ -211,6 +224,36 @@ parse_and_set_import_filter (const char *string)
 }
 
 
+/* Save the current import filters, return them, and clear the current
+ * filters.  Returns NULL on error and sets ERRNO.  */
+import_filter_t
+save_and_clear_import_filter (void)
+{
+  import_filter_t filt;
+
+  filt = xtrycalloc (1, sizeof *filt);
+  if (!filt)
+    return NULL;
+  *filt = import_filter;
+  memset (&import_filter, 0, sizeof import_filter);
+
+  return filt;
+}
+
+
+/* Release the current import filters and restore them from NEWFILT.
+ * Ownership of NEWFILT is moved to this function.  */
+void
+restore_import_filter (import_filter_t filt)
+{
+  if (filt)
+    {
+      release_import_filter (&import_filter);
+      import_filter = *filt;
+      xfree (filt);
+    }
+}
+
 
 import_stats_t
 import_new_stats_handle (void)
@@ -465,7 +508,7 @@ import_keys_es_stream (ctrl_t ctrl, estream_t fp,
   int rc;
   iobuf_t inp;
 
-  inp = iobuf_esopen (fp, "r", 1);
+  inp = iobuf_esopen (fp, "rb", 1);
   if (!inp)
     {
       rc = gpg_error_from_syserror ();
@@ -1157,6 +1200,35 @@ impex_filter_getval (void *cookie, const char *propname)
       else
         result = NULL;
     }
+  else if (node->pkt->pkttype == PKT_PUBLIC_KEY
+           || node->pkt->pkttype == PKT_SECRET_KEY
+           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
+           || node->pkt->pkttype == PKT_SECRET_SUBKEY)
+    {
+      PKT_public_key *pk = node->pkt->pkt.public_key;
+
+      if (!strcmp (propname, "secret"))
+        {
+          result = (node->pkt->pkttype == PKT_SECRET_KEY
+                    || node->pkt->pkttype == PKT_SECRET_SUBKEY)? "1":"0";
+        }
+      else if (!strcmp (propname, "key_algo"))
+        {
+          snprintf (numbuf, sizeof numbuf, "%d", pk->pubkey_algo);
+          result = numbuf;
+        }
+      if (!strcmp (propname, "key_created"))
+        {
+          snprintf (numbuf, sizeof numbuf, "%lu", (ulong)pk->timestamp);
+          result = numbuf;
+        }
+      else if (!strcmp (propname, "key_created_d"))
+        {
+          result = datestr_from_pk (pk);
+        }
+      else
+        result = NULL;
+    }
   else
     result = NULL;
 
@@ -1273,6 +1345,7 @@ import_one (ctrl_t ctrl,
   size_t an;
   char pkstrbuf[PUBKEY_STRING_SIZE];
   int merge_keys_done = 0;
+  int any_filter = 0;
 
   /* Get the key and print some info about it. */
   node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
@@ -1380,17 +1453,29 @@ import_one (ctrl_t ctrl,
   commit_kbnode (&keyblock);
 
   /* Apply import filter.  */
-  if (import_keep_uid)
+  if (import_filter.keep_uid)
     {
-      apply_keep_uid_filter (keyblock, import_keep_uid);
+      apply_keep_uid_filter (keyblock, import_filter.keep_uid);
       commit_kbnode (&keyblock);
+      any_filter = 1;
     }
-  if (import_drop_sig)
+  if (import_filter.drop_sig)
     {
-      apply_drop_sig_filter (keyblock, import_drop_sig);
+      apply_drop_sig_filter (keyblock, import_filter.drop_sig);
       commit_kbnode (&keyblock);
+      any_filter = 1;
     }
 
+  /* If we ran any filter we need to check that at least one user id
+   * is left in the keyring.  Note that we do not use log_error in
+   * this case. */
+  if (any_filter && !any_uid_left (keyblock))
+    {
+      if (!opt.quiet )
+        log_info ( _("key %s: no valid user IDs\n"), keystr_from_pk (pk));
+      stats->no_user_id++;
+      return 0;
+    }
 
   /* Show the key in the form it is merged or inserted.  We skip this
    * if "import-export" is also active without --armor or the output
@@ -2672,6 +2757,19 @@ delete_inv_parts (kbnode_t keyblock, u32 *keyid, unsigned int options)
   return nvalid;
 }
 
+/* This function returns true if any UID is left in the keyring.  */
+static int
+any_uid_left (kbnode_t keyblock)
+{
+  kbnode_t node;
+
+  for (node=keyblock->next; node; node = node->next)
+    if (node->pkt->pkttype == PKT_USER_ID)
+      return 1;
+  return 0;
+}
+
+
 
 /****************
  * It may happen that the imported keyblock has duplicated user IDs.
@@ -2856,7 +2954,7 @@ revocation_present (ctrl_t ctrl, kbnode_t keyblock)
                              keyserver_import_fprint (ctrl,
                                                        sig->revkey[idx].fpr,
                                                        MAX_FINGERPRINT_LEN,
-                                                       opt.keyserver);
+                                                       opt.keyserver, 0);
 
                              /* Do we have it now? */
                              rc=get_pubkey_byfprint_fast (NULL,