/* SPDX-License-Identifier: GPL-2.0+ */

/*

 * Copyright (C) 2012, 2013 Red Hat, Inc.

 */

/**

 * SECTION:nm-editor-utils

 * @short_description: Miscellaneous connection editor utilities

 *

 * nm-editor-utils contains helper functions for connection editors.

 * The goal is that this should eventually be shared between nmtui,

 * nm-connection-editor, and gnome-control-center.

 */

#include "nm-default.h"

#include "nm-editor-utils.h"

#if 0

    #include "nm-vpn-helpers.h"

static GSList *vpn_plugins;

static int

sort_vpn_plugins (gconstpointer a, gconstpointer b)

{

    NMVpnEditorPlugin *aa = NM_VPN_EDITOR_PLUGIN (a);

    NMVpnEditorPlugin *bb = NM_VPN_EDITOR_PLUGIN (b);

    char *aa_desc = NULL, *bb_desc = NULL;

    int ret;

    g_object_get (aa, NM_VPN_EDITOR_PLUGIN_NAME, &aa_desc, NULL);

    g_object_get (bb, NM_VPN_EDITOR_PLUGIN_NAME, &bb_desc, NULL);

    ret = g_strcmp0 (aa_desc, bb_desc);

    g_free (aa_desc);

    g_free (bb_desc);

    return ret;

}

#endif

static void

wifi_connection_setup_func(NMConnection *connection, NMSettingConnection *s_con, NMSetting *s_hw)

{

    g_object_set(G_OBJECT(s_hw), NM_SETTING_WIRELESS_MODE, NM_SETTING_WIRELESS_MODE_INFRA, NULL);

}

static void

bond_connection_setup_func(NMConnection *connection, NMSettingConnection *s_con, NMSetting *s_hw)

{

    NMSettingBond *          s_bond = NM_SETTING_BOND(s_hw);

    guint                    i;

    const char *             value;

    static const char *const options[] = {

        NM_SETTING_BOND_OPTION_MODE,

        NM_SETTING_BOND_OPTION_MIIMON,

        NM_SETTING_BOND_OPTION_DOWNDELAY,

        NM_SETTING_BOND_OPTION_UPDELAY,

    };

    for (i = 0; i < G_N_ELEMENTS(options); i++) {

        value = nm_setting_bond_get_option_default(s_bond, options[i]);

        if (value)

            nm_setting_bond_add_option(s_bond, options[i], value);

    }

}

typedef void (*NMEditorNewConnectionSetupFunc)(NMConnection *       connection,

                                               NMSettingConnection *s_con,

                                               NMSetting *          s_hw);

typedef struct {

    NMEditorConnectionTypeData data;

    const char *                   id_format;

    NMEditorNewConnectionSetupFunc connection_setup_func;

    gboolean                       no_autoconnect;

} NMEditorConnectionTypeDataReal;

static int

sort_types(gconstpointer a, gconstpointer b)

{

    NMEditorConnectionTypeData *typea = *(NMEditorConnectionTypeData **) a;

    NMEditorConnectionTypeData *typeb = *(NMEditorConnectionTypeData **) b;

    if (typea->virtual && !typeb->virtual)

        return 1;

    else if (typeb->virtual && !typea->virtual)

        return -1;

    if (typea->setting_type == NM_TYPE_SETTING_VPN && typeb->setting_type != NM_TYPE_SETTING_VPN)

        return 1;

    else if (typeb->setting_type == NM_TYPE_SETTING_VPN

             && typea->setting_type != NM_TYPE_SETTING_VPN)

        return -1;

    return g_utf8_collate(typea->name, typeb->name);

}

/**

 * nm_editor_utils_get_connection_type_list:

 *

 * Gets an array of information about supported connection types. The

 * array is sorted in a standard presentation order (hardware types

 * first, alphabetized, then virtual types, alphabetized, then VPN

 * types, alphabetized).

 *

 * Returns: the array of connection type information

 */

NMEditorConnectionTypeData **

nm_editor_utils_get_connection_type_list(void)

{

    GPtrArray *                         array;

    NMEditorConnectionTypeDataReal *    item;

    static NMEditorConnectionTypeData **list;

#if 0

    GHashTable *vpn_plugins_hash;

    gboolean have_vpn_plugins;

#endif

    if (list)

        return list;

    array = g_ptr_array_new();

    item                    = g_new0(NMEditorConnectionTypeDataReal, 1);

    item->data.name         = _("Ethernet");

    item->data.setting_type = NM_TYPE_SETTING_WIRED;

    item->data.device_type  = NM_TYPE_DEVICE_ETHERNET;

    item->data.virtual      = FALSE;

    item->id_format         = _("Ethernet connection %d");

    g_ptr_array_add(array, item);

    item                    = g_new0(NMEditorConnectionTypeDataReal, 1);

    item->data.name         = _("Veth");

    item->data.setting_type = NM_TYPE_SETTING_VETH;

    item->data.device_type  = NM_TYPE_DEVICE_VETH;

    item->data.virtual      = TRUE;

    item->id_format         = _("Veth connection %d");

    g_ptr_array_add(array, item);

    item                        = g_new0(NMEditorConnectionTypeDataReal, 1);

    item->data.name             = _("Wi-Fi");

    item->data.setting_type     = NM_TYPE_SETTING_WIRELESS;

    item->data.device_type      = NM_TYPE_DEVICE_WIFI;

    item->data.virtual          = FALSE;

    item->id_format             = _("Wi-Fi connection %d");

    item->connection_setup_func = wifi_connection_setup_func;

    g_ptr_array_add(array, item);

    item                    = g_new0(NMEditorConnectionTypeDataReal, 1);

    item->data.name         = _("InfiniBand");

    item->data.setting_type = NM_TYPE_SETTING_INFINIBAND;

    item->data.device_type  = NM_TYPE_DEVICE_INFINIBAND;

    item->data.virtual      = FALSE;

    item->id_format         = _("InfiniBand connection %d");

    g_ptr_array_add(array, item);

#if 0

    item = g_new0 (NMEditorConnectionTypeDataReal, 1);

    item->data.name = _("Mobile Broadband");

    item->data.setting_type = NM_TYPE_SETTING_GSM;

    item->data.virtual = FALSE;

    item->id_format = _("Mobile broadband connection %d");

    item->no_autoconnect = TRUE;

    g_ptr_array_add (array, item);

#endif

    item                    = g_new0(NMEditorConnectionTypeDataReal, 1);

    item->data.name         = _("DSL");

    item->data.setting_type = NM_TYPE_SETTING_PPPOE;

    item->data.device_type  = NM_TYPE_DEVICE_ETHERNET;

    item->data.virtual      = FALSE;

    item->id_format         = _("DSL connection %d");

    item->no_autoconnect    = TRUE;

    g_ptr_array_add(array, item);

    item                        = g_new0(NMEditorConnectionTypeDataReal, 1);

    item->data.name             = _("Bond");

    item->data.setting_type     = NM_TYPE_SETTING_BOND;

    item->data.device_type      = NM_TYPE_DEVICE_BOND;

    item->data.virtual          = TRUE;

    item->id_format             = _("Bond connection %d");

    item->connection_setup_func = bond_connection_setup_func;

    g_ptr_array_add(array, item);

    item                          = g_new0(NMEditorConnectionTypeDataReal, 1);

    item->data.name               = _("Bridge");

    item->data.setting_type       = NM_TYPE_SETTING_BRIDGE;

    item->data.slave_setting_type = NM_TYPE_SETTING_BRIDGE_PORT;

    item->data.device_type        = NM_TYPE_DEVICE_BRIDGE;

    item->data.virtual            = TRUE;

    item->id_format               = _("Bridge connection %d");

    g_ptr_array_add(array, item);

    item                          = g_new0(NMEditorConnectionTypeDataReal, 1);

    item->data.name               = _("Team");

    item->data.setting_type       = NM_TYPE_SETTING_TEAM;

    item->data.slave_setting_type = NM_TYPE_SETTING_TEAM_PORT;

    item->data.device_type        = NM_TYPE_DEVICE_TEAM;

    item->data.virtual            = TRUE;

    item->id_format               = _("Team connection %d");

    g_ptr_array_add(array, item);

    item                    = g_new0(NMEditorConnectionTypeDataReal, 1);

    item->data.name         = _("VLAN");

    item->data.setting_type = NM_TYPE_SETTING_VLAN;

    item->data.device_type  = NM_TYPE_DEVICE_VLAN;

    item->data.virtual      = TRUE;

    item->id_format         = _("VLAN connection %d");

    g_ptr_array_add(array, item);

    item                    = g_new0(NMEditorConnectionTypeDataReal, 1);

    item->data.name         = _("IP tunnel");

    item->data.setting_type = NM_TYPE_SETTING_IP_TUNNEL;

    item->data.device_type  = NM_TYPE_DEVICE_IP_TUNNEL;

    item->data.virtual      = TRUE;

    item->id_format         = _("IP tunnel connection %d");

    g_ptr_array_add(array, item);

#if 0

    /* Add "VPN" only if there are plugins */

    vpn_plugins_hash = nm_vpn_get_plugin_infos ();

    have_vpn_plugins  = vpn_plugins_hash && g_hash_table_size (vpn_plugins_hash);

    if (have_vpn_plugins) {

        GHashTableIter iter;

        gpointer name, plugin;

        item = g_new0 (NMEditorConnectionTypeDataReal, 1);

        item->data.name = _("VPN");

        item->data.setting_type = NM_TYPE_SETTING_VPN;

        item->data.virtual = TRUE;

        item->id_format = _("VPN connection %d");

        item->no_autoconnect = TRUE;

        g_ptr_array_add (array, item);

        vpn_plugins = NULL;

        g_hash_table_iter_init (&iter, vpn_plugins_hash);

        while (g_hash_table_iter_next (&iter, &name, &plugin))

            vpn_plugins = g_slist_prepend (vpn_plugins, plugin);

        vpn_plugins = g_slist_sort (vpn_plugins, sort_vpn_plugins);

    }

#endif

    g_ptr_array_sort(array, sort_types);

    g_ptr_array_add(array, NULL);

    list = (NMEditorConnectionTypeData **) g_ptr_array_free(array, FALSE);

    return list;

}

static gboolean

_assert_format_int(const char *format)

{

    g_assert(format);

    format = strchr(format, '%');

    g_assert(format);

    format++;

    g_assert(!strchr(format, '%'));

    g_assert(format[0] == 'd');

    return TRUE;

}

static char *

get_available_connection_name(const char *format, NMClient *client)

{

    const GPtrArray *conns;

    GSList *         names = NULL, *iter;

    char *           cname = NULL;

    int              i     = 0;

    nm_assert(_assert_format_int(format));

    conns = nm_client_get_connections(client);

    for (i = 0; i < conns->len; i++) {

        const char *id;

        id = nm_connection_get_id(NM_CONNECTION(conns->pdata[i]));

        g_assert(id);

        names = g_slist_append(names, (gpointer) id);

    }

    /* Find the next available unique connection name */

    for (i = 1; !cname && i < 10000; i++) {

        char *   temp;

        gboolean found = FALSE;

        NM_PRAGMA_WARNING_DISABLE("-Wformat-nonliteral")

        temp = g_strdup_printf(format, i);

        NM_PRAGMA_WARNING_REENABLE

        for (iter = names; iter; iter = g_slist_next(iter)) {

            if (!strcmp(iter->data, temp)) {

                found = TRUE;

                break;

            }

        }

        if (!found)

            cname = temp;

        else

            g_free(temp);

    }

    g_slist_free(names);

    return cname;

}

static char *

get_available_iface_name(const char *try_name, NMClient *client)

{

    const GPtrArray *connections;

    NMConnection *   connection;

    char *           new_name;

    unsigned         num    = 1;

    int              i      = 0;

    const char *     ifname = NULL;

    connections = nm_client_get_connections(client);

    new_name = g_strdup(try_name);

    while (i < connections->len) {

        connection = NM_CONNECTION(connections->pdata[i]);

        ifname     = nm_connection_get_interface_name(connection);

        if (g_strcmp0(new_name, ifname) == 0) {

            g_free(new_name);

            new_name = g_strdup_printf("%s%d", try_name, num++);

            i        = 0;

        } else

            i++;

    }

    return new_name;

}

/**

 * nm_editor_utils_create_connection:

 * @type: the type of the connection's primary #NMSetting

 * @master: (allow-none): the connection's master, if any

 * @client: an #NMClient

 *

 * Creates a new #NMConnection of the given type, automatically

 * creating a UUID and an appropriate not-currently-in-use connection

 * name, setting #NMSettingConnection:autoconnect appropriately for

 * the connection type, filling in slave-related information if

 * @master is not %NULL, and initializing any other mandatory-to-set

 * properties to reasonable initial values.

 *

 * Returns: a new #NMConnection

 */

NMConnection *

nm_editor_utils_create_connection(GType type, NMConnection *master, NMClient *client)

{

    NMEditorConnectionTypeData **   types;

    NMEditorConnectionTypeDataReal *type_data           = NULL;

    const char *                    master_setting_type = NULL, *master_uuid = NULL;

    GType                master_type = G_TYPE_INVALID, slave_setting_type = G_TYPE_INVALID;

    NMConnection *       connection;

    NMSettingConnection *s_con;

    NMSetting *          s_hw, *s_slave;

    char *               uuid, *id, *ifname;

    int                  i;

    if (master) {

        NMSettingConnection *master_s_con;

        master_s_con        = nm_connection_get_setting_connection(master);

        master_setting_type = nm_setting_connection_get_connection_type(master_s_con);

        master_uuid         = nm_setting_connection_get_uuid(master_s_con);

        master_type         = nm_setting_lookup_type(master_setting_type);

    }

    types = nm_editor_utils_get_connection_type_list();

    for (i = 0; types[i]; i++) {

        if (types[i]->setting_type == type)

            type_data = (NMEditorConnectionTypeDataReal *) types[i];

        if (types[i]->setting_type == master_type)

            slave_setting_type = types[i]->slave_setting_type;

    }

    if (!type_data) {

        g_return_val_if_reached(NULL);

        return NULL;

    }

    connection = nm_simple_connection_new();

    s_con = NM_SETTING_CONNECTION(nm_setting_connection_new());

    nm_connection_add_setting(connection, NM_SETTING(s_con));

    s_hw = g_object_new(type, NULL);

    nm_connection_add_setting(connection, s_hw);

    if (type == NM_TYPE_SETTING_BOND)

        ifname = get_available_iface_name("nm-bond", client);

    else if (type == NM_TYPE_SETTING_TEAM)

        ifname = get_available_iface_name("nm-team", client);

    else if (type == NM_TYPE_SETTING_BRIDGE)

        ifname = get_available_iface_name("nm-bridge", client);

    else

        ifname = NULL;

    if (slave_setting_type != G_TYPE_INVALID) {

        s_slave = g_object_new(slave_setting_type, NULL);

        nm_connection_add_setting(connection, s_slave);

    }

    uuid = nm_utils_uuid_generate();

    id   = get_available_connection_name(type_data->id_format, client);

    g_object_set(s_con,

                 NM_SETTING_CONNECTION_UUID,

                 uuid,

                 NM_SETTING_CONNECTION_ID,

                 id,

                 NM_SETTING_CONNECTION_TYPE,

                 nm_setting_get_name(s_hw),

                 NM_SETTING_CONNECTION_AUTOCONNECT,

                 !type_data->no_autoconnect,

                 NM_SETTING_CONNECTION_MASTER,

                 master_uuid,

                 NM_SETTING_CONNECTION_SLAVE_TYPE,

                 master_setting_type,

                 NM_SETTING_CONNECTION_INTERFACE_NAME,

                 ifname,

                 NULL);

    g_free(uuid);

    g_free(id);

    g_free(ifname);

    if (type_data->connection_setup_func)

        type_data->connection_setup_func(connection, s_con, s_hw);

    return connection;

}

/**

 * nm_editor_utils_get_connection_type_data:

 * @conn: an #NMConnection

 *

 * Gets the #NMEditorConnectionTypeData corresponding to

 * @conn's connection type.

 *

 * Returns: the #NMEditorConnectionTypeData

 */

NMEditorConnectionTypeData *

nm_editor_utils_get_connection_type_data(NMConnection *conn)

{

    NMSettingConnection *        s_con;

    const char *                 conn_type;

    GType                        conn_gtype;

    NMEditorConnectionTypeData **types;

    int                          i;

    s_con = nm_connection_get_setting_connection(conn);

    g_return_val_if_fail(s_con != NULL, NULL);

    conn_type  = nm_setting_connection_get_connection_type(s_con);

    conn_gtype = nm_setting_lookup_type(conn_type);

    g_return_val_if_fail(conn_gtype != G_TYPE_INVALID, NULL);

    types = nm_editor_utils_get_connection_type_list();

    for (i = 0; types[i]; i++) {

        if (types[i]->setting_type == conn_gtype)

            return types[i];

    }

    return NULL;

}