diff options
Diffstat (limited to 'panels/network/connection-editor/ce-page-ip4.c')
| -rw-r--r-- | panels/network/connection-editor/ce-page-ip4.c | 846 |
1 files changed, 846 insertions, 0 deletions
diff --git a/panels/network/connection-editor/ce-page-ip4.c b/panels/network/connection-editor/ce-page-ip4.c new file mode 100644 index 0000000..c3f0864 --- /dev/null +++ b/panels/network/connection-editor/ce-page-ip4.c @@ -0,0 +1,846 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2012 Red Hat, Inc + * + * Licensed under the GNU General Public License Version 2 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" + +#include <errno.h> +#include <stdlib.h> +#include <arpa/inet.h> +#include <glib/gi18n.h> +#include <NetworkManager.h> + +#include "ce-ip-address-entry.h" +#include "ce-netmask-entry.h" +#include "ce-page.h" +#include "ce-page-ip4.h" +#include "ui-helpers.h" + +static void ensure_empty_address_row (CEPageIP4 *self); +static void ensure_empty_routes_row (CEPageIP4 *self); + +struct _CEPageIP4 +{ + AdwBin parent; + + GtkLabel *address_address_label; + GtkBox *address_box; + GtkLabel *address_gateway_label; + GtkLabel *address_netmask_label; + GtkSizeGroup *address_sizegroup; + GtkSwitch *auto_dns_switch; + GtkSwitch *auto_routes_switch; + GtkCheckButton *automatic_radio; + GtkBox *content_box; + GtkCheckButton *disabled_radio; + GtkEntry *dns_entry; + GtkCheckButton *local_radio; + GtkGrid *main_box; + GtkCheckButton *manual_radio; + GtkCheckButton *never_default_check; + GtkLabel *routes_address_label; + GtkBox *routes_box; + GtkLabel *routes_gateway_label; + GtkLabel *routes_metric_label; + GtkSizeGroup *routes_metric_sizegroup; + GtkLabel *routes_netmask_label; + GtkSizeGroup *routes_sizegroup; + GtkCheckButton *shared_radio; + + NMSettingIPConfig *setting; + + GtkWidget *address_list; + GtkWidget *routes_list; +}; + +static void ce_page_iface_init (CEPageInterface *); + +G_DEFINE_TYPE_WITH_CODE (CEPageIP4, ce_page_ip4, ADW_TYPE_BIN, + G_IMPLEMENT_INTERFACE (ce_page_get_type (), ce_page_iface_init)) + +enum { + METHOD_COL_NAME, + METHOD_COL_METHOD +}; + +enum { + IP4_METHOD_AUTO, + IP4_METHOD_MANUAL, + IP4_METHOD_LINK_LOCAL, + IP4_METHOD_SHARED, + IP4_METHOD_DISABLED +}; + +static void +method_changed (CEPageIP4 *self) +{ + gboolean addr_enabled; + gboolean dns_enabled; + gboolean routes_enabled; + + if (gtk_check_button_get_active (GTK_CHECK_BUTTON (self->disabled_radio)) || + gtk_check_button_get_active (GTK_CHECK_BUTTON (self->shared_radio))) { + addr_enabled = FALSE; + dns_enabled = FALSE; + routes_enabled = FALSE; + } else { + addr_enabled = gtk_check_button_get_active (GTK_CHECK_BUTTON (self->manual_radio)); + dns_enabled = !gtk_check_button_get_active (GTK_CHECK_BUTTON (self->local_radio)); + routes_enabled = !gtk_check_button_get_active (GTK_CHECK_BUTTON (self->local_radio)); + } + + gtk_widget_set_visible (GTK_WIDGET (self->address_box), addr_enabled); + gtk_widget_set_sensitive (GTK_WIDGET (self->dns_entry), dns_enabled); + gtk_widget_set_sensitive (GTK_WIDGET (self->routes_list), routes_enabled); + gtk_widget_set_sensitive (GTK_WIDGET (self->never_default_check), routes_enabled); + + ce_page_changed (CE_PAGE (self)); +} + +static void +update_row_sensitivity (CEPageIP4 *self, GtkWidget *list) +{ + GtkWidget *child; + gint rows = 0, i = 0; + + for (child = gtk_widget_get_first_child (GTK_WIDGET (list)); + child; + child = gtk_widget_get_next_sibling (child)) { + GtkWidget *button; + + button = GTK_WIDGET (g_object_get_data (G_OBJECT (child), "delete-button")); + if (button != NULL) + rows++; + } + for (child = gtk_widget_get_first_child (GTK_WIDGET (list)); + child; + child = gtk_widget_get_next_sibling (child)) { + GtkWidget *button; + + button = GTK_WIDGET (g_object_get_data (G_OBJECT (child), "delete-button")); + if (button != NULL) + gtk_widget_set_sensitive (button, rows > 1 && ++i < rows); + } +} + +static void +update_row_gateway_sensitivity (CEPageIP4 *self) +{ + GtkWidget *child; + gint rows = 0; + + for (child = gtk_widget_get_first_child (self->address_list); + child; + child = gtk_widget_get_next_sibling (child)) { + GtkWidget *entry; + + entry = GTK_WIDGET (g_object_get_data (G_OBJECT (child), "gateway")); + + gtk_widget_set_sensitive (entry, (rows == 0)); + + rows++; + } +} + +static void +remove_row (CEPageIP4 *self, GtkButton *button) +{ + GtkWidget *list; + GtkWidget *row; + GtkWidget *row_box; + + row_box = gtk_widget_get_parent (GTK_WIDGET (button)); + row = gtk_widget_get_parent (row_box); + list = gtk_widget_get_parent (row); + + gtk_list_box_remove (GTK_LIST_BOX (list), row); + + ce_page_changed (CE_PAGE (self)); + + update_row_sensitivity (self, list); + if (list == self->address_list) + update_row_gateway_sensitivity (self); +} + +static gboolean +validate_row (GtkWidget *row) +{ + GtkWidget *child; + GtkWidget *box; + gboolean valid; + + valid = FALSE; + box = gtk_list_box_row_get_child (GTK_LIST_BOX_ROW (row)); + + for (child = gtk_widget_get_first_child (box); + child; + child = gtk_widget_get_next_sibling (child)) { + if (!GTK_IS_ENTRY (child)) + continue; + + valid = valid || gtk_entry_get_text_length (GTK_ENTRY (child)) > 0; + } + + return valid; +} + +static void +add_address_row (CEPageIP4 *self, + const gchar *address, + const gchar *network, + const gchar *gateway) +{ + GtkWidget *row; + GtkWidget *row_box; + GtkWidget *widget; + GtkWidget *delete_button; + + row = gtk_list_box_row_new (); + gtk_list_box_row_set_activatable (GTK_LIST_BOX_ROW (row), FALSE); + + row_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); + gtk_widget_add_css_class (row_box, "linked"); + + widget = GTK_WIDGET (ce_ip_address_entry_new (AF_INET)); + g_signal_connect_object (widget, "changed", G_CALLBACK (ce_page_changed), self, G_CONNECT_SWAPPED); + g_signal_connect_object (widget, "activate", G_CALLBACK (ensure_empty_address_row), self, G_CONNECT_SWAPPED); + g_object_set_data (G_OBJECT (row), "address", widget); + gtk_editable_set_text (GTK_EDITABLE (widget), address); + gtk_editable_set_width_chars (GTK_EDITABLE (widget), 16); + gtk_widget_set_hexpand (widget, TRUE); + gtk_accessible_update_relation (GTK_ACCESSIBLE (widget), + GTK_ACCESSIBLE_RELATION_LABELLED_BY, self->address_address_label, NULL, + -1); + gtk_box_append (GTK_BOX (row_box), widget); + + widget = GTK_WIDGET (ce_netmask_entry_new ()); + g_signal_connect_object (widget, "changed", G_CALLBACK (ce_page_changed), self, G_CONNECT_SWAPPED); + g_signal_connect_object (widget, "activate", G_CALLBACK (ensure_empty_address_row), self, G_CONNECT_SWAPPED); + g_object_set_data (G_OBJECT (row), "netmask", widget); + gtk_editable_set_text (GTK_EDITABLE (widget), network); + gtk_editable_set_width_chars (GTK_EDITABLE (widget), 16); + gtk_widget_set_hexpand (widget, TRUE); + gtk_accessible_update_relation (GTK_ACCESSIBLE (widget), + GTK_ACCESSIBLE_RELATION_LABELLED_BY, self->address_netmask_label, NULL, + -1); + gtk_box_append (GTK_BOX (row_box), widget); + + widget = GTK_WIDGET (ce_ip_address_entry_new (AF_INET)); + g_signal_connect_object (widget, "changed", G_CALLBACK (ce_page_changed), self, G_CONNECT_SWAPPED); + g_signal_connect_object (widget, "activate", G_CALLBACK (ensure_empty_address_row), self, G_CONNECT_SWAPPED); + g_object_set_data (G_OBJECT (row), "gateway", widget); + gtk_editable_set_text (GTK_EDITABLE (widget), gateway ? gateway : ""); + gtk_editable_set_width_chars (GTK_EDITABLE (widget), 16); + gtk_widget_set_hexpand (widget, TRUE); + gtk_accessible_update_relation (GTK_ACCESSIBLE (widget), + GTK_ACCESSIBLE_RELATION_LABELLED_BY, self->address_gateway_label, NULL, + -1); + gtk_box_append (GTK_BOX (row_box), widget); + + delete_button = gtk_button_new_from_icon_name ("edit-delete-symbolic"); + gtk_widget_set_sensitive (delete_button, FALSE); + g_signal_connect_object (delete_button, "clicked", G_CALLBACK (remove_row), self, G_CONNECT_SWAPPED); + gtk_accessible_update_property (GTK_ACCESSIBLE (delete_button), + GTK_ACCESSIBLE_PROPERTY_LABEL, _("Delete Address"), + -1); + gtk_box_append (GTK_BOX (row_box), delete_button); + g_object_set_data (G_OBJECT (row), "delete-button", delete_button); + + gtk_size_group_add_widget (self->address_sizegroup, delete_button); + + gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), row_box); + gtk_list_box_append (GTK_LIST_BOX (self->address_list), row); + + update_row_gateway_sensitivity (self); + update_row_sensitivity (self, self->address_list); +} + +static void +ensure_empty_address_row (CEPageIP4 *self) +{ + GtkWidget *child = gtk_widget_get_last_child (self->address_list); + + /* Add the last, stub row if needed*/ + if (!child || validate_row (child)) + add_address_row (self, "", "", ""); +} + +static void +add_address_box (CEPageIP4 *self) +{ + GtkWidget *list; + gint i; + + self->address_list = list = gtk_list_box_new (); + gtk_list_box_set_selection_mode (GTK_LIST_BOX (list), GTK_SELECTION_NONE); + gtk_box_append (self->address_box, list); + + for (i = 0; i < nm_setting_ip_config_get_num_addresses (self->setting); i++) { + NMIPAddress *addr; + struct in_addr tmp_addr; + gchar network[INET_ADDRSTRLEN + 1]; + + addr = nm_setting_ip_config_get_address (self->setting, i); + if (!addr) + continue; + + tmp_addr.s_addr = nm_utils_ip4_prefix_to_netmask (nm_ip_address_get_prefix (addr)); + (void) inet_ntop (AF_INET, &tmp_addr, &network[0], sizeof (network)); + + add_address_row (self, + nm_ip_address_get_address (addr), + network, + i == 0 ? nm_setting_ip_config_get_gateway (self->setting) : ""); + } + if (nm_setting_ip_config_get_num_addresses (self->setting) == 0) + ensure_empty_address_row (self); +} + +static void +add_dns_section (CEPageIP4 *self) +{ + GString *string; + gint i; + + gtk_switch_set_active (self->auto_dns_switch, !nm_setting_ip_config_get_ignore_auto_dns (self->setting)); + g_signal_connect_object (self->auto_dns_switch, "notify::active", G_CALLBACK (ce_page_changed), self, G_CONNECT_SWAPPED); + + string = g_string_new (""); + + for (i = 0; i < nm_setting_ip_config_get_num_dns (self->setting); i++) { + const char *address; + + address = nm_setting_ip_config_get_dns (self->setting, i); + + if (i > 0) + g_string_append (string, ", "); + + g_string_append (string, address); + } + + gtk_editable_set_text (GTK_EDITABLE (self->dns_entry), string->str); + + g_signal_connect_object (self->dns_entry, "notify::text", G_CALLBACK (ce_page_changed), self, G_CONNECT_SWAPPED); + + g_string_free (string, TRUE); +} + +static void +add_route_row (CEPageIP4 *self, + const gchar *address, + const gchar *netmask, + const gchar *gateway, + gint metric) +{ + GtkWidget *row; + GtkWidget *row_box; + GtkWidget *widget; + GtkWidget *delete_button; + + row = gtk_list_box_row_new (); + gtk_list_box_row_set_activatable (GTK_LIST_BOX_ROW (row), FALSE); + + row_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); + gtk_widget_add_css_class (row_box, "linked"); + + widget = GTK_WIDGET (ce_ip_address_entry_new (AF_INET)); + g_signal_connect_object (widget, "changed", G_CALLBACK (ce_page_changed), self, G_CONNECT_SWAPPED); + g_signal_connect_object (widget, "activate", G_CALLBACK (ensure_empty_routes_row), self, G_CONNECT_SWAPPED); + g_object_set_data (G_OBJECT (row), "address", widget); + gtk_editable_set_text (GTK_EDITABLE (widget), address); + gtk_editable_set_width_chars (GTK_EDITABLE (widget), 16); + gtk_widget_set_hexpand (widget, TRUE); + gtk_accessible_update_relation (GTK_ACCESSIBLE (widget), + GTK_ACCESSIBLE_RELATION_LABELLED_BY, self->routes_address_label, NULL, + -1); + gtk_box_append (GTK_BOX (row_box), widget); + + widget = GTK_WIDGET (ce_netmask_entry_new ()); + g_signal_connect_object (widget, "changed", G_CALLBACK (ce_page_changed), self, G_CONNECT_SWAPPED); + g_signal_connect_object (widget, "activate", G_CALLBACK (ensure_empty_routes_row), self, G_CONNECT_SWAPPED); + g_object_set_data (G_OBJECT (row), "netmask", widget); + gtk_editable_set_text (GTK_EDITABLE (widget), netmask); + gtk_editable_set_width_chars (GTK_EDITABLE (widget), 16); + gtk_widget_set_hexpand (widget, TRUE); + gtk_accessible_update_relation (GTK_ACCESSIBLE (widget), + GTK_ACCESSIBLE_RELATION_LABELLED_BY, self->routes_netmask_label, NULL, + -1); + gtk_box_append (GTK_BOX (row_box), widget); + + widget = GTK_WIDGET (ce_ip_address_entry_new (AF_INET)); + g_signal_connect_object (widget, "changed", G_CALLBACK (ce_page_changed), self, G_CONNECT_SWAPPED); + g_signal_connect_object (widget, "activate", G_CALLBACK (ensure_empty_routes_row), self, G_CONNECT_SWAPPED); + g_object_set_data (G_OBJECT (row), "gateway", widget); + gtk_editable_set_text (GTK_EDITABLE (widget), gateway ? gateway : ""); + gtk_editable_set_width_chars (GTK_EDITABLE (widget), 16); + gtk_widget_set_hexpand (widget, TRUE); + gtk_accessible_update_relation (GTK_ACCESSIBLE (widget), + GTK_ACCESSIBLE_RELATION_LABELLED_BY, self->routes_gateway_label, NULL, + -1); + gtk_box_append (GTK_BOX (row_box), widget); + + widget = gtk_entry_new (); + g_signal_connect_object (widget, "changed", G_CALLBACK (ce_page_changed), self, G_CONNECT_SWAPPED); + g_signal_connect_object (widget, "activate", G_CALLBACK (ensure_empty_routes_row), self, G_CONNECT_SWAPPED); + g_object_set_data (G_OBJECT (row), "metric", widget); + if (metric >= 0) { + g_autofree gchar *s = g_strdup_printf ("%d", metric); + gtk_editable_set_text (GTK_EDITABLE (widget), s); + } + gtk_editable_set_width_chars (GTK_EDITABLE (widget), 5); + gtk_widget_set_hexpand (widget, TRUE); + gtk_accessible_update_relation (GTK_ACCESSIBLE (widget), + GTK_ACCESSIBLE_RELATION_LABELLED_BY, self->routes_metric_label, NULL, + -1); + gtk_box_append (GTK_BOX (row_box), widget); + + gtk_size_group_add_widget (self->routes_metric_sizegroup, widget); + + delete_button = gtk_button_new_from_icon_name ("edit-delete-symbolic"); + gtk_widget_set_sensitive (delete_button, FALSE); + g_signal_connect_object (delete_button, "clicked", G_CALLBACK (remove_row), self, G_CONNECT_SWAPPED); + gtk_accessible_update_property (GTK_ACCESSIBLE (delete_button), + GTK_ACCESSIBLE_PROPERTY_LABEL, _("Delete Route"), + -1); + gtk_widget_set_halign (delete_button, GTK_ALIGN_CENTER); + gtk_widget_set_valign (delete_button, GTK_ALIGN_CENTER); + gtk_box_append (GTK_BOX (row_box), delete_button); + g_object_set_data (G_OBJECT (row), "delete-button", delete_button); + + gtk_size_group_add_widget (self->routes_sizegroup, delete_button); + + gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), row_box); + gtk_list_box_append (GTK_LIST_BOX (self->routes_list), row); + + update_row_sensitivity (self, self->routes_list); +} + +static void +ensure_empty_routes_row (CEPageIP4 *self) +{ + GtkWidget *child = gtk_widget_get_last_child (self->routes_list); + + /* Add the last, stub row if needed*/ + if (!child || validate_row (child)) + add_route_row (self, "", "", "", -1); +} + +static void +add_routes_box (CEPageIP4 *self) +{ + GtkWidget *list; + gint i; + + self->routes_list = list = gtk_list_box_new (); + gtk_list_box_set_selection_mode (GTK_LIST_BOX (list), GTK_SELECTION_NONE); + gtk_box_append (GTK_BOX (self->routes_box), list); + gtk_switch_set_active (self->auto_routes_switch, !nm_setting_ip_config_get_ignore_auto_routes (self->setting)); + g_signal_connect_object (self->auto_routes_switch, "notify::active", G_CALLBACK (ce_page_changed), self, G_CONNECT_SWAPPED); + + for (i = 0; i < nm_setting_ip_config_get_num_routes (self->setting); i++) { + NMIPRoute *route; + struct in_addr tmp_addr; + gchar netmask[INET_ADDRSTRLEN + 1]; + + route = nm_setting_ip_config_get_route (self->setting, i); + if (!route) + continue; + + tmp_addr.s_addr = nm_utils_ip4_prefix_to_netmask (nm_ip_route_get_prefix (route)); + (void) inet_ntop (AF_INET, &tmp_addr, &netmask[0], sizeof (netmask)); + + add_route_row (self, + nm_ip_route_get_dest (route), + netmask, + nm_ip_route_get_next_hop (route), + nm_ip_route_get_metric (route)); + } + if (nm_setting_ip_config_get_num_routes (self->setting) == 0) + ensure_empty_routes_row (self); +} + +static void +connect_ip4_page (CEPageIP4 *self) +{ + const gchar *str_method; + guint method; + + add_address_box (self); + add_dns_section (self); + add_routes_box (self); + + str_method = nm_setting_ip_config_get_method (self->setting); + g_signal_connect_object (self->disabled_radio, "notify::active", G_CALLBACK (ce_page_changed), self, G_CONNECT_SWAPPED); + g_object_bind_property (self->disabled_radio, "active", + self->content_box, "sensitive", + G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); + + g_signal_connect_object (self->shared_radio, "notify::active", G_CALLBACK (ce_page_changed), self, G_CONNECT_SWAPPED); + g_object_bind_property (self->shared_radio, "active", + self->content_box, "sensitive", + G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); + + method = IP4_METHOD_AUTO; + if (g_strcmp0 (str_method, NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL) == 0) { + method = IP4_METHOD_LINK_LOCAL; + } else if (g_strcmp0 (str_method, NM_SETTING_IP4_CONFIG_METHOD_MANUAL) == 0) { + method = IP4_METHOD_MANUAL; + } else if (g_strcmp0 (str_method, NM_SETTING_IP4_CONFIG_METHOD_SHARED) == 0) { + method = IP4_METHOD_SHARED; + } else if (g_strcmp0 (str_method, NM_SETTING_IP4_CONFIG_METHOD_DISABLED) == 0) { + method = IP4_METHOD_DISABLED; + } + + gtk_check_button_set_active (GTK_CHECK_BUTTON (self->never_default_check), + nm_setting_ip_config_get_never_default (self->setting)); + g_signal_connect_object (self->never_default_check, "toggled", G_CALLBACK (ce_page_changed), self, G_CONNECT_SWAPPED); + + g_signal_connect_object (self->automatic_radio, "toggled", G_CALLBACK (method_changed), self, G_CONNECT_SWAPPED); + g_signal_connect_object (self->local_radio, "toggled", G_CALLBACK (method_changed), self, G_CONNECT_SWAPPED); + g_signal_connect_object (self->manual_radio, "toggled", G_CALLBACK (method_changed), self, G_CONNECT_SWAPPED); + g_signal_connect_object (self->disabled_radio, "toggled", G_CALLBACK (method_changed), self, G_CONNECT_SWAPPED); + + switch (method) { + case IP4_METHOD_AUTO: + gtk_check_button_set_active (GTK_CHECK_BUTTON (self->automatic_radio), TRUE); + break; + case IP4_METHOD_LINK_LOCAL: + gtk_check_button_set_active (GTK_CHECK_BUTTON (self->local_radio), TRUE); + break; + case IP4_METHOD_MANUAL: + gtk_check_button_set_active (GTK_CHECK_BUTTON (self->manual_radio), TRUE); + break; + case IP4_METHOD_SHARED: + gtk_check_button_set_active (GTK_CHECK_BUTTON (self->shared_radio), TRUE); + break; + case IP4_METHOD_DISABLED: + gtk_check_button_set_active (GTK_CHECK_BUTTON (self->disabled_radio), TRUE); + break; + default: + break; + } + + method_changed (self); +} + +static gboolean +ui_to_setting (CEPageIP4 *self) +{ + const gchar *method; + gboolean ignore_auto_dns; + gboolean ignore_auto_routes; + gboolean never_default; + GPtrArray *addresses = NULL; + GPtrArray *dns_servers = NULL; + GPtrArray *routes = NULL; + GtkWidget *child; + GStrv dns_addresses = NULL; + gboolean ret = TRUE; + const char *default_gateway = NULL; + gboolean add_addresses = FALSE; + gboolean add_routes = FALSE; + gchar *dns_text = NULL; + guint i; + + if (gtk_check_button_get_active (GTK_CHECK_BUTTON (self->disabled_radio))) + method = NM_SETTING_IP4_CONFIG_METHOD_DISABLED; + else if (gtk_check_button_get_active (GTK_CHECK_BUTTON (self->automatic_radio))) + method = NM_SETTING_IP4_CONFIG_METHOD_AUTO; + else if (gtk_check_button_get_active (GTK_CHECK_BUTTON (self->local_radio))) + method = NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL; + else if (gtk_check_button_get_active (GTK_CHECK_BUTTON (self->manual_radio))) + method = NM_SETTING_IP4_CONFIG_METHOD_MANUAL; + else if (gtk_check_button_get_active (GTK_CHECK_BUTTON (self->shared_radio))) + method = NM_SETTING_IP4_CONFIG_METHOD_SHARED; + + addresses = g_ptr_array_new_with_free_func ((GDestroyNotify) nm_ip_address_unref); + add_addresses = g_str_equal (method, NM_SETTING_IP4_CONFIG_METHOD_MANUAL); + + for (child = gtk_widget_get_first_child (self->address_list); + add_addresses && child; + child = gtk_widget_get_next_sibling (child)) { + GtkWidget *row = child; + CEIPAddressEntry *address_entry; + CENetmaskEntry *netmask_entry; + CEIPAddressEntry *gateway_entry; + NMIPAddress *addr; + + address_entry = CE_IP_ADDRESS_ENTRY (g_object_get_data (G_OBJECT (row), "address")); + if (!address_entry) + continue; + + netmask_entry = CE_NETMASK_ENTRY (g_object_get_data (G_OBJECT (row), "netmask")); + gateway_entry = CE_IP_ADDRESS_ENTRY (g_object_get_data (G_OBJECT (row), "gateway")); + + if (ce_ip_address_entry_is_empty (address_entry) && ce_netmask_entry_is_empty (netmask_entry) && ce_ip_address_entry_is_empty (gateway_entry)) { + /* ignore empty rows */ + continue; + } + + if (!ce_ip_address_entry_is_valid (address_entry)) + ret = FALSE; + + if (!ce_netmask_entry_is_valid (netmask_entry)) + ret = FALSE; + + if (!ce_ip_address_entry_is_valid (gateway_entry)) { + ret = FALSE; + } else { + if (!ce_ip_address_entry_is_empty (gateway_entry)) { + g_assert (default_gateway == NULL); + default_gateway = gtk_editable_get_text (GTK_EDITABLE (gateway_entry)); + } + } + + if (!ret) + continue; + + addr = nm_ip_address_new (AF_INET, gtk_editable_get_text (GTK_EDITABLE (address_entry)), ce_netmask_entry_get_prefix (netmask_entry), NULL); + if (addr) + g_ptr_array_add (addresses, addr); + + if (!gtk_widget_get_next_sibling (row)) + ensure_empty_address_row (self); + } + + if (addresses->len == 0) { + g_ptr_array_free (addresses, TRUE); + addresses = NULL; + } + + dns_servers = g_ptr_array_new_with_free_func (g_free); + dns_text = g_strstrip (g_strdup (gtk_editable_get_text (GTK_EDITABLE (self->dns_entry)))); + if (g_str_equal (method, NM_SETTING_IP4_CONFIG_METHOD_AUTO) || + g_str_equal (method, NM_SETTING_IP4_CONFIG_METHOD_MANUAL)) + dns_addresses = g_strsplit_set (dns_text, ", ", -1); + else + dns_addresses = NULL; + + for (i = 0; dns_addresses && dns_addresses[i]; i++) { + const gchar *text; + + text = dns_addresses[i]; + + if (!text || !*text) + continue; + + if (!nm_utils_ipaddr_valid (AF_INET, text)) { + g_ptr_array_remove_range (dns_servers, 0, dns_servers->len); + widget_set_error (GTK_WIDGET (self->dns_entry)); + ret = FALSE; + break; + } else { + widget_unset_error (GTK_WIDGET (self->dns_entry)); + g_ptr_array_add (dns_servers, g_strdup (text)); + } + } + g_clear_pointer (&dns_addresses, g_strfreev); + + if (dns_servers->len == 0) { + g_ptr_array_free (dns_servers, TRUE); + dns_servers = NULL; + } else { + g_ptr_array_add (dns_servers, NULL); + } + + routes = g_ptr_array_new_with_free_func ((GDestroyNotify) nm_ip_route_unref); + add_routes = g_str_equal (method, NM_SETTING_IP4_CONFIG_METHOD_AUTO) || + g_str_equal (method, NM_SETTING_IP4_CONFIG_METHOD_MANUAL); + + for (child = gtk_widget_get_first_child (self->routes_list); + add_routes && child; + child = gtk_widget_get_next_sibling (child)) { + GtkWidget *row = child; + CEIPAddressEntry *address_entry; + CENetmaskEntry *netmask_entry; + CEIPAddressEntry *gateway_entry; + const gchar *text_metric; + gint64 metric; + NMIPRoute *route; + + address_entry = CE_IP_ADDRESS_ENTRY (g_object_get_data (G_OBJECT (row), "address")); + if (!address_entry) + continue; + + netmask_entry = CE_NETMASK_ENTRY (g_object_get_data (G_OBJECT (row), "netmask")); + gateway_entry = CE_IP_ADDRESS_ENTRY (g_object_get_data (G_OBJECT (row), "gateway")); + text_metric = gtk_editable_get_text (GTK_EDITABLE (g_object_get_data (G_OBJECT (row), "metric"))); + + if (ce_ip_address_entry_is_empty (address_entry) && ce_netmask_entry_is_empty (netmask_entry) && ce_ip_address_entry_is_empty (gateway_entry) && !*text_metric) { + /* ignore empty rows */ + continue; + } + + if (!ce_ip_address_entry_is_valid (address_entry)) + ret = FALSE; + + if (!ce_netmask_entry_is_valid (netmask_entry)) + ret = FALSE; + + if (!ce_ip_address_entry_is_valid (gateway_entry)) + ret = FALSE; + + metric = -1; + if (*text_metric) { + errno = 0; + metric = g_ascii_strtoull (text_metric, NULL, 10); + if (errno || metric < 0 || metric > G_MAXUINT32) { + widget_set_error (GTK_WIDGET (g_object_get_data (G_OBJECT (row), "metric"))); + ret = FALSE; + } else { + widget_unset_error (GTK_WIDGET (g_object_get_data (G_OBJECT (row), "metric"))); + } + } else { + widget_unset_error (GTK_WIDGET (g_object_get_data (G_OBJECT (row), "metric"))); + } + + if (!ret) + continue; + + route = nm_ip_route_new (AF_INET, + gtk_editable_get_text (GTK_EDITABLE (address_entry)), + ce_netmask_entry_get_prefix (netmask_entry), + gtk_editable_get_text (GTK_EDITABLE (gateway_entry)), + metric, NULL); + if (route) + g_ptr_array_add (routes, route); + + if (!gtk_widget_get_next_sibling (row)) + ensure_empty_routes_row (self); + } + + if (routes->len == 0) { + g_ptr_array_free (routes, TRUE); + routes = NULL; + } + + if (!ret) + goto out; + + ignore_auto_dns = !gtk_switch_get_active (self->auto_dns_switch); + ignore_auto_routes = !gtk_switch_get_active (self->auto_routes_switch); + never_default = gtk_check_button_get_active (GTK_CHECK_BUTTON (self->never_default_check)); + + g_object_set (self->setting, + NM_SETTING_IP_CONFIG_METHOD, method, + NM_SETTING_IP_CONFIG_ADDRESSES, addresses, + NM_SETTING_IP_CONFIG_GATEWAY, default_gateway, + NM_SETTING_IP_CONFIG_DNS, dns_servers ? dns_servers->pdata : NULL, + NM_SETTING_IP_CONFIG_ROUTES, routes, + NM_SETTING_IP_CONFIG_IGNORE_AUTO_DNS, ignore_auto_dns, + NM_SETTING_IP_CONFIG_IGNORE_AUTO_ROUTES, ignore_auto_routes, + NM_SETTING_IP_CONFIG_NEVER_DEFAULT, never_default, + NULL); + +out: + if (addresses) + g_ptr_array_free (addresses, TRUE); + + if (dns_servers) + g_ptr_array_free (dns_servers, TRUE); + + if (routes) + g_ptr_array_free (routes, TRUE); + + g_clear_pointer (&dns_text, g_free); + + return ret; +} + +static const gchar * +ce_page_ip4_get_title (CEPage *page) +{ + return _("IPv4"); +} + +static gboolean +ce_page_ip4_validate (CEPage *self, + NMConnection *connection, + GError **error) +{ + if (!ui_to_setting (CE_PAGE_IP4 (self))) + return FALSE; + + return nm_setting_verify (NM_SETTING (CE_PAGE_IP4 (self)->setting), NULL, error); +} + +static void +ce_page_ip4_init (CEPageIP4 *self) +{ + gtk_widget_init_template (GTK_WIDGET (self)); +} + +static void +ce_page_ip4_class_init (CEPageIP4Class *klass) +{ + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/network/ip4-page.ui"); + + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, address_box); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, address_sizegroup); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, auto_dns_switch); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, auto_routes_switch); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, automatic_radio); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, content_box); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, disabled_radio); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, dns_entry); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, local_radio); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, main_box); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, manual_radio); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, never_default_check); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, address_address_label); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, address_netmask_label); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, address_gateway_label); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, routes_box); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, routes_address_label); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, routes_netmask_label); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, routes_gateway_label); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, routes_metric_label); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, routes_metric_sizegroup); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, routes_sizegroup); + gtk_widget_class_bind_template_child (widget_class, CEPageIP4, shared_radio); +} + +static void +ce_page_iface_init (CEPageInterface *iface) +{ + iface->get_title = ce_page_ip4_get_title; + iface->validate = ce_page_ip4_validate; +} + +CEPageIP4 * +ce_page_ip4_new (NMConnection *connection, + NMClient *client) +{ + CEPageIP4 *self; + + self = CE_PAGE_IP4 (g_object_new (ce_page_ip4_get_type (), NULL)); + + self->setting = nm_connection_get_setting_ip4_config (connection); + if (!self->setting) { + self->setting = NM_SETTING_IP_CONFIG (nm_setting_ip4_config_new ()); + nm_connection_add_setting (connection, NM_SETTING (self->setting)); + } + + connect_ip4_page (self); + + return self; +} |