summaryrefslogtreecommitdiffstats
path: root/common/name-value.c
diff options
context:
space:
mode:
Diffstat (limited to 'common/name-value.c')
-rw-r--r--common/name-value.c908
1 files changed, 908 insertions, 0 deletions
diff --git a/common/name-value.c b/common/name-value.c
new file mode 100644
index 0000000..b9b13d1
--- /dev/null
+++ b/common/name-value.c
@@ -0,0 +1,908 @@
+/* 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; i--)
+ if (ascii_isspace (entry->value[offset+i]))
+ break;
+
+ if (ascii_isspace (entry->value[offset+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)
+ return nve_set (e, value);
+ else
+ return nvc_add (pk, name, value);
+}
+
+
+/* Update entry E to VALUE. */
+gpg_error_t
+nve_set (nve_t e, const char *value)
+{
+ char *v;
+
+ if (!e)
+ return GPG_ERR_INV_ARG;
+
+ v = xtrystrdup (value? value:"");
+ if (!v)
+ 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;
+}
+
+
+/* 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;
+
+ if (!pk)
+ return NULL;
+
+ for (entry = pk->first; entry; entry = entry->next)
+ if (entry->name)
+ return entry;
+
+ return NULL;
+}
+
+
+/* Get the first entry with the given name. Return NULL if it does
+ * not exist. */
+nve_t
+nvc_lookup (nvc_t pk, const char *name)
+{
+ nve_t entry;
+
+ if (!pk)
+ return NULL;
+
+ 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 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);
+}
+
+
+/* Return true if NAME exists and its value is true; that is either
+ * "yes", "true", or a decimal value unequal to 0. */
+int
+nvc_get_boolean (nvc_t nvc, const char *name)
+{
+ nve_t item;
+ const char *s;
+
+ if (!nvc)
+ return 0;
+ item = nvc_lookup (nvc, name);
+ if (!item)
+ return 0;
+ s = nve_value (item);
+ if (s && (atoi (s)
+ || !ascii_strcasecmp (s, "yes")
+ || !ascii_strcasecmp (s, "true")))
+ return 1;
+ return 0;
+}
+
+
+
+/* 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);
+ name = NULL;
+ 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;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-17 13:50:22 +0000