/* 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;

}