New upstream version 1.32.12 upstream/1.32.12

1 files changed, 594 insertions, 0 deletions

diff --git a/src/libnm-core-impl/nm-setting-user.c b/src/libnm-core-impl/nm-setting-user.c
new file mode 100644
index 00000000..0f99baa2
--- /dev/null
+++ b/src/libnm-core-impl/nm-setting-user.c
@@ -0,0 +1,594 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2017 Red Hat, Inc.
+ */
+
+#include "libnm-core-impl/nm-default-libnm-core.h"
+
+#include "nm-setting-user.h"
+
+#include "nm-setting.h"
+#include "nm-setting-private.h"
+#include "nm-utils-private.h"
+
+/**
+ * SECTION:nm-setting-user
+ * @short_description: Describes user properties
+ *
+ * The #NMSettingUser object is a #NMSetting subclass that allow to attach
+ * arbitrary user data to #NMConnection objects.
+ **/
+
+#define MAX_NUM_KEYS 256
+
+/*****************************************************************************/
+
+NM_GOBJECT_PROPERTIES_DEFINE(NMSettingUser, PROP_DATA, );
+
+typedef struct {
+    GHashTable * data;
+    GHashTable * data_invalid;
+    const char **keys;
+} NMSettingUserPrivate;
+
+/**
+ * NMSettingUser:
+ *
+ * General User Profile Settings
+ */
+struct _NMSettingUser {
+    NMSetting            parent;
+    NMSettingUserPrivate _priv;
+};
+
+struct _NMSettingUserClass {
+    NMSettingClass parent;
+};
+
+G_DEFINE_TYPE(NMSettingUser, nm_setting_user, NM_TYPE_SETTING)
+
+#define NM_SETTING_USER_GET_PRIVATE(self) _NM_GET_PRIVATE(self, NMSettingUser, NM_IS_SETTING_USER)
+
+/*****************************************************************************/
+
+static gboolean
+_key_char_is_regular(char ch)
+{
+    /* allow words of printable characters, plus some
+     * special characters, for example to support base64 encoding. */
+    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9')
+           || NM_IN_SET(ch, '-', '_', '+', '/', '=');
+}
+
+/**
+ * nm_setting_user_check_key:
+ * @key: the key to check
+ * @error: a #GError, %NULL to ignore.
+ *
+ * Checks whether @key is a valid user data key. This means,
+ * key is not %NULL, not too large and valid ASCII. Also,
+ * only digits and numbers are allowed with a few special
+ * characters. The key must contain at least one '.' and
+ * look like a fully qualified DNS name.
+ *
+ * Since: 1.8
+ *
+ * Returns: %TRUE if @key is a valid user data key.
+ */
+gboolean
+nm_setting_user_check_key(const char *key, GError **error)
+{
+    gsize    len;
+    gboolean has_dot;
+    char     ch;
+
+    g_return_val_if_fail(!error || !*error, FALSE);
+
+    if (!key || !key[0]) {
+        g_set_error_literal(error,
+                            NM_CONNECTION_ERROR,
+                            NM_CONNECTION_ERROR_INVALID_PROPERTY,
+                            _("missing key"));
+        return FALSE;
+    }
+    len = strlen(key);
+    if (len > 255) {
+        g_set_error_literal(error,
+                            NM_CONNECTION_ERROR,
+                            NM_CONNECTION_ERROR_INVALID_PROPERTY,
+                            _("key is too long"));
+        return FALSE;
+    }
+    if (!g_utf8_validate(key, len, NULL)) {
+        g_set_error_literal(error,
+                            NM_CONNECTION_ERROR,
+                            NM_CONNECTION_ERROR_INVALID_PROPERTY,
+                            _("key must be UTF8"));
+        return FALSE;
+    }
+
+    has_dot = FALSE;
+    while (TRUE) {
+        ch = (key++)[0];
+
+        /* Allow something that looks like a FQN, separating namespaces by a single '.'
+         * We want to print the keys nicely in nmcli requiring escaping.
+         *
+         * If a user really has to encode special values in the name, he may base64 encode it. */
+
+        if (!_key_char_is_regular(ch))
+            break;
+
+        while (_key_char_is_regular(key[0]))
+            key++;
+
+        ch = key[0];
+        if (ch == '\0') {
+            if (!has_dot) {
+                g_set_error_literal(error,
+                                    NM_CONNECTION_ERROR,
+                                    NM_CONNECTION_ERROR_INVALID_PROPERTY,
+                                    _("key requires a '.' for a namespace"));
+                return FALSE;
+            }
+            return TRUE;
+        }
+
+        if (ch != '.')
+            break;
+
+        has_dot = TRUE;
+        ch      = (++key)[0];
+        if (ch == '.') {
+            g_set_error_literal(error,
+                                NM_CONNECTION_ERROR,
+                                NM_CONNECTION_ERROR_INVALID_PROPERTY,
+                                _("key cannot contain \"..\""));
+            return FALSE;
+        }
+    }
+    g_set_error_literal(error,
+                        NM_CONNECTION_ERROR,
+                        NM_CONNECTION_ERROR_INVALID_PROPERTY,
+                        _("key contains invalid characters"));
+    return FALSE;
+}
+
+/**
+ * nm_setting_user_check_val:
+ * @val: the value to check
+ * @error: a #GError, %NULL to ignore.
+ *
+ * Checks whether @val is a valid user data value. This means,
+ * value is not %NULL, not too large and valid UTF-8.
+ *
+ * Since: 1.8
+ *
+ * Returns: %TRUE if @val is a valid user data value.
+ */
+gboolean
+nm_setting_user_check_val(const char *val, GError **error)
+{
+    gsize len;
+
+    g_return_val_if_fail(!error || !*error, FALSE);
+
+    if (!val) {
+        g_set_error_literal(error,
+                            NM_CONNECTION_ERROR,
+                            NM_CONNECTION_ERROR_INVALID_PROPERTY,
+                            _("value is missing"));
+        return FALSE;
+    }
+
+    len = strlen(val);
+    if (len > 8 * 1024) {
+        g_set_error_literal(error,
+                            NM_CONNECTION_ERROR,
+                            NM_CONNECTION_ERROR_INVALID_PROPERTY,
+                            _("value is too large"));
+        return FALSE;
+    }
+
+    if (!g_utf8_validate(val, len, NULL)) {
+        g_set_error_literal(error,
+                            NM_CONNECTION_ERROR,
+                            NM_CONNECTION_ERROR_INVALID_PROPERTY,
+                            _("value is not valid UTF8"));
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/*****************************************************************************/
+
+static GHashTable *
+_create_data_hash(void)
+{
+    return g_hash_table_new_full(nm_str_hash, g_str_equal, g_free, g_free);
+}
+
+/**
+ * nm_setting_user_get_keys:
+ * @setting: the #NMSettingUser
+ * @out_len: (out): the length of the returned array
+ *
+ * Returns: (array length=out_len) (transfer none): a
+ *   %NULL-terminated array containing each key from the table.
+  **/
+const char *const *
+nm_setting_user_get_keys(NMSettingUser *setting, guint *out_len)
+{
+    NMSettingUser *       self = setting;
+    NMSettingUserPrivate *priv;
+
+    g_return_val_if_fail(NM_IS_SETTING_USER(self), NULL);
+
+    priv = NM_SETTING_USER_GET_PRIVATE(self);
+
+    if (priv->keys) {
+        NM_SET_OUT(out_len, g_hash_table_size(priv->data));
+        return priv->keys;
+    }
+
+    priv->keys = nm_utils_strdict_get_keys(priv->data, TRUE, out_len);
+
+    /* don't return %NULL, but hijack the @keys fields as a pseudo
+     * empty strv array. */
+    return priv->keys ?: ((const char **) &priv->keys);
+}
+
+/*****************************************************************************/
+
+/**
+ * nm_setting_user_get_data:
+ * @setting: the #NMSettingUser instance
+ * @key: the key to lookup
+ *
+ * Since: 1.8
+ *
+ * Returns: (transfer none): the value associated with @key or %NULL if no such
+ *   value exists.
+ */
+const char *
+nm_setting_user_get_data(NMSettingUser *setting, const char *key)
+{
+    NMSettingUser *       self = setting;
+    NMSettingUserPrivate *priv;
+
+    g_return_val_if_fail(NM_IS_SETTING_USER(self), NULL);
+    g_return_val_if_fail(key, NULL);
+
+    priv = NM_SETTING_USER_GET_PRIVATE(self);
+
+    if (!priv->data)
+        return NULL;
+
+    return g_hash_table_lookup(priv->data, key);
+}
+
+/**
+ * nm_setting_user_set_data:
+ * @setting: the #NMSettingUser instance
+ * @key: the key to set
+ * @val: (allow-none): the value to set or %NULL to clear a key.
+ * @error: (allow-none): optional error argument
+ *
+ * Since: 1.8
+ *
+ * Returns: %TRUE if the operation was successful. The operation
+ *   can fail if @key or @val are not valid strings according
+ *   to nm_setting_user_check_key() and nm_setting_user_check_val().
+ */
+gboolean
+nm_setting_user_set_data(NMSettingUser *setting, const char *key, const char *val, GError **error)
+{
+    NMSettingUser *       self = setting;
+    NMSettingUserPrivate *priv;
+    gboolean              changed = FALSE;
+
+    g_return_val_if_fail(NM_IS_SETTING_USER(self), FALSE);
+    g_return_val_if_fail(!error || !*error, FALSE);
+
+    if (!nm_setting_user_check_key(key, error))
+        return FALSE;
+
+    if (val && !nm_setting_user_check_val(val, error))
+        return FALSE;
+
+    priv = NM_SETTING_USER_GET_PRIVATE(self);
+
+    if (!val) {
+        if (priv->data && g_hash_table_remove(priv->data, key)) {
+            nm_clear_g_free(&priv->keys);
+            changed = TRUE;
+        }
+        goto out;
+    }
+
+    if (priv->data) {
+        const char *key2, *val2;
+
+        if (g_hash_table_lookup_extended(priv->data, key, (gpointer *) &key2, (gpointer *) &val2)) {
+            if (nm_streq(val, val2))
+                goto out;
+        } else {
+            if (g_hash_table_size(priv->data) >= MAX_NUM_KEYS) {
+                /* limit the number of valid keys */
+                g_set_error_literal(error,
+                                    NM_CONNECTION_ERROR,
+                                    NM_CONNECTION_ERROR_INVALID_PROPERTY,
+                                    _("maximum number of user data entries reached"));
+                return FALSE;
+            }
+
+            nm_clear_g_free(&priv->keys);
+        }
+    } else
+        priv->data = _create_data_hash();
+
+    g_hash_table_insert(priv->data, g_strdup(key), g_strdup(val));
+    changed = TRUE;
+
+out:
+    if (priv->data_invalid) {
+        /* setting a value purges all invalid values that were set
+         * via GObject property. */
+        changed = TRUE;
+        nm_clear_pointer(&priv->data_invalid, g_hash_table_unref);
+    }
+    if (changed)
+        _notify(self, PROP_DATA);
+    return TRUE;
+}
+
+/*****************************************************************************/
+
+static gboolean
+verify(NMSetting *setting, NMConnection *connection, GError **error)
+{
+    NMSettingUser *       self = NM_SETTING_USER(setting);
+    NMSettingUserPrivate *priv = NM_SETTING_USER_GET_PRIVATE(self);
+
+    if (priv->data_invalid) {
+        const char *   key, *val;
+        GHashTableIter iter;
+        gs_free_error GError *local = NULL;
+
+        g_hash_table_iter_init(&iter, priv->data_invalid);
+        while (g_hash_table_iter_next(&iter, (gpointer *) &key, (gpointer *) &val)) {
+            if (!nm_setting_user_check_key(key, &local)) {
+                g_set_error(error,
+                            NM_CONNECTION_ERROR,
+                            NM_CONNECTION_ERROR_FAILED,
+                            _("invalid key \"%s\": %s"),
+                            key,
+                            local->message);
+            } else if (!nm_setting_user_check_val(val, &local)) {
+                g_set_error(error,
+                            NM_CONNECTION_ERROR,
+                            NM_CONNECTION_ERROR_FAILED,
+                            _("invalid value for \"%s\": %s"),
+                            key,
+                            local->message);
+            } else {
+                nm_assert_not_reached();
+                continue;
+            }
+            g_prefix_error(error, "%s.%s: ", NM_SETTING_USER_SETTING_NAME, NM_SETTING_USER_DATA);
+            return FALSE;
+        }
+        nm_assert_not_reached();
+    }
+
+    if (priv->data && g_hash_table_size(priv->data) > MAX_NUM_KEYS) {
+        g_set_error(error,
+                    NM_CONNECTION_ERROR,
+                    NM_CONNECTION_ERROR_INVALID_PROPERTY,
+                    _("maximum number of user data entries reached (%u instead of %u)"),
+                    g_hash_table_size(priv->data),
+                    (unsigned) MAX_NUM_KEYS);
+        g_prefix_error(error, "%s.%s: ", NM_SETTING_USER_SETTING_NAME, NM_SETTING_USER_DATA);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static NMTernary
+compare_property(const NMSettInfoSetting *sett_info,
+                 guint                    property_idx,
+                 NMConnection *           con_a,
+                 NMSetting *              set_a,
+                 NMConnection *           con_b,
+                 NMSetting *              set_b,
+                 NMSettingCompareFlags    flags)
+{
+    NMSettingUserPrivate *priv, *pri2;
+
+    if (nm_streq(sett_info->property_infos[property_idx].name, NM_SETTING_USER_DATA)) {
+        if (NM_FLAGS_HAS(flags, NM_SETTING_COMPARE_FLAG_INFERRABLE))
+            return NM_TERNARY_DEFAULT;
+
+        if (!set_b)
+            return TRUE;
+
+        priv = NM_SETTING_USER_GET_PRIVATE(NM_SETTING_USER(set_a));
+        pri2 = NM_SETTING_USER_GET_PRIVATE(NM_SETTING_USER(set_b));
+        return nm_utils_hashtable_equal(priv->data, pri2->data, TRUE, g_str_equal)
+               && nm_utils_hashtable_equal(priv->data_invalid,
+                                           pri2->data_invalid,
+                                           TRUE,
+                                           g_str_equal);
+    }
+
+    return NM_SETTING_CLASS(nm_setting_user_parent_class)
+        ->compare_property(sett_info, property_idx, con_a, set_a, con_b, set_b, flags);
+}
+
+/*****************************************************************************/
+
+static void
+get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+    NMSettingUser *       self = NM_SETTING_USER(object);
+    NMSettingUserPrivate *priv = NM_SETTING_USER_GET_PRIVATE(self);
+    GHashTableIter        iter;
+    GHashTable *          data;
+    const char *          key, *val;
+
+    switch (prop_id) {
+    case PROP_DATA:
+        data = _create_data_hash();
+        if (priv->data) {
+            g_hash_table_iter_init(&iter, priv->data);
+            while (g_hash_table_iter_next(&iter, (gpointer *) &key, (gpointer *) &val))
+                g_hash_table_insert(data, g_strdup(key), g_strdup(val));
+        }
+        if (priv->data_invalid) {
+            g_hash_table_iter_init(&iter, priv->data_invalid);
+            while (g_hash_table_iter_next(&iter, (gpointer *) &key, (gpointer *) &val))
+                g_hash_table_insert(data, g_strdup(key), g_strdup(val));
+        }
+        g_value_take_boxed(value, data);
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+        break;
+    }
+}
+
+static void
+set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+    NMSettingUser *       self = NM_SETTING_USER(object);
+    NMSettingUserPrivate *priv = NM_SETTING_USER_GET_PRIVATE(self);
+    GHashTableIter        iter;
+    GHashTable *          data;
+    const char *          key, *val;
+
+    switch (prop_id) {
+    case PROP_DATA:
+        nm_clear_g_free(&priv->keys);
+
+        data = g_value_get_boxed(value);
+        if (!data || !g_hash_table_size(data)) {
+            nm_clear_pointer(&priv->data, g_hash_table_unref);
+            nm_clear_pointer(&priv->data_invalid, g_hash_table_unref);
+            return;
+        }
+
+        if (priv->data)
+            g_hash_table_remove_all(priv->data);
+        else
+            priv->data = _create_data_hash();
+
+        if (priv->data_invalid)
+            g_hash_table_remove_all(priv->data_invalid);
+
+        g_hash_table_iter_init(&iter, data);
+        while (g_hash_table_iter_next(&iter, (gpointer *) &key, (gpointer *) &val)) {
+            if (nm_setting_user_check_key(key, NULL) && nm_setting_user_check_val(val, NULL))
+                g_hash_table_insert(priv->data, g_strdup(key), g_strdup(val));
+            else {
+                if (!priv->data_invalid)
+                    priv->data_invalid = _create_data_hash();
+                g_hash_table_insert(priv->data_invalid, g_strdup(key), g_strdup(val));
+            }
+        }
+        if (priv->data_invalid && !g_hash_table_size(priv->data_invalid))
+            nm_clear_pointer(&priv->data_invalid, g_hash_table_unref);
+
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+        break;
+    }
+}
+
+/*****************************************************************************/
+
+static void
+nm_setting_user_init(NMSettingUser *self)
+{}
+
+/**
+ * nm_setting_user_new:
+ *
+ * Creates a new #NMSettingUser object with default values.
+ *
+ * Returns: the new empty #NMSettingUser object
+ **/
+NMSetting *
+nm_setting_user_new(void)
+{
+    return g_object_new(NM_TYPE_SETTING_USER, NULL);
+}
+
+static void
+finalize(GObject *object)
+{
+    NMSettingUser *       self = NM_SETTING_USER(object);
+    NMSettingUserPrivate *priv = NM_SETTING_USER_GET_PRIVATE(self);
+
+    g_free(priv->keys);
+    if (priv->data)
+        g_hash_table_unref(priv->data);
+    if (priv->data_invalid)
+        g_hash_table_unref(priv->data_invalid);
+
+    G_OBJECT_CLASS(nm_setting_user_parent_class)->finalize(object);
+}
+
+static void
+nm_setting_user_class_init(NMSettingUserClass *klass)
+{
+    GObjectClass *  object_class        = G_OBJECT_CLASS(klass);
+    NMSettingClass *setting_class       = NM_SETTING_CLASS(klass);
+    GArray *        properties_override = _nm_sett_info_property_override_create_array();
+
+    object_class->get_property = get_property;
+    object_class->set_property = set_property;
+    object_class->finalize     = finalize;
+
+    setting_class->compare_property = compare_property;
+    setting_class->verify           = verify;
+
+    /**
+     * NMSettingUser:data: (type GHashTable(utf8,utf8))
+     *
+     * A dictionary of key/value pairs with user data. This data is ignored by NetworkManager
+     * and can be used at the users discretion. The keys only support a strict ascii format,
+     * but the values can be arbitrary UTF8 strings up to a certain length.
+     *
+     * Since: 1.8
+     **/
+    /* ---ifcfg-rh---
+     * property: data
+     * variable: NM_USER_*
+     * description: each key/value pair is stored as a separate variable with
+     *   name composed by concatenating NM_USER_ with the encoded key. The key is
+     *   encoded by substituting lowercase letters with uppercase and prepending
+     *   uppercase letters with an underscore. A dot is encoded as a double
+     *   underscore. Remaining characters are encoded as underscore followed by a
+     *   3 digit octal representation of the character.
+     * example: NM_USER_FOO__BAR=something
+     * ---end---
+     */
+    obj_properties[PROP_DATA] = g_param_spec_boxed(NM_SETTING_USER_DATA,
+                                                   "",
+                                                   "",
+                                                   G_TYPE_HASH_TABLE,
+                                                   G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+    _nm_properties_override_gobj(properties_override,
+                                 obj_properties[PROP_DATA],
+                                 &nm_sett_info_propert_type_strdict);
+
+    g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties);
+
+    _nm_setting_class_commit_full(setting_class,
+                                  NM_META_SETTING_TYPE_USER,
+                                  NULL,
+                                  properties_override);
+}