void
ce_page_complete_connection (NMConnection *connection,
const char *format,
const char *ctype,
gboolean autoconnect,
NMClient *client)
{
NMSettingConnection *s_con;
char *id, *uuid;
const GPtrArray *connections;
s_con = nm_connection_get_setting_connection (connection);
if (!s_con) {
s_con = NM_SETTING_CONNECTION (nm_setting_connection_new ());
nm_connection_add_setting (connection, NM_SETTING (s_con));
}
if (!nm_setting_connection_get_id (s_con)) {
connections = nm_client_get_connections (client);
id = ce_page_get_next_available_name (connections, format);
g_object_set (s_con, NM_SETTING_CONNECTION_ID, id, NULL);
g_free (id);
}
uuid = nm_utils_uuid_generate ();
g_object_set (s_con,
NM_SETTING_CONNECTION_UUID, uuid,
NM_SETTING_CONNECTION_TYPE, ctype,
NM_SETTING_CONNECTION_AUTOCONNECT, autoconnect,
NULL);
g_free (uuid);
}
void
bond_connection_new (GtkWindow *parent,
const char *detail,
NMClient *client,
PageNewConnectionResultFunc result_func,
gpointer user_data)
{
NMConnection *connection;
NMSettingConnection *s_con;
int bond_num = 0, num, i;
const GPtrArray *connections;
NMConnection *conn2;
const char *iface;
char *my_iface;
connection = ce_page_new_connection (_("Bond connection %d"),
NM_SETTING_BOND_SETTING_NAME,
TRUE,
client,
user_data);
nm_connection_add_setting (connection, nm_setting_bond_new ());
/* Find an available interface name */
connections = nm_client_get_connections (client);
for (i = 0; i < connections->len; i++) {
conn2 = connections->pdata[i];
if (!nm_connection_is_type (conn2, NM_SETTING_BOND_SETTING_NAME))
continue;
iface = nm_connection_get_interface_name (conn2);
if (!iface || strncmp (iface, "bond", 4) != 0 || !g_ascii_isdigit (iface[4]))
continue;
num = atoi (iface + 4);
if (bond_num <= num)
bond_num = num + 1;
}
s_con = nm_connection_get_setting_connection (connection);
my_iface = g_strdup_printf ("bond%d", bond_num);
g_object_set (G_OBJECT (s_con),
NM_SETTING_CONNECTION_INTERFACE_NAME, my_iface,
NULL);
g_free (my_iface);
(*result_func) (connection, FALSE, NULL, user_data);
}
void
nmt_remove_connection (NMRemoteConnection *connection)
{
const GPtrArray *all_conns;
GSList *slaves, *iter;
int i;
NMRemoteConnection *slave;
NMSettingConnection *s_con;
const char *uuid, *iface, *master;
int choice;
choice = nmt_newt_choice_dialog (_("Cancel"),
_("Delete"),
_("Are you sure you want to delete the connection '%s'?"),
nm_connection_get_id (NM_CONNECTION (connection)));
if (choice == 1)
return;
g_object_ref (connection);
remove_one_connection (connection);
uuid = nm_connection_get_uuid (NM_CONNECTION (connection));
iface = nm_connection_get_interface_name (NM_CONNECTION (connection));
all_conns = nm_client_get_connections (nm_client);
slaves = NULL;
for (i = 0; i < all_conns->len; i++) {
slave = all_conns->pdata[i];
s_con = nm_connection_get_setting_connection (NM_CONNECTION (slave));
master = nm_setting_connection_get_master (s_con);
if (master) {
if (!g_strcmp0 (master, uuid) || !g_strcmp0 (master, iface))
slaves = g_slist_prepend (slaves, g_object_ref (slave));
}
}
for (iter = slaves; iter; iter = iter->next)
remove_one_connection (iter->data);
g_slist_free_full (slaves, g_object_unref);
g_object_unref (connection);
}
static void
add_profile (GtkButton *button, NetDeviceEthernet *device)
{
NMConnection *connection;
NMSettingConnection *sc;
gchar *uuid, *id;
NetConnectionEditor *editor;
GtkWidget *window;
NMClient *client;
NMDevice *nmdev;
const GPtrArray *connections;
connection = nm_simple_connection_new ();
sc = NM_SETTING_CONNECTION (nm_setting_connection_new ());
nm_connection_add_setting (connection, NM_SETTING (sc));
uuid = nm_utils_uuid_generate ();
client = net_object_get_client (NET_OBJECT (device));
connections = nm_client_get_connections (client);
id = ce_page_get_next_available_name (connections, NAME_FORMAT_PROFILE, NULL);
g_object_set (sc,
NM_SETTING_CONNECTION_UUID, uuid,
NM_SETTING_CONNECTION_ID, id,
NM_SETTING_CONNECTION_TYPE, NM_SETTING_WIRED_SETTING_NAME,
NM_SETTING_CONNECTION_AUTOCONNECT, TRUE,
NULL);
nm_connection_add_setting (connection, nm_setting_wired_new ());
g_free (uuid);
g_free (id);
window = gtk_widget_get_toplevel (GTK_WIDGET (button));
nmdev = net_device_get_nm_device (NET_DEVICE (device));
editor = net_connection_editor_new (GTK_WINDOW (window), connection, nmdev, NULL, client);
g_signal_connect (editor, "done", G_CALLBACK (editor_done), device);
net_connection_editor_run (editor);
}
static gboolean
edit_connection_list_filter (NmtEditConnectionList *list,
NMConnection *connection,
gpointer user_data)
{
NMSettingConnection *s_con;
const char *master, *slave_type;
const char *uuid, *ifname;
const GPtrArray *conns;
int i;
gboolean found_master = FALSE;
s_con = nm_connection_get_setting_connection (connection);
g_return_val_if_fail (s_con != NULL, FALSE);
master = nm_setting_connection_get_master (s_con);
if (!master)
return TRUE;
slave_type = nm_setting_connection_get_slave_type (s_con);
if ( g_strcmp0 (slave_type, NM_SETTING_BOND_SETTING_NAME) != 0
&& g_strcmp0 (slave_type, NM_SETTING_TEAM_SETTING_NAME) != 0
&& g_strcmp0 (slave_type, NM_SETTING_BRIDGE_SETTING_NAME) != 0)
return TRUE;
conns = nm_client_get_connections (nm_client);
for (i = 0; i < conns->len; i++) {
NMConnection *candidate = conns->pdata[i];
uuid = nm_connection_get_uuid (candidate);
ifname = nm_connection_get_interface_name (candidate);
if (!g_strcmp0 (master, uuid) || !g_strcmp0 (master, ifname)) {
found_master = TRUE;
break;
}
}
return !found_master;
}
int
main (int argc, char *argv[])
{
NMClient *client;
GError *error = NULL;
const GPtrArray *connections;
int i;
#if !GLIB_CHECK_VERSION (2, 35, 0)
/* Initialize GType system */
g_type_init ();
#endif
if (!(client = nm_client_new (NULL, &error))) {
g_message ("Error: Could not connect to NetworkManager: %s.", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
if (!nm_client_get_nm_running (client)) {
g_message ("Error: Can't obtain connections: NetworkManager is not running.");
return EXIT_FAILURE;
}
/* Now the connections can be listed. */
connections = nm_client_get_connections (client);
printf ("Connections:\n===================\n");
for (i = 0; i < connections->len; i++)
show_connection (connections->pdata[i]);
g_object_unref (client);
return EXIT_SUCCESS;
}
static void
nmt_connect_connection_list_rebuild (NmtConnectConnectionList *list)
{
NmtConnectConnectionListPrivate *priv = NMT_CONNECT_CONNECTION_LIST_GET_PRIVATE (list);
NmtNewtListbox *listbox = NMT_NEWT_LISTBOX (list);
const GPtrArray *devices, *acs, *connections;
int max_width;
char **names, *row, active_col;
const char *strength_col;
GSList *nmt_devices, *diter, *citer;
NmtConnectDevice *nmtdev;
NmtConnectConnection *nmtconn;
g_slist_free_full (priv->nmt_devices, (GDestroyNotify) nmt_connect_device_free);
priv->nmt_devices = NULL;
nmt_newt_listbox_clear (listbox);
devices = nm_client_get_devices (nm_client);
acs = nm_client_get_active_connections (nm_client);
connections = nm_client_get_connections (nm_client);
nmt_devices = NULL;
names = nm_device_disambiguate_names ((NMDevice **) devices->pdata, devices->len);
nmt_devices = append_nmt_devices_for_devices (nmt_devices, devices, names, connections);
g_strfreev (names);
nmt_devices = append_nmt_devices_for_virtual_devices (nmt_devices, connections);
nmt_devices = append_nmt_devices_for_vpns (nmt_devices, connections);
nmt_devices = g_slist_sort (nmt_devices, sort_nmt_devices);
max_width = 0;
for (diter = nmt_devices; diter; diter = diter->next) {
nmtdev = diter->data;
for (citer = nmtdev->conns; citer; citer = citer->next) {
nmtconn = citer->data;
max_width = MAX (max_width, nmt_newt_text_width (nmtconn->name));
}
}
for (diter = nmt_devices; diter; diter = diter->next) {
nmtdev = diter->data;
if (diter != nmt_devices)
nmt_newt_listbox_append (listbox, "", NULL);
nmt_newt_listbox_append (listbox, nmtdev->name, NULL);
for (citer = nmtdev->conns; citer; citer = citer->next) {
nmtconn = citer->data;
if (nmtconn->conn)
nmtconn->active = connection_find_ac (nmtconn->conn, acs);
if (nmtconn->active) {
g_object_ref (nmtconn->active);
active_col = '*';
} else
active_col = ' ';
if (nmtconn->ap) {
guint8 strength = nm_access_point_get_strength (nmtconn->ap);
strength_col = nm_utils_wifi_strength_bars (strength);
} else
strength_col = NULL;
row = g_strdup_printf ("%c %s%-*s%s%s",
active_col,
nmtconn->name,
(int)(max_width - nmt_newt_text_width (nmtconn->name)), "",
strength_col ? " " : "",
strength_col ? strength_col : "");
nmt_newt_listbox_append (listbox, row, nmtconn);
g_free (row);
}
}
priv->nmt_devices = nmt_devices;
g_object_notify (G_OBJECT (listbox), "active");
g_object_notify (G_OBJECT (listbox), "active-key");
}
static void
test_make_invisible (void)
{
time_t start, now;
const GPtrArray *conns;
int i;
GDBusProxy *proxy;
gboolean visible_changed = FALSE, connection_removed = FALSE;
gboolean has_settings = FALSE;
char *path;
g_assert (remote != NULL);
/* Listen for the remove event when the connection becomes invisible */
g_signal_connect (remote, "notify::" NM_REMOTE_CONNECTION_VISIBLE, G_CALLBACK (visible_changed_cb), &visible_changed);
g_signal_connect (client, "connection-removed", G_CALLBACK (connection_removed_cb), &connection_removed);
path = g_strdup (nm_connection_get_path (NM_CONNECTION (remote)));
proxy = g_dbus_proxy_new_sync (bus,
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
NULL,
NM_DBUS_SERVICE,
path,
NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
NULL,
NULL);
g_assert (proxy != NULL);
/* Bypass the NMClient object so we can test it independently */
g_dbus_proxy_call (proxy,
"SetVisible",
g_variant_new ("(b)", FALSE),
G_DBUS_CALL_FLAGS_NONE, -1,
NULL,
set_visible_cb, NULL);
/* Wait for the connection to be removed */
start = time (NULL);
do {
now = time (NULL);
g_main_context_iteration (NULL, FALSE);
} while ((!visible_changed || !connection_removed) && (now - start < 5));
g_assert (visible_changed == TRUE);
g_assert (connection_removed == TRUE);
g_signal_handlers_disconnect_by_func (remote, G_CALLBACK (visible_changed_cb), &visible_changed);
g_signal_handlers_disconnect_by_func (client, G_CALLBACK (connection_removed_cb), &connection_removed);
/* Ensure NMClient no longer has the connection */
conns = nm_client_get_connections (client);
for (i = 0; i < conns->len; i++) {
NMConnection *candidate = NM_CONNECTION (conns->pdata[i]);
g_assert ((gpointer) remote != (gpointer) candidate);
g_assert (strcmp (path, nm_connection_get_path (candidate)) != 0);
}
/* And ensure the invisible connection no longer has any settings */
g_assert (remote);
nm_connection_for_each_setting_value (NM_CONNECTION (remote),
invis_has_settings_cb,
&has_settings);
g_assert (has_settings == FALSE);
g_free (path);
g_object_unref (proxy);
}
static void
wireless_dialog_response_cb (GtkDialog *foo,
gint response,
gpointer user_data)
{
NMAWifiDialog *dialog = NMA_WIFI_DIALOG (foo);
WirelessDialogClosure *closure = user_data;
NMConnection *connection, *fuzzy_match = NULL;
NMDevice *device;
NMAccessPoint *ap;
const GPtrArray *all;
guint i;
if (response != GTK_RESPONSE_OK)
goto done;
if (!nma_wifi_dialog_get_nag_ignored (dialog)) {
GtkWidget *nag_dialog;
/* Nag the user about certificates or whatever. Only destroy the dialog
* if no nagging was done.
*/
nag_dialog = nma_wifi_dialog_nag_user (dialog);
if (nag_dialog) {
gtk_window_set_transient_for (GTK_WINDOW (nag_dialog), GTK_WINDOW (dialog));
g_signal_connect (nag_dialog, "response",
G_CALLBACK (nag_dialog_response_cb),
dialog);
return;
}
}
/* nma_wifi_dialog_get_connection() returns a connection with the
* refcount incremented, so the caller must remember to unref it.
*/
connection = nma_wifi_dialog_get_connection (dialog, &device, &ap);
g_assert (connection);
g_assert (device);
/* Find a similar connection and use that instead */
all = nm_client_get_connections (closure->client);
for (i = 0; i < all->len; i++) {
if (nm_connection_compare (connection,
NM_CONNECTION (g_ptr_array_index (all, i)),
(NM_SETTING_COMPARE_FLAG_FUZZY | NM_SETTING_COMPARE_FLAG_IGNORE_ID))) {
fuzzy_match = NM_CONNECTION (g_ptr_array_index (all, i));
break;
}
}
if (fuzzy_match) {
nm_client_activate_connection_async (closure->client,
fuzzy_match,
device,
ap ? nm_object_get_path (NM_OBJECT (ap)) : NULL,
NULL,
activate_existing_cb,
NULL);
} else {
NMSetting *s_con;
NMSettingWireless *s_wifi;
const char *mode = NULL;
/* Entirely new connection */
/* Don't autoconnect adhoc networks by default for now */
s_wifi = (NMSettingWireless *) nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS);
if (s_wifi)
mode = nm_setting_wireless_get_mode (s_wifi);
if (g_strcmp0 (mode, "adhoc") == 0) {
s_con = nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION);
if (!s_con) {
s_con = nm_setting_connection_new ();
nm_connection_add_setting (connection, s_con);
}
g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_AUTOCONNECT, FALSE, NULL);
}
nm_client_add_and_activate_connection_async (closure->client,
connection,
device,
ap ? nm_object_get_path (NM_OBJECT (ap)) : NULL,
NULL,
activate_new_cb,
NULL);
}
/* Balance nma_wifi_dialog_get_connection() */
g_object_unref (connection);
done:
gtk_widget_hide (GTK_WIDGET (dialog));
gtk_widget_destroy (GTK_WIDGET (dialog));
}