// 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 = _("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;
}