New upstream version 1.29.90 upstream/1.29.90

1 files changed, 237 insertions, 0 deletions

diff --git a/src/core/settings/plugins/keyfile/nms-keyfile-reader.c b/src/core/settings/plugins/keyfile/nms-keyfile-reader.c
new file mode 100644
index 00000000..70b047f3
--- /dev/null
+++ b/src/core/settings/plugins/keyfile/nms-keyfile-reader.c
@@ -0,0 +1,237 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2015 Red Hat, Inc.
+ */
+
+#include "src/core/nm-default-daemon.h"
+
+#include "nms-keyfile-reader.h"
+
+#include <sys/stat.h>
+
+#include "nm-keyfile-internal.h"
+
+#include "NetworkManagerUtils.h"
+#include "nms-keyfile-utils.h"
+
+/*****************************************************************************/
+
+static const char *
+_fmt_warn(const NMKeyfileHandlerData *handler_data, char **out_message)
+{
+    const char *group   = handler_data->kf_group_name;
+    const char *message = _nm_keyfile_handler_data_warn_get_message(handler_data);
+
+    if (group) {
+        NMSetting * setting       = handler_data->cur_setting;
+        const char *property_name = handler_data->cur_property;
+        const char *setting_name  = setting ? nm_setting_get_name(setting) : NULL;
+        char *      res;
+
+        if (setting_name) {
+            if (property_name && !strcmp(group, setting_name))
+                res = g_strdup_printf("%s.%s: %s", group, property_name, message);
+            else if (property_name)
+                res = g_strdup_printf("%s/%s.%s: %s", group, setting_name, property_name, message);
+            else if (!strcmp(group, setting_name))
+                res = g_strdup_printf("%s: %s", group, message);
+            else
+                res = g_strdup_printf("%s/%s: %s", group, setting_name, message);
+        } else
+            res = g_strdup_printf("%s: %s", group, message);
+        *out_message = res;
+        return res;
+    }
+
+    return message;
+}
+
+typedef struct {
+    bool verbose;
+} ReadInfo;
+
+static gboolean
+_handler_read(GKeyFile *            keyfile,
+              NMConnection *        connection,
+              NMKeyfileHandlerType  handler_type,
+              NMKeyfileHandlerData *handler_data,
+              void *                user_data)
+{
+    const ReadInfo *read_info = user_data;
+
+    if (handler_type == NM_KEYFILE_HANDLER_TYPE_WARN) {
+        const NMKeyfileHandlerDataWarn *warn_data = &handler_data->warn;
+        NMLogLevel                      level;
+        char *                          message_free = NULL;
+
+        if (!read_info->verbose)
+            return TRUE;
+
+        if (warn_data->severity > NM_KEYFILE_WARN_SEVERITY_WARN)
+            level = LOGL_ERR;
+        else if (warn_data->severity >= NM_KEYFILE_WARN_SEVERITY_WARN)
+            level = LOGL_WARN;
+        else if (warn_data->severity == NM_KEYFILE_WARN_SEVERITY_INFO_MISSING_FILE)
+            level = LOGL_WARN;
+        else
+            level = LOGL_INFO;
+
+        nm_log(level,
+               LOGD_SETTINGS,
+               NULL,
+               nm_connection_get_uuid(connection),
+               "keyfile: %s",
+               _fmt_warn(handler_data, &message_free));
+        g_free(message_free);
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+NMConnection *
+nms_keyfile_reader_from_keyfile(GKeyFile *  key_file,
+                                const char *filename,
+                                const char *base_dir,
+                                const char *profile_dir,
+                                gboolean    verbose,
+                                GError **   error)
+{
+    NMConnection *connection;
+    ReadInfo      read_info = {
+        .verbose = verbose,
+    };
+    gs_free char *base_dir_free         = NULL;
+    gs_free char *profile_filename_free = NULL;
+    gs_free char *filename_id           = NULL;
+    const char *  profile_filename      = NULL;
+
+    nm_assert(filename && filename[0]);
+    nm_assert(!base_dir || base_dir[0] == '/');
+    nm_assert(!profile_dir || profile_dir[0] == '/');
+
+    if (base_dir)
+        nm_assert(!strchr(filename, '/'));
+    else {
+        const char *s;
+
+        nm_assert(filename[0] == '/');
+
+        /* @base_dir may be NULL, in which case @filename must be an absolute path,
+         * and the directory is taken as the @base_dir. */
+        s        = strrchr(filename, '/');
+        base_dir = nm_strndup_a(255, filename, s - filename, &base_dir_free);
+        if (!profile_dir || nm_streq(base_dir, profile_dir))
+            profile_filename = filename;
+        filename = &s[1];
+    }
+
+    connection = nm_keyfile_read(key_file,
+                                 base_dir,
+                                 NM_KEYFILE_HANDLER_FLAGS_NONE,
+                                 _handler_read,
+                                 &read_info,
+                                 error);
+    if (!connection)
+        return NULL;
+
+    if (g_str_has_suffix(filename, NM_KEYFILE_PATH_SUFFIX_NMCONNECTION)) {
+        gsize l = strlen(filename);
+
+        if (l > NM_STRLEN(NM_KEYFILE_PATH_SUFFIX_NMCONNECTION))
+            filename_id = g_strndup(filename, l - NM_STRLEN(NM_KEYFILE_PATH_SUFFIX_NMCONNECTION));
+    }
+
+    nm_keyfile_read_ensure_id(connection, filename_id ?: filename);
+
+    if (!profile_filename) {
+        profile_filename_free = g_build_filename(profile_dir ?: base_dir, filename, NULL);
+        profile_filename      = profile_filename_free;
+    }
+    nm_keyfile_read_ensure_uuid(connection, profile_filename);
+
+    return connection;
+}
+
+NMConnection *
+nms_keyfile_reader_from_file(const char * full_filename,
+                             const char * profile_dir,
+                             struct stat *out_stat,
+                             NMTernary *  out_is_nm_generated,
+                             NMTernary *  out_is_volatile,
+                             NMTernary *  out_is_external,
+                             char **      out_shadowed_storage,
+                             NMTernary *  out_shadowed_owned,
+                             GError **    error)
+{
+    nm_auto_unref_keyfile GKeyFile *key_file     = NULL;
+    NMConnection *                  connection   = NULL;
+    GError *                        verify_error = NULL;
+
+    nm_assert(full_filename && full_filename[0] == '/');
+    nm_assert(!profile_dir || profile_dir[0] == '/');
+
+    NM_SET_OUT(out_is_nm_generated, NM_TERNARY_DEFAULT);
+    NM_SET_OUT(out_is_volatile, NM_TERNARY_DEFAULT);
+    NM_SET_OUT(out_is_external, NM_TERNARY_DEFAULT);
+    NM_SET_OUT(out_shadowed_owned, NM_TERNARY_DEFAULT);
+
+    if (!nms_keyfile_utils_check_file_permissions(NMS_KEYFILE_FILETYPE_KEYFILE,
+                                                  full_filename,
+                                                  out_stat,
+                                                  error))
+        return NULL;
+
+    key_file = g_key_file_new();
+    if (!g_key_file_load_from_file(key_file, full_filename, G_KEY_FILE_NONE, error))
+        return NULL;
+
+    connection =
+        nms_keyfile_reader_from_keyfile(key_file, full_filename, NULL, profile_dir, TRUE, error);
+    if (!connection)
+        return NULL;
+
+    /* Normalize and verify the connection */
+    if (!nm_connection_normalize(connection, NULL, NULL, &verify_error)) {
+        g_set_error(error,
+                    NM_SETTINGS_ERROR,
+                    NM_SETTINGS_ERROR_INVALID_CONNECTION,
+                    "invalid connection: %s",
+                    verify_error->message);
+        g_clear_error(&verify_error);
+        g_object_unref(connection);
+        connection = NULL;
+    }
+
+    NM_SET_OUT(out_is_nm_generated,
+               nm_key_file_get_boolean(key_file,
+                                       NM_KEYFILE_GROUP_NMMETA,
+                                       NM_KEYFILE_KEY_NMMETA_NM_GENERATED,
+                                       NM_TERNARY_DEFAULT));
+
+    NM_SET_OUT(out_is_volatile,
+               nm_key_file_get_boolean(key_file,
+                                       NM_KEYFILE_GROUP_NMMETA,
+                                       NM_KEYFILE_KEY_NMMETA_VOLATILE,
+                                       NM_TERNARY_DEFAULT));
+
+    NM_SET_OUT(out_is_external,
+               nm_key_file_get_boolean(key_file,
+                                       NM_KEYFILE_GROUP_NMMETA,
+                                       NM_KEYFILE_KEY_NMMETA_EXTERNAL,
+                                       NM_TERNARY_DEFAULT));
+
+    NM_SET_OUT(out_shadowed_storage,
+               g_key_file_get_string(key_file,
+                                     NM_KEYFILE_GROUP_NMMETA,
+                                     NM_KEYFILE_KEY_NMMETA_SHADOWED_STORAGE,
+                                     NULL));
+
+    NM_SET_OUT(out_shadowed_owned,
+               nm_key_file_get_boolean(key_file,
+                                       NM_KEYFILE_GROUP_NMMETA,
+                                       NM_KEYFILE_KEY_NMMETA_SHADOWED_OWNED,
+                                       NM_TERNARY_DEFAULT));
+
+    return connection;
+}