diff --git a/common/name-value.c b/common/name-value.c
index 89fd060c8..989a5b111 100644
--- a/common/name-value.c
+++ b/common/name-value.c
@@ -1,833 +1,867 @@
 /* name-value.c - Parser and writer for a name-value format.
  *	Copyright (C) 2016 g10 Code GmbH
  *
  * This file is part of GnuPG.
  *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of either
  *
  *   - the GNU Lesser General Public License as published by the Free
  *     Software Foundation; either version 3 of the License, or (at
  *     your option) any later version.
  *
  * or
  *
  *   - the GNU General Public License as published by the Free
  *     Software Foundation; either version 2 of the License, or (at
  *     your option) any later version.
  *
  * or both in parallel, as here.
  *
  * GnuPG is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 /*
  * This module aso provides features for the extended private key
  * format of gpg-agent.
  */
 
 #include <config.h>
 #include <assert.h>
 #include <gcrypt.h>
 #include <gpg-error.h>
 #include <string.h>
 
 #include "mischelp.h"
 #include "strlist.h"
 #include "util.h"
 #include "name-value.h"
 
 struct name_value_container
 {
   struct name_value_entry *first;
   struct name_value_entry *last;
   unsigned int private_key_mode:1;
 };
 
 
 struct name_value_entry
 {
   struct name_value_entry *prev;
   struct name_value_entry *next;
 
   /* The name.  Comments and blank lines have NAME set to NULL.  */
   char *name;
 
   /* The value as stored in the file.  We store it when we parse
      a file so that we can reproduce it.  */
   strlist_t raw_value;
 
   /* The decoded value.  */
   char *value;
 };
 
 
 /* Helper */
 static inline gpg_error_t
 my_error_from_syserror (void)
 {
   return gpg_err_make (default_errsource, gpg_err_code_from_syserror ());
 }
 
 
 static inline gpg_error_t
 my_error (gpg_err_code_t ec)
 {
   return gpg_err_make (default_errsource, ec);
 }
 
 
 
 
 /* Allocation and deallocation.  */
 
 /* Allocate a private key container structure.  */
 nvc_t
 nvc_new (void)
 {
   return xtrycalloc (1, sizeof (struct name_value_container));
 }
 
 
 /* Allocate a private key container structure for use with private keys.  */
 nvc_t
 nvc_new_private_key (void)
 {
   nvc_t nvc = nvc_new ();
   if (nvc)
     nvc->private_key_mode = 1;
   return nvc;
 }
 
 
 static void
 nve_release (nve_t entry, int private_key_mode)
 {
   if (entry == NULL)
     return;
 
   xfree (entry->name);
   if (entry->value && private_key_mode)
     wipememory (entry->value, strlen (entry->value));
   xfree (entry->value);
   if (private_key_mode)
     free_strlist_wipe (entry->raw_value);
   else
     free_strlist (entry->raw_value);
   xfree (entry);
 }
 
 
 /* Release a private key container structure.  */
 void
 nvc_release (nvc_t pk)
 {
   nve_t e, next;
 
   if (pk == NULL)
     return;
 
   for (e = pk->first; e; e = next)
     {
       next = e->next;
       nve_release (e, pk->private_key_mode);
     }
 
   xfree (pk);
 }
 
 
 
 /* Dealing with names and values.  */
 
 /* Check whether the given name is valid.  Valid names start with a
    letter, end with a colon, and contain only alphanumeric characters
    and the hyphen.  */
 static int
 valid_name (const char *name)
 {
   size_t i, len = strlen (name);
 
   if (! alphap (name) || len == 0 || name[len - 1] != ':')
     return 0;
 
   for (i = 1; i < len - 1; i++)
     if (! alnump (&name[i]) && name[i] != '-')
       return 0;
 
   return 1;
 }
 
 
 /* Makes sure that ENTRY has a RAW_VALUE.  */
 static gpg_error_t
 assert_raw_value (nve_t entry)
 {
   gpg_error_t err = 0;
   size_t len, offset;
 #define LINELEN	70
   char buf[LINELEN+3];
 
   if (entry->raw_value)
     return 0;
 
   len = strlen (entry->value);
   offset = 0;
   while (len)
     {
       size_t amount, linelen = LINELEN;
 
       /* On the first line we need to subtract space for the name.  */
       if (entry->raw_value == NULL && strlen (entry->name) < linelen)
 	linelen -= strlen (entry->name);
 
       /* See if the rest of the value fits in this line.  */
       if (len <= linelen)
 	amount = len;
       else
 	{
 	  size_t i;
 
 	  /* Find a suitable space to break on.  */
 	  for (i = linelen - 1; linelen - i < 30 && linelen - i > offset; i--)
 	    if (ascii_isspace (entry->value[i]))
 	      break;
 
 	  if (ascii_isspace (entry->value[i]))
 	    {
 	      /* Found one.  */
 	      amount = i;
 	    }
 	  else
 	    {
 	      /* Just induce a hard break.  */
 	      amount = linelen;
 	    }
 	}
 
       snprintf (buf, sizeof buf, " %.*s\n", (int) amount,
 		&entry->value[offset]);
       if (append_to_strlist_try (&entry->raw_value, buf) == NULL)
 	{
 	  err = my_error_from_syserror ();
 	  goto leave;
 	}
 
       offset += amount;
       len -= amount;
     }
 
  leave:
   if (err)
     {
       free_strlist_wipe (entry->raw_value);
       entry->raw_value = NULL;
     }
 
   return err;
 #undef LINELEN
 }
 
 
 /* Computes the length of the value encoded as continuation.  If
    *SWALLOW_WS is set, all whitespace at the beginning of S is
    swallowed.  If START is given, a pointer to the beginning of the
    value is stored there.  */
 static size_t
 continuation_length (const char *s, int *swallow_ws, const char **start)
 {
   size_t len;
 
   if (*swallow_ws)
     {
       /* The previous line was a blank line and we inserted a newline.
 	 Swallow all whitespace at the beginning of this line.  */
       while (ascii_isspace (*s))
 	s++;
     }
   else
     {
       /* Iff a continuation starts with more than one space, it
 	 encodes a space.  */
       if (ascii_isspace (*s))
 	s++;
     }
 
   /* Strip whitespace at the end.  */
   len = strlen (s);
   while (len > 0 && ascii_isspace (s[len-1]))
     len--;
 
   if (len == 0)
     {
       /* Blank lines encode newlines.  */
       len = 1;
       s = "\n";
       *swallow_ws = 1;
     }
   else
     *swallow_ws = 0;
 
   if (start)
     *start = s;
 
   return len;
 }
 
 
 /* Makes sure that ENTRY has a VALUE.  */
 static gpg_error_t
 assert_value (nve_t entry)
 {
   size_t len;
   int swallow_ws;
   strlist_t s;
   char *p;
 
   if (entry->value)
     return 0;
 
   len = 0;
   swallow_ws = 0;
   for (s = entry->raw_value; s; s = s->next)
     len += continuation_length (s->d, &swallow_ws, NULL);
 
   /* Add one for the terminating zero.  */
   len += 1;
 
   entry->value = p = xtrymalloc (len);
   if (entry->value == NULL)
     return my_error_from_syserror ();
 
   swallow_ws = 0;
   for (s = entry->raw_value; s; s = s->next)
     {
       const char *start;
       size_t l = continuation_length (s->d, &swallow_ws, &start);
 
       memcpy (p, start, l);
       p += l;
     }
 
   *p++ = 0;
   assert (p - entry->value == len);
 
   return 0;
 }
 
 
 /* Get the name.  */
 char *
 nve_name (nve_t pke)
 {
   return pke->name;
 }
 
 
 /* Get the value.  */
 char *
 nve_value (nve_t pke)
 {
   if (assert_value (pke))
     return NULL;
   return pke->value;
 }
 
 
 
 /* Adding and modifying values.  */
 
 /* Add (NAME, VALUE, RAW_VALUE) to PK.  NAME may be NULL for comments
    and blank lines.  At least one of VALUE and RAW_VALUE must be
    given.  If PRESERVE_ORDER is not given, entries with the same name
    are grouped.  NAME, VALUE and RAW_VALUE is consumed.  */
 static gpg_error_t
 _nvc_add (nvc_t pk, char *name, char *value, strlist_t raw_value,
 	  int preserve_order)
 {
   gpg_error_t err = 0;
   nve_t e;
 
   assert (value || raw_value);
 
   if (name && ! valid_name (name))
     {
       err = my_error (GPG_ERR_INV_NAME);
       goto leave;
     }
 
   if (name
       && pk->private_key_mode
       && !ascii_strcasecmp (name, "Key:")
       && nvc_lookup (pk, "Key:"))
     {
       err = my_error (GPG_ERR_INV_NAME);
       goto leave;
     }
 
   e = xtrycalloc (1, sizeof *e);
   if (e == NULL)
     {
       err = my_error_from_syserror ();
       goto leave;
     }
 
   e->name = name;
   e->value = value;
   e->raw_value = raw_value;
 
   if (pk->first)
     {
       nve_t last;
 
       if (preserve_order || name == NULL)
 	last = pk->last;
       else
 	{
 	  /* See if there is already an entry with NAME.  */
 	  last = nvc_lookup (pk, name);
 
 	  /* If so, find the last in that block.  */
 	  if (last)
             {
               while (last->next)
                 {
                   nve_t next = last->next;
 
                   if (next->name && ascii_strcasecmp (next->name, name) == 0)
                     last = next;
                   else
                     break;
                 }
             }
 	  else /* Otherwise, just find the last entry.  */
 	    last = pk->last;
 	}
 
       if (last->next)
 	{
 	  e->prev = last;
 	  e->next = last->next;
 	  last->next = e;
 	  e->next->prev = e;
 	}
       else
 	{
 	  e->prev = last;
 	  last->next = e;
 	  pk->last = e;
 	}
     }
   else
     pk->first = pk->last = e;
 
  leave:
   if (err)
     {
       xfree (name);
       if (value)
 	wipememory (value, strlen (value));
       xfree (value);
       free_strlist_wipe (raw_value);
     }
 
   return err;
 }
 
 
 /* Add (NAME, VALUE) to PK.  If an entry with NAME already exists, it
    is not updated but the new entry is appended.  */
 gpg_error_t
 nvc_add (nvc_t pk, const char *name, const char *value)
 {
   char *k, *v;
 
   k = xtrystrdup (name);
   if (k == NULL)
     return my_error_from_syserror ();
 
   v = xtrystrdup (value);
   if (v == NULL)
     {
       xfree (k);
       return my_error_from_syserror ();
     }
 
   return _nvc_add (pk, k, v, NULL, 0);
 }
 
 
 /* Add (NAME, VALUE) to PK.  If an entry with NAME already exists, it
    is updated with VALUE.  If multiple entries with NAME exist, the
    first entry is updated.  */
 gpg_error_t
 nvc_set (nvc_t pk, const char *name, const char *value)
 {
   nve_t e;
 
   if (! valid_name (name))
     return GPG_ERR_INV_NAME;
 
   e = nvc_lookup (pk, name);
   if (e)
     {
       char *v;
 
       v = xtrystrdup (value);
       if (v == NULL)
 	return my_error_from_syserror ();
 
       free_strlist_wipe (e->raw_value);
       e->raw_value = NULL;
       if (e->value)
 	wipememory (e->value, strlen (e->value));
       xfree (e->value);
       e->value = v;
 
       return 0;
     }
   else
     return nvc_add (pk, name, value);
 }
 
 
 /* Delete the given entry from PK.  */
 void
 nvc_delete (nvc_t pk, nve_t entry)
 {
   if (entry->prev)
     entry->prev->next = entry->next;
   else
     pk->first = entry->next;
 
   if (entry->next)
     entry->next->prev = entry->prev;
   else
     pk->last = entry->prev;
 
   nve_release (entry, pk->private_key_mode);
 }
 
+
+/* Delete the entries with NAME from PK.  */
+void
+nvc_delete_named (nvc_t pk, const char *name)
+{
+  nve_t e;
+
+  if (!valid_name (name))
+    return;
+
+  while ((e = nvc_lookup (pk, name)))
+    nvc_delete (pk, e);
+}
+
+
 
 
 /* Lookup and iteration.  */
 
 /* Get the first non-comment entry.  */
 nve_t
 nvc_first (nvc_t pk)
 {
   nve_t entry;
   for (entry = pk->first; entry; entry = entry->next)
     if (entry->name)
       return entry;
   return NULL;
 }
 
 
 /* Get the first entry with the given name.  */
 nve_t
 nvc_lookup (nvc_t pk, const char *name)
 {
   nve_t entry;
   for (entry = pk->first; entry; entry = entry->next)
     if (entry->name && ascii_strcasecmp (entry->name, name) == 0)
       return entry;
   return NULL;
 }
 
 
 /* Get the next non-comment entry.  */
 nve_t
 nve_next (nve_t entry)
 {
   for (entry = entry->next; entry; entry = entry->next)
     if (entry->name)
       return entry;
   return NULL;
 }
 
 
 /* Get the next entry with the given name.  */
 nve_t
 nve_next_value (nve_t entry, const char *name)
 {
   for (entry = entry->next; entry; entry = entry->next)
     if (entry->name && ascii_strcasecmp (entry->name, name) == 0)
       return entry;
   return NULL;
 }
 
+
+/* Return the string for the first entry in NVC with NAME.  If an
+ * entry with NAME is missing in NVC or its value is the empty string
+ * NULL is returned.  Note that the The returned string is a pointer
+ * into NVC.  */
+const char *
+nvc_get_string (nvc_t nvc, const char *name)
+{
+  nve_t item;
+
+  if (!nvc)
+    return NULL;
+  item = nvc_lookup (nvc, name);
+  if (!item)
+    return NULL;
+  return nve_value (item);
+}
+
+
 
 
 /* Private key handling.  */
 
 /* Get the private key.  */
 gpg_error_t
 nvc_get_private_key (nvc_t pk, gcry_sexp_t *retsexp)
 {
   gpg_error_t err;
   nve_t e;
 
   e = pk->private_key_mode? nvc_lookup (pk, "Key:") : NULL;
   if (e == NULL)
     return my_error (GPG_ERR_MISSING_KEY);
 
   err = assert_value (e);
   if (err)
     return err;
 
   return gcry_sexp_sscan (retsexp, NULL, e->value, strlen (e->value));
 }
 
 
 /* Set the private key.  */
 gpg_error_t
 nvc_set_private_key (nvc_t pk, gcry_sexp_t sexp)
 {
   gpg_error_t err;
   char *raw, *clean, *p;
   size_t len, i;
 
   if (!pk->private_key_mode)
     return my_error (GPG_ERR_MISSING_KEY);
 
   len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, NULL, 0);
 
   raw = xtrymalloc (len);
   if (raw == NULL)
     return my_error_from_syserror ();
 
   clean = xtrymalloc (len);
   if (clean == NULL)
     {
       xfree (raw);
       return my_error_from_syserror ();
     }
 
   gcry_sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, raw, len);
 
   /* Strip any whitespace at the end.  */
   i = strlen (raw) - 1;
   while (i && ascii_isspace (raw[i]))
     {
       raw[i] = 0;
       i--;
     }
 
   /* Replace any newlines with spaces, remove superfluous whitespace.  */
   len = strlen (raw);
   for (p = clean, i = 0; i < len; i++)
     {
       char c = raw[i];
 
       /* Collapse contiguous and superfluous spaces.  */
       if (ascii_isspace (c) && i > 0
 	  && (ascii_isspace (raw[i-1]) || raw[i-1] == '(' || raw[i-1] == ')'))
 	continue;
 
       if (c == '\n')
 	c = ' ';
 
       *p++ = c;
     }
   *p = 0;
 
   err = nvc_set (pk, "Key:", clean);
   xfree (raw);
   xfree (clean);
   return err;
 }
 
 
 
 /* Parsing and serialization.  */
 
 static gpg_error_t
 do_nvc_parse (nvc_t *result, int *errlinep, estream_t stream,
               int for_private_key)
 {
   gpg_error_t err = 0;
   gpgrt_ssize_t len;
   char *buf = NULL;
   size_t buf_len = 0;
   char *name = NULL;
   strlist_t raw_value = NULL;
 
   *result = for_private_key? nvc_new_private_key () : nvc_new ();
   if (*result == NULL)
     return my_error_from_syserror ();
 
   if (errlinep)
     *errlinep = 0;
   while ((len = es_read_line (stream, &buf, &buf_len, NULL)) > 0)
     {
       char *p;
       if (errlinep)
 	*errlinep += 1;
 
       /* Skip any whitespace.  */
       for (p = buf; *p && ascii_isspace (*p); p++)
 	/* Do nothing.  */;
 
       if (name && (spacep (buf) || *p == 0))
 	{
 	  /* A continuation.  */
 	  if (append_to_strlist_try (&raw_value, buf) == NULL)
 	    {
 	      err = my_error_from_syserror ();
 	      goto leave;
 	    }
 	  continue;
 	}
 
       /* No continuation.  Add the current entry if any.  */
       if (raw_value)
 	{
 	  err = _nvc_add (*result, name, NULL, raw_value, 1);
 	  if (err)
 	    goto leave;
 	}
 
       /* And prepare for the next one.  */
       name = NULL;
       raw_value = NULL;
 
       if (*p != 0 && *p != '#')
 	{
 	  char *colon, *value, tmp;
 
 	  colon = strchr (buf, ':');
 	  if (colon == NULL)
 	    {
 	      err = my_error (GPG_ERR_INV_VALUE);
 	      goto leave;
 	    }
 
 	  value = colon + 1;
 	  tmp = *value;
 	  *value = 0;
 	  name = xtrystrdup (p);
 	  *value = tmp;
 
 	  if (name == NULL)
 	    {
 	      err = my_error_from_syserror ();
 	      goto leave;
 	    }
 
 	  if (append_to_strlist_try (&raw_value, value) == NULL)
 	    {
 	      err = my_error_from_syserror ();
 	      goto leave;
 	    }
 	  continue;
 	}
 
       if (append_to_strlist_try (&raw_value, buf) == NULL)
 	{
 	  err = my_error_from_syserror ();
 	  goto leave;
 	}
     }
   if (len < 0)
     {
       err = gpg_error_from_syserror ();
       goto leave;
     }
 
   /* Add the final entry.  */
   if (raw_value)
     err = _nvc_add (*result, name, NULL, raw_value, 1);
 
  leave:
   gpgrt_free (buf);
   if (err)
     {
       nvc_release (*result);
       *result = NULL;
     }
 
   return err;
 }
 
 
 /* Parse STREAM and return a newly allocated name value container
    structure in RESULT.  If ERRLINEP is given, the line number the
    parser was last considering is stored there.  */
 gpg_error_t
 nvc_parse (nvc_t *result, int *errlinep, estream_t stream)
 {
   return do_nvc_parse (result, errlinep, stream, 0);
 }
 
 
 /* Parse STREAM and return a newly allocated name value container
    structure in RESULT - assuming the extended private key format.  If
    ERRLINEP is given, the line number the parser was last considering
    is stored there.  */
 gpg_error_t
 nvc_parse_private_key (nvc_t *result, int *errlinep, estream_t stream)
 {
   return do_nvc_parse (result, errlinep, stream, 1);
 }
 
 
 /* Helper fpr nvc_write.  */
 static gpg_error_t
 write_one_entry (nve_t entry, estream_t stream)
 {
   gpg_error_t err;
   strlist_t sl;
 
   if (entry->name)
     es_fputs (entry->name, stream);
 
   err = assert_raw_value (entry);
   if (err)
     return err;
 
   for (sl = entry->raw_value; sl; sl = sl->next)
     es_fputs (sl->d, stream);
 
   if (es_ferror (stream))
     return my_error_from_syserror ();
 
   return 0;
 }
 
 
 /* Write a representation of PK to STREAM.  */
 gpg_error_t
 nvc_write (nvc_t pk, estream_t stream)
 {
   gpg_error_t err = 0;
   nve_t entry;
   nve_t keyentry = NULL;
 
   for (entry = pk->first; entry; entry = entry->next)
     {
       if (pk->private_key_mode
           && entry->name && !ascii_strcasecmp (entry->name, "Key:"))
         {
           if (!keyentry)
             keyentry = entry;
           continue;
         }
 
       err = write_one_entry (entry, stream);
       if (err)
 	return err;
     }
 
   /* In private key mode we write the Key always last.  */
   if (keyentry)
     err = write_one_entry (keyentry, stream);
 
   return err;
 }
diff --git a/common/name-value.h b/common/name-value.h
index 5c24b8db1..a6283a649 100644
--- a/common/name-value.h
+++ b/common/name-value.h
@@ -1,120 +1,126 @@
 /* name-value.h - Parser and writer for a name-value format.
  *	Copyright (C) 2016 g10 Code GmbH
  *
  * This file is part of GnuPG.
  *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of either
  *
  *   - the GNU Lesser General Public License as published by the Free
  *     Software Foundation; either version 3 of the License, or (at
  *     your option) any later version.
  *
  * or
  *
  *   - the GNU General Public License as published by the Free
  *     Software Foundation; either version 2 of the License, or (at
  *     your option) any later version.
  *
  * or both in parallel, as here.
  *
  * GnuPG is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #ifndef GNUPG_COMMON_NAME_VALUE_H
 #define GNUPG_COMMON_NAME_VALUE_H
 
 struct name_value_container;
 typedef struct name_value_container *nvc_t;
 
 struct name_value_entry;
 typedef struct name_value_entry *nve_t;
 
 
 
 /* Memory management, and dealing with entries.  */
 
 /* Allocate a name value container structure.  */
 nvc_t nvc_new (void);
 
 /* Allocate a name value container structure for use with the extended
  * private key format.  */
 nvc_t nvc_new_private_key (void);
 
 /* Release a name value container structure.  */
 void nvc_release (nvc_t pk);
 
 /* Get the name.  */
 char *nve_name (nve_t pke);
 
 /* Get the value.  */
 char *nve_value (nve_t pke);
 
 
 
 /* Lookup and iteration.  */
 
 /* Get the first non-comment entry.  */
 nve_t nvc_first (nvc_t pk);
 
 /* Get the first entry with the given name.  */
 nve_t nvc_lookup (nvc_t pk, const char *name);
 
 /* Get the next non-comment entry.  */
 nve_t nve_next (nve_t entry);
 
 /* Get the next entry with the given name.  */
 nve_t nve_next_value (nve_t entry, const char *name);
 
+/* Return the string for the first entry in NVC with NAME or NULL.  */
+const char *nvc_get_string (nvc_t nvc, const char *name);
+
 
 
 /* Adding and modifying values.  */
 
 /* Add (NAME, VALUE) to PK.  If an entry with NAME already exists, it
    is not updated but the new entry is appended.  */
 gpg_error_t nvc_add (nvc_t pk, const char *name, const char *value);
 
 /* Add (NAME, VALUE) to PK.  If an entry with NAME already exists, it
    is updated with VALUE.  If multiple entries with NAME exist, the
    first entry is updated.  */
 gpg_error_t nvc_set (nvc_t pk, const char *name, const char *value);
 
 /* Delete the given entry from PK.  */
 void nvc_delete (nvc_t pk, nve_t pke);
 
+/* Delete the entries with NAME from PK.  */
+void nvc_delete_named (nvc_t pk, const char *name);
+
 
 
 /* Private key handling.  */
 
 /* Get the private key.  */
 gpg_error_t nvc_get_private_key (nvc_t pk, gcry_sexp_t *retsexp);
 
 /* Set the private key.  */
 gpg_error_t nvc_set_private_key (nvc_t pk, gcry_sexp_t sexp);
 
 
 
 /* Parsing and serialization.  */
 
 /* Parse STREAM and return a newly allocated name-value container
    structure in RESULT.  If ERRLINEP is given, the line number the
    parser was last considering is stored there.  */
 gpg_error_t nvc_parse (nvc_t *result, int *errlinep, estream_t stream);
 
 /* Parse STREAM and return a newly allocated name value container
    structure in RESULT - assuming the extended private key format.  If
    ERRLINEP is given, the line number the parser was last considering
    is stored there.  */
 gpg_error_t nvc_parse_private_key (nvc_t *result, int *errlinep,
                                    estream_t stream);
 
 /* Write a representation of PK to STREAM.  */
 gpg_error_t nvc_write (nvc_t pk, estream_t stream);
 
 #endif /* GNUPG_COMMON_NAME_VALUE_H */
diff --git a/common/t-name-value.c b/common/t-name-value.c
index 57f685ffb..13a383ddb 100644
--- a/common/t-name-value.c
+++ b/common/t-name-value.c
@@ -1,593 +1,618 @@
 /* t-name-value.c - Module test for name-value.c
  *	Copyright (C) 2016 g10 Code GmbH
  *
  * This file is part of GnuPG.
  *
  * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <assert.h>
 #include <unistd.h>
 #include <sys/stat.h>
 
 #include "util.h"
 #include "name-value.h"
 
 static int verbose;
 static int private_key_mode;
 
 
 static nvc_t
 my_nvc_new (void)
 {
   if (private_key_mode)
     return nvc_new_private_key ();
   else
     return nvc_new ();
 }
 
 
 void
 test_getting_values (nvc_t pk)
 {
   nve_t e;
 
   e = nvc_lookup (pk, "Comment:");
   assert (e);
 
   /* Names are case-insensitive.  */
   e = nvc_lookup (pk, "comment:");
   assert (e);
   e = nvc_lookup (pk, "COMMENT:");
   assert (e);
 
   e = nvc_lookup (pk, "SomeOtherName:");
   assert (e);
 }
 
 
 void
 test_key_extraction (nvc_t pk)
 {
   gpg_error_t err;
   gcry_sexp_t key;
 
   if (private_key_mode)
     {
       err = nvc_get_private_key (pk, &key);
       assert (err == 0);
       assert (key);
 
       if (verbose)
         gcry_sexp_dump (key);
 
       gcry_sexp_release (key);
     }
   else
     {
       err = nvc_get_private_key (pk, &key);
       assert (gpg_err_code (err) == GPG_ERR_MISSING_KEY);
     }
 }
 
 
 void
 test_iteration (nvc_t pk)
 {
   int i;
   nve_t e;
 
   i = 0;
   for (e = nvc_first (pk); e; e = nve_next (e))
     i++;
   assert (i == 4);
 
   i = 0;
   for (e = nvc_lookup (pk, "Comment:");
        e;
        e = nve_next_value (e, "Comment:"))
     i++;
   assert (i == 3);
 }
 
 
 void
 test_whitespace (nvc_t pk)
 {
   nve_t e;
 
   e = nvc_lookup (pk, "One:");
   assert (e);
   assert (strcmp (nve_value (e), "WithoutWhitespace") == 0);
 
   e = nvc_lookup (pk, "Two:");
   assert (e);
   assert (strcmp (nve_value (e), "With Whitespace") == 0);
 
   e = nvc_lookup (pk, "Three:");
   assert (e);
   assert (strcmp (nve_value (e),
                   "Blank lines in continuations encode newlines.\n"
                   "Next paragraph.") == 0);
 }
 
 
 struct
 {
   char *value;
   void (*test_func) (nvc_t);
 } tests[] =
   {
     {
       "# This is a comment followed by an empty line\n"
       "\n",
       NULL,
     },
     {
       "# This is a comment followed by two empty lines, Windows style\r\n"
       "\r\n"
       "\r\n",
       NULL,
     },
     {
       "# Some name,value pairs\n"
       "Comment: Some comment.\n"
       "SomeOtherName: Some value.\n",
       test_getting_values,
     },
     {
       "  # Whitespace is preserved as much as possible\r\n"
       "Comment:Some comment.\n"
       "SomeOtherName: Some value.   \n",
       test_getting_values,
     },
     {
       "# Values may be continued in the next line as indicated by leading\n"
       "# space\n"
       "Comment: Some rather long\n"
       "  comment that is continued in the next line.\n"
       "\n"
       "  Blank lines with or without whitespace are allowed within\n"
       "  continuations to allow paragraphs.\n"
       "SomeOtherName: Some value.\n",
       test_getting_values,
     },
     {
       "# Names may be given multiple times forming an array of values\n"
       "Comment: Some comment, element 0.\n"
       "Comment: Some comment, element 1.\n"
       "Comment: Some comment, element 2.\n"
       "SomeOtherName: Some value.\n",
       test_iteration,
     },
     {
       "# One whitespace at the beginning of a continuation is swallowed.\n"
       "One: Without\n"
       " Whitespace\n"
       "Two: With\n"
       "  Whitespace\n"
       "Three: Blank lines in continuations encode newlines.\n"
       "\n"
       "  Next paragraph.\n",
       test_whitespace,
     },
     {
       "Description: Key to sign all GnuPG released tarballs.\n"
       "  The key is actually stored on a smart card.\n"
       "Use-for-ssh: yes\n"
       "OpenSSH-cert: long base64 encoded string wrapped so that this\n"
       "  key file can be easily edited with a standard editor.\n"
       "Key: (shadowed-private-key\n"
       "  (rsa\n"
       "  (n #00AA1AD2A55FD8C8FDE9E1941772D9CC903FA43B268CB1B5A1BAFDC900\n"
       "  2961D8AEA153424DC851EF13B83AC64FBE365C59DC1BD3E83017C90D4365B4\n"
       "  83E02859FC13DB5842A00E969480DB96CE6F7D1C03600392B8E08EF0C01FC7\n"
       "  19F9F9086B25AD39B4F1C2A2DF3E2BE317110CFFF21D4A11455508FE407997\n"
       "  601260816C8422297C0637BB291C3A079B9CB38A92CE9E551F80AA0EBF4F0E\n"
       "  72C3F250461E4D31F23A7087857FC8438324A013634563D34EFDDCBF2EA80D\n"
       "  F9662C9CCD4BEF2522D8BDFED24CEF78DC6B309317407EAC576D889F88ADA0\n"
       "  8C4FFB480981FB68C5C6CA27503381D41018E6CDC52AAAE46B166BDC10637A\n"
       "  E186A02BA2497FDC5D1221#)\n"
       "  (e #00010001#)\n"
       "  (shadowed t1-v1\n"
       "   (#D2760001240102000005000011730000# OPENPGP.1)\n"
       "    )))\n",
       test_key_extraction,
     },
   };
 
 
 static char *
 nvc_to_string (nvc_t pk)
 {
   gpg_error_t err;
   char *buf;
   size_t len;
   estream_t sink;
 
   sink = es_fopenmem (0, "rw");
   assert (sink);
 
   err = nvc_write (pk, sink);
   assert (err == 0);
 
   len = es_ftell (sink);
   buf = xmalloc (len+1);
   assert (buf);
 
   es_fseek (sink, 0, SEEK_SET);
   es_read (sink, buf, len, NULL);
   buf[len] = 0;
 
   es_fclose (sink);
   return buf;
 }
 
 
 void dummy_free (void *p) { (void) p; }
 void *dummy_realloc (void *p, size_t s) { (void) s; return p; }
 
 void
 run_tests (void)
 {
   gpg_error_t err;
   nvc_t pk;
 
   int i;
   for (i = 0; i < DIM (tests); i++)
     {
       estream_t source;
       char *buf;
       size_t len;
 
       len = strlen (tests[i].value);
       source = es_mopen (tests[i].value, len, len,
 			 0, dummy_realloc, dummy_free, "r");
       assert (source);
 
       if (private_key_mode)
         err = nvc_parse_private_key (&pk, NULL, source);
       else
         err = nvc_parse (&pk, NULL, source);
       assert (err == 0);
       assert (pk);
 
       if (verbose)
 	{
 	  err = nvc_write (pk, es_stderr);
 	  assert (err == 0);
 	}
 
       buf = nvc_to_string (pk);
       assert (memcmp (tests[i].value, buf, len) == 0);
 
       es_fclose (source);
       xfree (buf);
 
       if (tests[i].test_func)
 	tests[i].test_func (pk);
 
       nvc_release (pk);
     }
 }
 
 
 void
 run_modification_tests (void)
 {
   gpg_error_t err;
   nvc_t pk;
+  nve_t e;
   gcry_sexp_t key;
   char *buf;
 
   pk = my_nvc_new ();
   assert (pk);
 
   nvc_set (pk, "Foo:", "Bar");
   buf = nvc_to_string (pk);
   assert (strcmp (buf, "Foo: Bar\n") == 0);
   xfree (buf);
 
   nvc_set (pk, "Foo:", "Baz");
   buf = nvc_to_string (pk);
   assert (strcmp (buf, "Foo: Baz\n") == 0);
   xfree (buf);
 
   nvc_set (pk, "Bar:", "Bazzel");
   buf = nvc_to_string (pk);
   assert (strcmp (buf, "Foo: Baz\nBar: Bazzel\n") == 0);
   xfree (buf);
 
   nvc_add (pk, "Foo:", "Bar");
   buf = nvc_to_string (pk);
   assert (strcmp (buf, "Foo: Baz\nFoo: Bar\nBar: Bazzel\n") == 0);
   xfree (buf);
 
   nvc_add (pk, "DontExistYet:", "Bar");
   buf = nvc_to_string (pk);
   assert (strcmp (buf, "Foo: Baz\nFoo: Bar\nBar: Bazzel\nDontExistYet: Bar\n")
 	  == 0);
   xfree (buf);
 
   nvc_delete (pk, nvc_lookup (pk, "DontExistYet:"));
   buf = nvc_to_string (pk);
   assert (strcmp (buf, "Foo: Baz\nFoo: Bar\nBar: Bazzel\n") == 0);
   xfree (buf);
 
   nvc_delete (pk, nve_next_value (nvc_lookup (pk, "Foo:"), "Foo:"));
   buf = nvc_to_string (pk);
   assert (strcmp (buf, "Foo: Baz\nBar: Bazzel\n") == 0);
   xfree (buf);
 
   nvc_delete (pk, nvc_lookup (pk, "Foo:"));
   buf = nvc_to_string (pk);
   assert (strcmp (buf, "Bar: Bazzel\n") == 0);
   xfree (buf);
 
   nvc_delete (pk, nvc_first (pk));
   buf = nvc_to_string (pk);
   assert (strcmp (buf, "") == 0);
   xfree (buf);
 
+  /* Test whether we can delete an entry by name.  */
+  err = nvc_add (pk, "Key:", "(3:foo)");
+  assert (!err);
+  e = nvc_lookup (pk, "Key:");
+  assert (e);
+  nvc_delete_named (pk, "Kez:");  /* Delete an inexistant name.  */
+  e = nvc_lookup (pk, "Key:");
+  assert (e);
+  nvc_delete_named (pk, "Key:");
+  e = nvc_lookup (pk, "Key:");
+  assert (!e);
+
+  /* Ditto but now whether it deletes all entries with that name.  We
+   * don't use "Key" because that name is special in private key mode.  */
+  err = nvc_add (pk, "AKey:", "A-value");
+  assert (!err);
+  err = nvc_add (pk, "AKey:", "B-value");
+  assert (!err);
+  e = nvc_lookup (pk, "AKey:");
+  assert (e);
+  nvc_delete_named (pk, "AKey:");
+  e = nvc_lookup (pk, "AKey:");
+  assert (!e);
+
   nvc_set (pk, "Foo:", "A really long value spanning across multiple lines"
 	   " that has to be wrapped at a convenient space.");
   buf = nvc_to_string (pk);
   assert (strcmp (buf, "Foo: A really long value spanning across multiple"
 		  " lines that has to be\n  wrapped at a convenient space.\n")
 	  == 0);
   xfree (buf);
 
   nvc_set (pk, "Foo:", "XA really long value spanning across multiple lines"
 	   " that has to be wrapped at a convenient space.");
   buf = nvc_to_string (pk);
   assert (strcmp (buf, "Foo: XA really long value spanning across multiple"
 		  " lines that has to\n  be wrapped at a convenient space.\n")
 	  == 0);
   xfree (buf);
 
   nvc_set (pk, "Foo:", "XXXXA really long value spanning across multiple lines"
 	   " that has to be wrapped at a convenient space.");
   buf = nvc_to_string (pk);
   assert (strcmp (buf, "Foo: XXXXA really long value spanning across multiple"
 		  " lines that has\n  to be wrapped at a convenient space.\n")
 	  == 0);
   xfree (buf);
 
   nvc_set (pk, "Foo:", "Areallylongvaluespanningacrossmultiplelines"
 	   "thathastobewrappedataconvenientspacethatisnotthere.");
   buf = nvc_to_string (pk);
   assert (strcmp (buf, "Foo: Areallylongvaluespanningacrossmultiplelinesthat"
 		  "hastobewrappedataco\n nvenientspacethatisnotthere.\n")
 	  == 0);
   xfree (buf);
   nvc_release (pk);
 
   pk = my_nvc_new ();
   assert (pk);
 
   err = gcry_sexp_build (&key, NULL, "(hello world)");
   assert (err == 0);
   assert (key);
 
   if (private_key_mode)
     {
       err = nvc_set_private_key (pk, key);
       assert (err == 0);
 
       buf = nvc_to_string (pk);
       assert (strcmp (buf, "Key: (hello world)\n") == 0);
       xfree (buf);
     }
   else
     {
       err = nvc_set_private_key (pk, key);
       assert (gpg_err_code (err) == GPG_ERR_MISSING_KEY);
     }
   gcry_sexp_release (key);
   nvc_release (pk);
 }
 
 
 void
 convert (const char *fname)
 {
   gpg_error_t err;
   estream_t source;
   gcry_sexp_t key;
   char *buf;
   size_t buflen;
   struct stat st;
   nvc_t pk;
 
   source = es_fopen (fname, "rb");
   if (source == NULL)
     goto leave;
 
   if (fstat (es_fileno (source), &st))
     goto leave;
 
   buflen = st.st_size;
   buf = xtrymalloc (buflen+1);
   assert (buf);
 
   if (es_fread (buf, buflen, 1, source) != 1)
     goto leave;
 
   err = gcry_sexp_sscan (&key, NULL, buf, buflen);
   if (err)
     {
       fprintf (stderr, "malformed s-expression in %s\n", fname);
       exit (1);
     }
 
   pk = my_nvc_new ();
   assert (pk);
 
   err = nvc_set_private_key (pk, key);
   assert (err == 0);
 
   err = nvc_write (pk, es_stdout);
   assert (err == 0);
 
   return;
 
  leave:
   perror (fname);
   exit (1);
 }
 
 
 void
 parse (const char *fname)
 {
   gpg_error_t err;
   estream_t source;
   char *buf;
   nvc_t pk_a, pk_b;
   nve_t e;
   int line;
 
   source = es_fopen (fname, "rb");
   if (source == NULL)
     {
       perror (fname);
       exit (1);
     }
 
   if (private_key_mode)
     err = nvc_parse_private_key (&pk_a, &line, source);
   else
     err = nvc_parse (&pk_a, &line, source);
   if (err)
     {
       fprintf (stderr, "failed to parse %s line %d: %s\n",
 	       fname, line, gpg_strerror (err));
       exit (1);
     }
 
   buf = nvc_to_string (pk_a);
   xfree (buf);
 
   pk_b = my_nvc_new ();
   assert (pk_b);
 
   for (e = nvc_first (pk_a); e; e = nve_next (e))
     {
       gcry_sexp_t key = NULL;
 
       if (private_key_mode && !strcasecmp (nve_name (e), "Key:"))
 	{
 	  err = nvc_get_private_key (pk_a, &key);
 	  if (err)
 	    key = NULL;
 	}
 
       if (key)
 	{
 	  err = nvc_set_private_key (pk_b, key);
 	  assert (err == 0);
 	}
       else
 	{
 	  err = nvc_add (pk_b, nve_name (e), nve_value (e));
 	  assert (err == 0);
 	}
     }
 
     buf = nvc_to_string (pk_b);
     if (verbose)
       fprintf (stdout, "%s", buf);
     xfree (buf);
 }
 
 
 void
 print_usage (void)
 {
   fprintf (stderr,
 	   "usage: t-private-keys [--verbose]"
 	   " [--convert <private-key-file>"
 	   " || --parse-key <extended-private-key-file>"
            " || --parse <file> ]\n");
   exit (2);
 }
 
 
 int
 main (int argc, char **argv)
 {
   enum { TEST, CONVERT, PARSE, PARSEKEY } command = TEST;
 
   if (argc)
     { argc--; argv++; }
   if (argc && !strcmp (argv[0], "--verbose"))
     {
       verbose = 1;
       argc--; argv++;
     }
 
   if (argc && !strcmp (argv[0], "--convert"))
     {
       command = CONVERT;
       argc--; argv++;
       if (argc != 1)
 	print_usage ();
     }
 
   if (argc && !strcmp (argv[0], "--parse-key"))
     {
       command = PARSEKEY;
       argc--; argv++;
       if (argc != 1)
 	print_usage ();
     }
 
   if (argc && !strcmp (argv[0], "--parse"))
     {
       command = PARSE;
       argc--; argv++;
       if (argc != 1)
 	print_usage ();
     }
 
   switch (command)
     {
     case TEST:
       run_tests ();
       run_modification_tests ();
       private_key_mode = 1;
       run_tests ();
       run_modification_tests ();
       break;
 
     case CONVERT:
       convert (*argv);
       break;
 
     case PARSEKEY:
       private_key_mode = 1;
       parse (*argv);
       break;
 
     case PARSE:
       parse (*argv);
       break;
     }
 
   return 0;
 }