static void cell_edited (GtkCellRendererText *cell, const gchar *path_string, const gchar *new_text, gpointer user_data) { CEPageIP4 *self = CE_PAGE_IP4 (user_data); CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); GtkListStore *store = GTK_LIST_STORE (gtk_tree_view_get_model (priv->addr_list)); GtkTreePath *path = gtk_tree_path_new_from_string (path_string); GtkTreeIter iter; guint32 column; GtkTreeViewColumn *next_col; column = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (cell), "column")); gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path); gtk_list_store_set (store, &iter, column, new_text, -1); /* Move focus to the next column */ column = (column >= COL_LAST) ? 0 : column + 1; next_col = gtk_tree_view_get_column (priv->addr_list, column); gtk_tree_view_set_cursor_on_cell (priv->addr_list, path, next_col, priv->addr_cells[column], TRUE); gtk_widget_grab_focus (GTK_WIDGET (priv->addr_list)); gtk_tree_path_free (path); ce_page_changed (CE_PAGE (self)); }
static void addr_add_clicked (GtkButton *button, gpointer user_data) { CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (user_data); GtkListStore *store; GtkTreeIter iter; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkTreePath *path; GList *cells; store = GTK_LIST_STORE (gtk_tree_view_get_model (priv->addr_list)); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COL_ADDRESS, "", -1); selection = gtk_tree_view_get_selection (priv->addr_list); gtk_tree_selection_select_iter (selection, &iter); path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter); column = gtk_tree_view_get_column (priv->addr_list, COL_ADDRESS); /* FIXME: using cells->data is pretty fragile but GTK apparently doesn't * have a way to get a cell renderer from a column based on path or iter * or whatever. */ cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column)); gtk_tree_view_set_cursor_on_cell (priv->addr_list, path, column, cells->data, TRUE); g_list_free (cells); gtk_tree_path_free (path); }
static void change_method_combo (CEPage *page, gboolean is_hotspot) { CEPageIP4 *self = CE_PAGE_IP4 (page); CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); /* Store previous active method */ if (get_method_sensitivity (page, IP4_METHOD_AUTO)) priv->normal_method_idx = gtk_combo_box_get_active (priv->method); else priv->hotspot_method_idx = gtk_combo_box_get_active (priv->method); /* Set active method */ if (is_hotspot) { if (priv->hotspot_method_idx == -1) { int method = IP4_METHOD_SHARED; if (g_strcmp0 (nm_setting_ip_config_get_method (priv->setting), NM_SETTING_IP4_CONFIG_METHOD_DISABLED) == 0) method = IP4_METHOD_DISABLED; gtk_combo_box_set_active (priv->method, method); } else gtk_combo_box_set_active (priv->method, priv->hotspot_method_idx); } else { if (priv->normal_method_idx != -1) gtk_combo_box_set_active (priv->method, priv->normal_method_idx); } toggle_method_sensitivity (page, IP4_METHOD_AUTO, !is_hotspot); toggle_method_sensitivity (page, IP4_METHOD_AUTO_ADDRESSES, !is_hotspot); toggle_method_sensitivity (page, IP4_METHOD_MANUAL, !is_hotspot); toggle_method_sensitivity (page, IP4_METHOD_LINK_LOCAL, !is_hotspot); }
static void cell_editing_canceled (GtkCellRenderer *renderer, gpointer user_data) { CEPageIP4 *self; CEPageIP4Private *priv; GtkTreeModel *model = NULL; GtkTreeSelection *selection; GtkTreeIter iter; guint32 column; /* user_data disposed? */ if (GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (renderer), "ce-page-not-valid"))) return; self = CE_PAGE_IP4 (user_data); priv = CE_PAGE_IP4_GET_PRIVATE (self); if (priv->last_edited) { selection = gtk_tree_view_get_selection (priv->addr_list); if (gtk_tree_selection_get_selected (selection, &model, &iter)) { column = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (renderer), "column")); gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, priv->last_edited, -1); } g_free (priv->last_edited); priv->last_edited = NULL; ce_page_changed (CE_PAGE (self)); } g_free (priv->last_path); priv->last_path = NULL; priv->last_column = -1; }
static gboolean tree_view_button_pressed_cb (GtkWidget *widget, GdkEvent *event, gpointer user_data) { CEPageIP4 *self = CE_PAGE_IP4 (user_data); CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); /* last_edited can be set e.g. when we get here by clicking an cell while * editing another cell. GTK3 issue neither editing-canceled nor editing-done * for cell renderer. Thus the previous cell value isn't saved. Store it now. */ if (priv->last_edited && priv->last_path) { GtkTreeIter iter; GtkListStore *store = GTK_LIST_STORE (gtk_tree_view_get_model (priv->addr_list)); GtkTreePath *last_treepath = gtk_tree_path_new_from_string (priv->last_path); gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, last_treepath); gtk_list_store_set (store, &iter, priv->last_column, priv->last_edited, -1); gtk_tree_path_free (last_treepath); g_free (priv->last_edited); priv->last_edited = NULL; g_free (priv->last_path); priv->last_path = NULL; priv->last_column = -1; } /* Ignore double clicks events. (They are issued after the single clicks, see GdkEventButton) */ if (event->type == GDK_2BUTTON_PRESS) return TRUE; gtk_widget_grab_focus (GTK_WIDGET (priv->addr_list)); return FALSE; }
static void ce_page_ip4_init (CEPageIP4 *self) { CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); priv->last_column = -1; priv->normal_method_idx = -1; priv->hotspot_method_idx = -1; }
static gboolean ce_page_validate_v (CEPage *page, NMConnection *connection, GError **error) { CEPageIP4 *self = CE_PAGE_IP4 (page); CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); if (!ui_to_setting (self, error)) return FALSE; return nm_setting_verify (NM_SETTING (priv->setting), NULL, error); }
static void toggle_method_sensitivity (CEPage *page, int column, gboolean sensitive) { CEPageIP4 *self = CE_PAGE_IP4 (page); CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); GtkTreeModel *model = GTK_TREE_MODEL (priv->method_store); GtkTreeIter iter; if (get_iter_for_method (model, column, &iter)) gtk_list_store_set (priv->method_store, &iter, METHOD_COL_ENABLED, sensitive, -1); }
CEPage * ce_page_ip4_new (NMConnection *connection, GtkWindow *parent_window, GError **error) { CEPageIP4 *self; CEPageIP4Private *priv; CEPage *parent; NMSettingConnection *s_con; self = CE_PAGE_IP4 (g_object_new (CE_TYPE_PAGE_IP4, CE_PAGE_CONNECTION, connection, CE_PAGE_PARENT_WINDOW, parent_window, NULL)); parent = CE_PAGE (self); parent->xml = glade_xml_new (GLADEDIR "/ce-page-ip4.glade", "IP4Page", NULL); if (!parent->xml) { g_set_error (error, 0, 0, "%s", _("Could not load IPv4 user interface.")); g_object_unref (self); return NULL; } parent->page = glade_xml_get_widget (parent->xml, "IP4Page"); if (!parent->page) { g_set_error (error, 0, 0, "%s", _("Could not load IPv4 user interface.")); g_object_unref (self); return NULL; } g_object_ref_sink (parent->page); parent->title = g_strdup (_("IPv4 Settings")); ip4_private_init (self, connection); priv = CE_PAGE_IP4_GET_PRIVATE (self); priv->window_group = gtk_window_group_new (); s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); priv->connection_id = g_strdup (nm_setting_connection_get_id (s_con)); priv->setting = (NMSettingIP4Config *) nm_connection_get_setting (connection, NM_TYPE_SETTING_IP4_CONFIG); if (!priv->setting) { priv->setting = NM_SETTING_IP4_CONFIG (nm_setting_ip4_config_new ()); nm_connection_add_setting (connection, NM_SETTING (priv->setting)); } g_signal_connect (self, "initialized", G_CALLBACK (finish_setup), NULL); if (!ce_page_initialize (parent, NULL, error)) { g_object_unref (self); return NULL; } return CE_PAGE (self); }
static void routes_dialog_response_cb (GtkWidget *dialog, gint response, gpointer user_data) { CEPageIP4 *self = CE_PAGE_IP4 (user_data); CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); if (response == GTK_RESPONSE_OK) ip4_routes_dialog_update_setting (dialog, priv->setting); routes_dialog_close_cb (dialog, NULL); }
static void dispose (GObject *object) { CEPageIP4 *self = CE_PAGE_IP4 (object); CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); if (priv->window_group) g_object_unref (priv->window_group); g_free (priv->connection_id); G_OBJECT_CLASS (ce_page_ip4_parent_class)->dispose (object); }
static gboolean get_method_sensitivity (CEPage *page, int column) { CEPageIP4 *self = CE_PAGE_IP4 (page); CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); GtkTreeModel *model = GTK_TREE_MODEL (priv->method_store); GtkTreeIter iter; gboolean sensitive = FALSE; if (get_iter_for_method (model, column, &iter)) gtk_tree_model_get (GTK_TREE_MODEL (priv->method_store), &iter, METHOD_COL_ENABLED, &sensitive, -1); return sensitive; }
static void delete_text_cb (GtkEditable *editable, gint start_pos, gint end_pos, gpointer user_data) { CEPageIP4 *self = CE_PAGE_IP4 (user_data); CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); /* Keep last_edited up-to-date */ g_free (priv->last_edited); priv->last_edited = gtk_editable_get_chars (editable, 0, -1); }
static void cell_editing_started (GtkCellRenderer *cell, GtkCellEditable *editable, const gchar *path, gpointer user_data) { CEPageIP4 *self = CE_PAGE_IP4 (user_data); CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); GtkTreeModel *model; GtkTreeIter iter; AddressLineInfo *info; if (!GTK_IS_ENTRY (editable)) { g_warning ("%s: Unexpected cell editable type.", __func__); return; } /* Initialize last_path and last_column, last_edited is initialized when the cell is edited */ g_free (priv->last_edited); priv->last_edited = NULL; g_free (priv->last_path); priv->last_path = g_strdup (path); priv->last_column = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (cell), "column")); /* Set up the entry filter */ g_signal_connect (G_OBJECT (editable), "insert-text", (GCallback) ip_address_filter_cb, user_data); g_signal_connect_after (G_OBJECT (editable), "delete-text", (GCallback) delete_text_cb, user_data); /* Set up handler for IP verifying and changing cell background */ model = gtk_tree_view_get_model (priv->addr_list); gtk_tree_model_get_iter_from_string (model, &iter, priv->last_path); info = g_slice_new0 (AddressLineInfo); info->model = model; info->iter = iter; info->column = priv->last_column; g_signal_connect_data (G_OBJECT (editable), "changed", (GCallback) cell_changed_cb, info, (GClosureNotify) address_line_info_destroy, 0); /* Set up key pressed handler - need to handle Tab key */ g_signal_connect (G_OBJECT (editable), "key-press-event", (GCallback) key_pressed_cb, cell); }
static void dispose (GObject *object) { CEPageIP4 *self = CE_PAGE_IP4 (object); CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); int i; g_clear_object (&priv->window_group); /* Mark CEPageIP4 object as invalid; store this indication to cells to be usable in callbacks */ for (i = 0; i <= COL_LAST; i++) g_object_set_data (G_OBJECT (priv->addr_cells[i]), "ce-page-not-valid", GUINT_TO_POINTER (1)); g_clear_pointer (&priv->connection_id, g_free); G_OBJECT_CLASS (ce_page_ip4_parent_class)->dispose (object); }
CEPage * ce_page_ip4_new (NMConnectionEditor *editor, NMConnection *connection, GtkWindow *parent_window, NMClient *client, const char **out_secrets_setting_name, GError **error) { CEPageIP4 *self; CEPageIP4Private *priv; NMSettingConnection *s_con; self = CE_PAGE_IP4 (ce_page_new (CE_TYPE_PAGE_IP4, editor, connection, parent_window, client, UIDIR "/ce-page-ip4.ui", "IP4Page", _("IPv4 Settings"))); if (!self) { g_set_error_literal (error, NMA_ERROR, NMA_ERROR_GENERIC, _("Could not load IPv4 user interface.")); return NULL; } ip4_private_init (self, connection); priv = CE_PAGE_IP4_GET_PRIVATE (self); priv->window_group = gtk_window_group_new (); s_con = nm_connection_get_setting_connection (connection); g_assert (s_con); priv->connection_id = g_strdup (nm_setting_connection_get_id (s_con)); priv->setting = nm_connection_get_setting_ip4_config (connection); g_assert (priv->setting); g_signal_connect (self, "initialized", G_CALLBACK (finish_setup), NULL); return CE_PAGE (self); }
static void ip_address_filter_cb (GtkEditable *editable, gchar *text, gint length, gint *position, gpointer user_data) { CEPageIP4 *self = CE_PAGE_IP4 (user_data); CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); gboolean changed; changed = utils_filter_editable_on_insert_text (editable, text, length, position, user_data, utils_char_is_ascii_ip4_address, ip_address_filter_cb); if (changed) { g_free (priv->last_edited); priv->last_edited = gtk_editable_get_chars (editable, 0, -1); } }
static void routes_button_clicked_cb (GtkWidget *button, gpointer user_data) { CEPageIP4 *self = CE_PAGE_IP4 (user_data); CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); GtkWidget *dialog, *toplevel; gboolean automatic = FALSE; const char *method; char *tmp; toplevel = gtk_widget_get_toplevel (CE_PAGE (self)->page); g_return_if_fail (GTK_WIDGET_TOPLEVEL (toplevel)); method = nm_setting_ip4_config_get_method (priv->setting); if (!method || !strcmp (method, NM_SETTING_IP4_CONFIG_METHOD_AUTO)) automatic = TRUE; dialog = ip4_routes_dialog_new (priv->setting, automatic); if (!dialog) { g_warning ("%s: failed to create the routes dialog!", __func__); return; } gtk_window_group_add_window (priv->window_group, GTK_WINDOW (dialog)); if (!priv->window_added) { gtk_window_group_add_window (priv->window_group, GTK_WINDOW (toplevel)); priv->window_added = TRUE; } gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (toplevel)); tmp = g_strdup_printf (_("Editing IPv4 routes for %s"), priv->connection_id); gtk_window_set_title (GTK_WINDOW (dialog), tmp); g_free (tmp); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (routes_dialog_response_cb), self); g_signal_connect (G_OBJECT (dialog), "close", G_CALLBACK (routes_dialog_close_cb), self); gtk_widget_show_all (dialog); }
static void populate_ui (CEPageIP4 *self) { CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); NMSettingIP4Config *setting = priv->setting; GtkListStore *store; GtkTreeIter model_iter; int method = IP4_METHOD_AUTO; GString *string = NULL; SetMethodInfo info; const char *str_method; int i; /* Method */ gtk_combo_box_set_active (priv->method, 0); str_method = nm_setting_ip4_config_get_method (setting); if (str_method) { if (!strcmp (str_method, NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL)) method = IP4_METHOD_LINK_LOCAL; else if (!strcmp (str_method, NM_SETTING_IP4_CONFIG_METHOD_MANUAL)) method = IP4_METHOD_MANUAL; else if (!strcmp (str_method, NM_SETTING_IP4_CONFIG_METHOD_SHARED)) method = IP4_METHOD_SHARED; } if (method == IP4_METHOD_AUTO && nm_setting_ip4_config_get_ignore_auto_dns (setting)) method = IP4_METHOD_AUTO_ADDRESSES; info.method = method; info.combo = priv->method; gtk_tree_model_foreach (GTK_TREE_MODEL (priv->method_store), set_method, &info); /* Addresses */ store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); for (i = 0; i < nm_setting_ip4_config_get_num_addresses (setting); i++) { NMIP4Address *addr = nm_setting_ip4_config_get_address (setting, i); struct in_addr tmp_addr; char buf[INET_ADDRSTRLEN + 1]; const char *ignored; if (!addr) { g_warning ("%s: empty IP4 Address structure!", __func__); continue; } gtk_list_store_append (store, &model_iter); tmp_addr.s_addr = nm_ip4_address_get_address (addr); ignored = inet_ntop (AF_INET, &tmp_addr, &buf[0], sizeof (buf)); gtk_list_store_set (store, &model_iter, COL_ADDRESS, buf, -1); tmp_addr.s_addr = nm_utils_ip4_prefix_to_netmask (nm_ip4_address_get_prefix (addr)); ignored = inet_ntop (AF_INET, &tmp_addr, &buf[0], sizeof (buf)); gtk_list_store_set (store, &model_iter, COL_PREFIX, buf, -1); tmp_addr.s_addr = nm_ip4_address_get_gateway (addr); ignored = inet_ntop (AF_INET, &tmp_addr, &buf[0], sizeof (buf)); gtk_list_store_set (store, &model_iter, COL_GATEWAY, buf, -1); } gtk_tree_view_set_model (priv->addr_list, GTK_TREE_MODEL (store)); g_signal_connect_swapped (store, "row-inserted", G_CALLBACK (ce_page_changed), self); g_signal_connect_swapped (store, "row-deleted", G_CALLBACK (ce_page_changed), self); g_object_unref (store); /* DNS servers */ string = g_string_new (""); for (i = 0; i < nm_setting_ip4_config_get_num_dns (setting); i++) { struct in_addr tmp_addr; char buf[INET_ADDRSTRLEN + 1]; const char *ignored; tmp_addr.s_addr = nm_setting_ip4_config_get_dns (setting, i); if (!tmp_addr.s_addr) continue; ignored = inet_ntop (AF_INET, &tmp_addr, &buf[0], sizeof (buf)); if (string->len) g_string_append (string, ", "); g_string_append (string, buf); } gtk_entry_set_text (priv->dns_servers, string->str); g_string_free (string, TRUE); /* DNS searches */ string = g_string_new (""); for (i = 0; i < nm_setting_ip4_config_get_num_dns_searches (setting); i++) { if (string->len) g_string_append (string, ", "); g_string_append (string, nm_setting_ip4_config_get_dns_search (setting, i)); } gtk_entry_set_text (priv->dns_searches, string->str); g_string_free (string, TRUE); if ((method == IP4_METHOD_AUTO) || (method = IP4_METHOD_AUTO_ADDRESSES)) { if (nm_setting_ip4_config_get_dhcp_client_id (setting)) { gtk_entry_set_text (priv->dhcp_client_id, nm_setting_ip4_config_get_dhcp_client_id (setting)); } } }
static void cell_edited (GtkCellRendererText *cell, const gchar *path_string, const gchar *new_text, gpointer user_data) { CEPageIP4 *self = CE_PAGE_IP4 (user_data); CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); GtkListStore *store = GTK_LIST_STORE (gtk_tree_view_get_model (priv->addr_list)); GtkTreePath *path = gtk_tree_path_new_from_string (path_string); GtkTreeIter iter; guint32 column; GtkTreeViewColumn *next_col; GtkCellRenderer *next_cell; gboolean can_cycle; int direction, tmp; /* Free auxiliary stuff */ g_free (priv->last_edited); priv->last_edited = NULL; g_free (priv->last_path); priv->last_path = NULL; priv->last_column = -1; column = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (cell), "column")); gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path); gtk_list_store_set (store, &iter, column, new_text, -1); /* Try to autodetect the prefix from the given address if we can */ if (column == COL_ADDRESS && new_text && strlen (new_text)) { char *prefix = NULL; const char *guess_prefix = NULL; gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &iter, path_string); gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, COL_PREFIX, &prefix, -1); if (!prefix || !strlen (prefix)) { if (!strncmp ("10.", new_text, 3)) guess_prefix = "8"; else if (!strncmp ("172.16.", new_text, 7)) guess_prefix = "16"; else if (!strncmp ("192.168.", new_text, 8)) guess_prefix = "24"; if (guess_prefix) gtk_list_store_set (store, &iter, COL_PREFIX, guess_prefix, -1); } g_free (prefix); } /* Move focus to the next/previous column */ can_cycle = g_object_get_data (G_OBJECT (cell), DO_NOT_CYCLE_TAG) == NULL; direction = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), DIRECTION_TAG)); g_object_set_data (G_OBJECT (cell), DIRECTION_TAG, NULL); g_object_set_data (G_OBJECT (cell), DO_NOT_CYCLE_TAG, NULL); if (direction == 0) /* Move forward by default */ direction = 1; tmp = column + direction; if (can_cycle) column = tmp < 0 ? COL_LAST : tmp > COL_LAST ? 0 : tmp; else column = tmp; next_col = gtk_tree_view_get_column (priv->addr_list, column); next_cell = column <= COL_LAST ? priv->addr_cells[column] : NULL; gtk_tree_view_set_cursor_on_cell (priv->addr_list, path, next_col, next_cell, TRUE); gtk_tree_path_free (path); ce_page_changed (CE_PAGE (self)); }
static gboolean ui_to_setting (CEPageIP4 *self) { CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); GtkTreeModel *model; GtkTreeIter tree_iter; int int_method = IP4_METHOD_AUTO; const char *method; GArray *dns_servers = NULL; GSList *search_domains = NULL; GPtrArray *addresses = NULL; gboolean valid = FALSE, iter_valid; const char *text; gboolean ignore_auto_dns = FALSE; const char *dhcp_client_id = NULL; char **items = NULL, **iter; /* Method */ if (gtk_combo_box_get_active_iter (priv->method, &tree_iter)) { gtk_tree_model_get (GTK_TREE_MODEL (priv->method_store), &tree_iter, METHOD_COL_NUM, &int_method, -1); } switch (int_method) { case IP4_METHOD_LINK_LOCAL: method = NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL; break; case IP4_METHOD_MANUAL: method = NM_SETTING_IP4_CONFIG_METHOD_MANUAL; break; case IP4_METHOD_SHARED: method = NM_SETTING_IP4_CONFIG_METHOD_SHARED; break; case IP4_METHOD_AUTO_ADDRESSES: ignore_auto_dns = TRUE; /* fall through */ default: method = NM_SETTING_IP4_CONFIG_METHOD_AUTO; break; } /* IP addresses */ model = gtk_tree_view_get_model (priv->addr_list); iter_valid = gtk_tree_model_get_iter_first (model, &tree_iter); addresses = g_ptr_array_sized_new (1); while (iter_valid) { char *item = NULL; struct in_addr tmp_addr, tmp_gateway = { 0 }; GArray *addr; guint32 empty_val = 0, prefix; gtk_tree_model_get (model, &tree_iter, COL_ADDRESS, &item, -1); if (!item || !inet_aton (item, &tmp_addr)) { g_warning ("%s: IPv4 address '%s' missing or invalid!", __func__, item ? item : "<none>"); g_free (item); goto out; } g_free (item); gtk_tree_model_get (model, &tree_iter, COL_PREFIX, &item, -1); if (!item) { g_warning ("%s: IPv4 prefix '%s' missing!", __func__, item ? item : "<none>"); goto out; } if (!parse_netmask (item, &prefix)) { g_warning ("%s: IPv4 prefix '%s' invalid!", __func__, item ? item : "<none>"); g_free (item); goto out; } g_free (item); /* Gateway is optional... */ gtk_tree_model_get (model, &tree_iter, COL_GATEWAY, &item, -1); if (item && !inet_aton (item, &tmp_gateway)) { g_warning ("%s: IPv4 gateway '%s' invalid!", __func__, item ? item : "<none>"); g_free (item); goto out; } g_free (item); addr = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 3); g_array_append_val (addr, tmp_addr.s_addr); g_array_append_val (addr, prefix); if (tmp_gateway.s_addr) g_array_append_val (addr, tmp_gateway.s_addr); else g_array_append_val (addr, empty_val); g_ptr_array_add (addresses, addr); iter_valid = gtk_tree_model_iter_next (model, &tree_iter); } /* Don't pass empty array to the setting */ if (!addresses->len) { g_ptr_array_free (addresses, TRUE); addresses = NULL; } /* DNS servers */ dns_servers = g_array_new (FALSE, FALSE, sizeof (guint)); text = gtk_entry_get_text (GTK_ENTRY (priv->dns_servers)); if (text && strlen (text)) { items = g_strsplit_set (text, ", ;:", 0); for (iter = items; *iter; iter++) { struct in_addr tmp_addr; char *stripped = g_strstrip (*iter); if (!strlen (stripped)) continue; if (inet_pton (AF_INET, stripped, &tmp_addr)) g_array_append_val (dns_servers, tmp_addr.s_addr); else { g_strfreev (items); goto out; } } g_strfreev (items); } /* Search domains */ text = gtk_entry_get_text (GTK_ENTRY (priv->dns_searches)); if (text && strlen (text)) { items = g_strsplit_set (text, ", ;:", 0); for (iter = items; *iter; iter++) { char *stripped = g_strstrip (*iter); if (strlen (stripped)) search_domains = g_slist_prepend (search_domains, g_strdup (stripped)); } if (items) g_strfreev (items); } search_domains = g_slist_reverse (search_domains); /* DHCP client ID */ if (!strcmp (method, NM_SETTING_IP4_CONFIG_METHOD_AUTO)) { dhcp_client_id = gtk_entry_get_text (priv->dhcp_client_id); if (dhcp_client_id && !strlen (dhcp_client_id)) dhcp_client_id = NULL; } /* Update setting */ g_object_set (priv->setting, NM_SETTING_IP4_CONFIG_METHOD, method, NM_SETTING_IP4_CONFIG_ADDRESSES, addresses, NM_SETTING_IP4_CONFIG_DNS, dns_servers, NM_SETTING_IP4_CONFIG_DNS_SEARCH, search_domains, NM_SETTING_IP4_CONFIG_IGNORE_AUTO_DNS, ignore_auto_dns, NM_SETTING_IP4_CONFIG_DHCP_CLIENT_ID, dhcp_client_id, NULL); valid = TRUE; out: if (addresses) { g_ptr_array_foreach (addresses, (GFunc) free_one_addr, NULL); g_ptr_array_free (addresses, TRUE); } if (dns_servers) g_array_free (dns_servers, TRUE); g_slist_foreach (search_domains, (GFunc) g_free, NULL); g_slist_free (search_domains); return valid; }
static void ip4_private_init (CEPageIP4 *self, NMConnection *connection) { CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); GladeXML *xml; GtkTreeIter iter; NMSettingConnection *s_con; const char *connection_type; char *str_auto = NULL, *str_auto_only = NULL; xml = CE_PAGE (self)->xml; s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); connection_type = nm_setting_connection_get_connection_type (s_con); g_assert (connection_type); priv->connection_type = nm_connection_lookup_setting_type (connection_type); if (priv->connection_type == NM_TYPE_SETTING_VPN) { str_auto = _("Automatic (VPN)"); str_auto_only = _("Automatic (VPN) addresses only"); } else if ( priv->connection_type == NM_TYPE_SETTING_GSM || priv->connection_type == NM_TYPE_SETTING_CDMA) { str_auto = _("Automatic (PPP)"); str_auto_only = _("Automatic (PPP) addresses only"); } else if (priv->connection_type == NM_TYPE_SETTING_PPPOE) { str_auto = _("Automatic (PPPoE)"); str_auto_only = _("Automatic (PPPoE) addresses only"); } else { str_auto = _("Automatic (DHCP)"); str_auto_only = _("Automatic (DHCP) addresses only"); } priv->method = GTK_COMBO_BOX (glade_xml_get_widget (xml, "ip4_method")); priv->method_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_UINT); gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, str_auto, METHOD_COL_NUM, IP4_METHOD_AUTO, -1); gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, str_auto_only, METHOD_COL_NUM, IP4_METHOD_AUTO_ADDRESSES, -1); /* Manual is pointless for Mobile Broadband */ if ( priv->connection_type != NM_TYPE_SETTING_GSM && priv->connection_type != NM_TYPE_SETTING_CDMA && priv->connection_type != NM_TYPE_SETTING_VPN) { gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, _("Manual"), METHOD_COL_NUM, IP4_METHOD_MANUAL, -1); } /* Link-local is pointless for VPNs, Mobile Broadband, and PPPoE */ if ( priv->connection_type != NM_TYPE_SETTING_VPN && priv->connection_type != NM_TYPE_SETTING_PPPOE && priv->connection_type != NM_TYPE_SETTING_GSM && priv->connection_type != NM_TYPE_SETTING_CDMA) { gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, _("Link-Local Only"), METHOD_COL_NUM, IP4_METHOD_LINK_LOCAL, -1); gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, _("Shared to other computers"), METHOD_COL_NUM, IP4_METHOD_SHARED, -1); } gtk_combo_box_set_model (priv->method, GTK_TREE_MODEL (priv->method_store)); priv->addr_label = glade_xml_get_widget (xml, "ip4_addr_label"); priv->addr_add = GTK_BUTTON (glade_xml_get_widget (xml, "ip4_addr_add_button")); priv->addr_delete = GTK_BUTTON (glade_xml_get_widget (xml, "ip4_addr_delete_button")); priv->addr_list = GTK_TREE_VIEW (glade_xml_get_widget (xml, "ip4_addresses")); priv->dns_servers_label = glade_xml_get_widget (xml, "ip4_dns_servers_label"); priv->dns_servers = GTK_ENTRY (glade_xml_get_widget (xml, "ip4_dns_servers_entry")); priv->dns_searches_label = glade_xml_get_widget (xml, "ip4_dns_searches_label"); priv->dns_searches = GTK_ENTRY (glade_xml_get_widget (xml, "ip4_dns_searches_entry")); priv->dhcp_client_id_label = glade_xml_get_widget (xml, "ip4_dhcp_client_id_label"); priv->dhcp_client_id = GTK_ENTRY (glade_xml_get_widget (xml, "ip4_dhcp_client_id_entry")); /* Hide DHCP stuff if it'll never be used for a particular method */ if ( priv->connection_type == NM_TYPE_SETTING_VPN || priv->connection_type == NM_TYPE_SETTING_GSM || priv->connection_type == NM_TYPE_SETTING_CDMA || priv->connection_type == NM_TYPE_SETTING_PPPOE) { gtk_widget_hide (GTK_WIDGET (priv->dhcp_client_id_label)); gtk_widget_hide (GTK_WIDGET (priv->dhcp_client_id)); } priv->routes_button = GTK_BUTTON (glade_xml_get_widget (xml, "ip4_routes_button")); }
static void populate_ui (CEPageIP4 *self) { CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); NMSettingIPConfig *setting = priv->setting; GtkListStore *store; GtkTreeIter model_iter; int method = IP4_METHOD_AUTO; GString *string = NULL; SetMethodInfo info; const char *str_method; int i; /* Method */ gtk_combo_box_set_active (priv->method, 0); str_method = nm_setting_ip_config_get_method (setting); if (str_method) { if (!strcmp (str_method, NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL)) method = IP4_METHOD_LINK_LOCAL; else if (!strcmp (str_method, NM_SETTING_IP4_CONFIG_METHOD_MANUAL)) method = IP4_METHOD_MANUAL; else if (!strcmp (str_method, NM_SETTING_IP4_CONFIG_METHOD_SHARED)) method = IP4_METHOD_SHARED; else if (!strcmp (str_method, NM_SETTING_IP4_CONFIG_METHOD_DISABLED)) method = IP4_METHOD_DISABLED; } if (method == IP4_METHOD_AUTO && nm_setting_ip_config_get_ignore_auto_dns (setting)) method = IP4_METHOD_AUTO_ADDRESSES; info.method = method; info.combo = priv->method; gtk_tree_model_foreach (GTK_TREE_MODEL (priv->method_store), set_method, &info); /* Addresses */ store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); for (i = 0; i < nm_setting_ip_config_get_num_addresses (setting); i++) { NMIPAddress *addr = nm_setting_ip_config_get_address (setting, i); char buf[32]; if (!addr) { g_warning ("%s: empty IP4 Address structure!", __func__); continue; } snprintf (buf, sizeof (buf), "%u", nm_ip_address_get_prefix (addr)); gtk_list_store_append (store, &model_iter); gtk_list_store_set (store, &model_iter, COL_ADDRESS, nm_ip_address_get_address (addr), COL_PREFIX, buf, /* FIXME */ COL_GATEWAY, i == 0 ? nm_setting_ip_config_get_gateway (setting) : NULL, -1); } gtk_tree_view_set_model (priv->addr_list, GTK_TREE_MODEL (store)); g_signal_connect_swapped (store, "row-inserted", G_CALLBACK (ce_page_changed), self); g_signal_connect_swapped (store, "row-deleted", G_CALLBACK (ce_page_changed), self); g_object_unref (store); /* DNS servers */ string = g_string_new (""); for (i = 0; i < nm_setting_ip_config_get_num_dns (setting); i++) { const char *dns; dns = nm_setting_ip_config_get_dns (setting, i); if (!dns) continue; if (string->len) g_string_append (string, ", "); g_string_append (string, dns); } gtk_entry_set_text (priv->dns_servers, string->str); g_string_free (string, TRUE); /* DNS searches */ string = g_string_new (""); for (i = 0; i < nm_setting_ip_config_get_num_dns_searches (setting); i++) { if (string->len) g_string_append (string, ", "); g_string_append (string, nm_setting_ip_config_get_dns_search (setting, i)); } gtk_entry_set_text (priv->dns_searches, string->str); g_string_free (string, TRUE); if ((method == IP4_METHOD_AUTO) || (method == IP4_METHOD_AUTO_ADDRESSES)) { if (nm_setting_ip4_config_get_dhcp_client_id (NM_SETTING_IP4_CONFIG (setting))) { gtk_entry_set_text (priv->dhcp_client_id, nm_setting_ip4_config_get_dhcp_client_id (NM_SETTING_IP4_CONFIG (setting))); } } /* IPv4 required */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->ip4_required), !nm_setting_ip_config_get_may_fail (setting)); }
static void method_changed (GtkComboBox *combo, gpointer user_data) { CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (user_data); guint32 method = IP4_METHOD_AUTO; gboolean addr_enabled = FALSE; gboolean dns_enabled = FALSE; gboolean dhcp_enabled = FALSE; gboolean routes_enabled = FALSE; gboolean ip4_required_enabled = TRUE; gboolean method_auto = FALSE; GtkTreeIter iter; if (gtk_combo_box_get_active_iter (priv->method, &iter)) { gtk_tree_model_get (GTK_TREE_MODEL (priv->method_store), &iter, METHOD_COL_NUM, &method, -1); } switch (method) { case IP4_METHOD_AUTO: addr_enabled = FALSE; dhcp_enabled = routes_enabled = TRUE; dns_enabled = TRUE; method_auto = TRUE; break; case IP4_METHOD_AUTO_ADDRESSES: addr_enabled = FALSE; dns_enabled = dhcp_enabled = routes_enabled = TRUE; break; case IP4_METHOD_MANUAL: addr_enabled = dns_enabled = routes_enabled = TRUE; break; case IP4_METHOD_DISABLED: addr_enabled = dns_enabled = dhcp_enabled = routes_enabled = ip4_required_enabled = FALSE; default: break; } /* Disable DHCP stuff for VPNs (though in the future we should support * DHCP over tap interfaces for OpenVPN and vpnc). */ if ( priv->connection_type == NM_TYPE_SETTING_VPN || priv->connection_type == NM_TYPE_SETTING_GSM || priv->connection_type == NM_TYPE_SETTING_CDMA || priv->connection_type == NM_TYPE_SETTING_PPPOE) dhcp_enabled = FALSE; gtk_widget_set_sensitive (priv->addr_label, addr_enabled); gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_add), addr_enabled); gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_delete), addr_enabled); gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_list), addr_enabled); if (!addr_enabled) { GtkListStore *store; store = GTK_LIST_STORE (gtk_tree_view_get_model (priv->addr_list)); gtk_list_store_clear (store); } gtk_widget_set_sensitive (priv->dns_servers_label, dns_enabled); if (method_auto) gtk_label_set_text_with_mnemonic (GTK_LABEL (priv->dns_servers_label), _("Additional DNS ser_vers:")); else gtk_label_set_text_with_mnemonic (GTK_LABEL (priv->dns_servers_label), _("DNS ser_vers:")); gtk_widget_set_sensitive (GTK_WIDGET (priv->dns_servers), dns_enabled); if (!dns_enabled) gtk_entry_set_text (priv->dns_servers, ""); gtk_widget_set_sensitive (priv->dns_searches_label, dns_enabled); if (method_auto) gtk_label_set_text_with_mnemonic (GTK_LABEL (priv->dns_searches_label), _("Additional s_earch domains:")); else gtk_label_set_text_with_mnemonic (GTK_LABEL (priv->dns_searches_label), _("S_earch domains:")); gtk_widget_set_sensitive (GTK_WIDGET (priv->dns_searches), dns_enabled); if (!dns_enabled) gtk_entry_set_text (priv->dns_searches, ""); gtk_widget_set_sensitive (priv->dhcp_client_id_label, dhcp_enabled); gtk_widget_set_sensitive (GTK_WIDGET (priv->dhcp_client_id), dhcp_enabled); if (!dhcp_enabled) gtk_entry_set_text (priv->dhcp_client_id, ""); gtk_widget_set_sensitive (GTK_WIDGET (priv->ip4_required), ip4_required_enabled); gtk_widget_set_sensitive (GTK_WIDGET (priv->routes_button), routes_enabled); ce_page_changed (CE_PAGE (user_data)); }
static void finish_setup (CEPageIP4 *self, gpointer unused, GError *error, gpointer user_data) { CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); GtkTreeSelection *selection; gint offset; GtkTreeViewColumn *column; GtkCellRenderer *renderer; if (error) return; populate_ui (self); /* IP Address column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), self); g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_ADDRESS)); g_signal_connect (renderer, "editing-started", G_CALLBACK (cell_editing_started), self); g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), self); priv->addr_cells[COL_ADDRESS] = GTK_CELL_RENDERER (renderer); offset = gtk_tree_view_insert_column_with_attributes (priv->addr_list, -1, _("Address"), renderer, "text", COL_ADDRESS, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (priv->addr_list), offset - 1); gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_view_column_set_cell_data_func (column, renderer, cell_error_data_func, GUINT_TO_POINTER (COL_ADDRESS), NULL); /* Prefix/netmask column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), self); g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_PREFIX)); g_signal_connect (renderer, "editing-started", G_CALLBACK (cell_editing_started), self); g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), self); priv->addr_cells[COL_PREFIX] = GTK_CELL_RENDERER (renderer); offset = gtk_tree_view_insert_column_with_attributes (priv->addr_list, -1, _("Netmask"), renderer, "text", COL_PREFIX, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (priv->addr_list), offset - 1); gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_view_column_set_cell_data_func (column, renderer, cell_error_data_func, GUINT_TO_POINTER (COL_PREFIX), NULL); /* Gateway column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), self); g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_GATEWAY)); g_signal_connect (renderer, "editing-started", G_CALLBACK (cell_editing_started), self); g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), self); priv->addr_cells[COL_GATEWAY] = GTK_CELL_RENDERER (renderer); offset = gtk_tree_view_insert_column_with_attributes (priv->addr_list, -1, _("Gateway"), renderer, "text", COL_GATEWAY, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (priv->addr_list), offset - 1); gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_view_column_set_cell_data_func (column, renderer, cell_error_data_func, GUINT_TO_POINTER (COL_GATEWAY), NULL); g_signal_connect (priv->addr_list, "button-press-event", G_CALLBACK (tree_view_button_pressed_cb), self); gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_add), TRUE); gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_delete), FALSE); g_signal_connect (priv->addr_add, "clicked", G_CALLBACK (addr_add_clicked), self); g_signal_connect (priv->addr_delete, "clicked", G_CALLBACK (addr_delete_clicked), priv->addr_list); selection = gtk_tree_view_get_selection (priv->addr_list); g_signal_connect (selection, "changed", G_CALLBACK (list_selection_changed), priv->addr_delete); g_signal_connect_swapped (priv->dns_servers, "changed", G_CALLBACK (ce_page_changed), self); g_signal_connect (priv->dns_servers, "insert-text", G_CALLBACK (dns_servers_filter_cb), self); g_signal_connect_swapped (priv->dns_searches, "changed", G_CALLBACK (ce_page_changed), self); method_changed (priv->method, self); g_signal_connect (priv->method, "changed", G_CALLBACK (method_changed), self); g_signal_connect_swapped (priv->dhcp_client_id, "changed", G_CALLBACK (ce_page_changed), self); g_signal_connect_swapped (priv->ip4_required, "toggled", G_CALLBACK (ce_page_changed), self); g_signal_connect (priv->routes_button, "clicked", G_CALLBACK (routes_button_clicked_cb), self); }
static void ip4_private_init (CEPageIP4 *self, NMConnection *connection) { CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); GtkBuilder *builder; GtkTreeIter iter; NMSettingConnection *s_con; const char *connection_type; char *str_auto = NULL, *str_auto_only = NULL; GList *cells; builder = CE_PAGE (self)->builder; s_con = nm_connection_get_setting_connection (connection); g_assert (s_con); connection_type = nm_setting_connection_get_connection_type (s_con); g_assert (connection_type); priv->connection_type = nm_setting_lookup_type (connection_type); if (priv->connection_type == NM_TYPE_SETTING_VPN) { str_auto = _("Automatic (VPN)"); str_auto_only = _("Automatic (VPN) addresses only"); } else if ( priv->connection_type == NM_TYPE_SETTING_GSM || priv->connection_type == NM_TYPE_SETTING_CDMA) { str_auto = _("Automatic"); str_auto_only = _("Automatic, addresses only"); } else if (priv->connection_type == NM_TYPE_SETTING_PPPOE) { str_auto = _("Automatic (PPPoE)"); str_auto_only = _("Automatic (PPPoE) addresses only"); } else { str_auto = _("Automatic (DHCP)"); str_auto_only = _("Automatic (DHCP) addresses only"); } priv->method = GTK_COMBO_BOX (gtk_builder_get_object (builder, "ip4_method")); cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (priv->method)); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (priv->method), cells->data, "sensitive", METHOD_COL_ENABLED); priv->method_store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_BOOLEAN); gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, str_auto, METHOD_COL_NUM, IP4_METHOD_AUTO, METHOD_COL_ENABLED, TRUE, -1); gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, str_auto_only, METHOD_COL_NUM, IP4_METHOD_AUTO_ADDRESSES, METHOD_COL_ENABLED, TRUE, -1); /* Manual is pointless for Mobile Broadband */ if ( priv->connection_type != NM_TYPE_SETTING_GSM && priv->connection_type != NM_TYPE_SETTING_CDMA && priv->connection_type != NM_TYPE_SETTING_VPN) { gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, _("Manual"), METHOD_COL_NUM, IP4_METHOD_MANUAL, METHOD_COL_ENABLED, TRUE, -1); } /* Link-local is pointless for VPNs, Mobile Broadband, and PPPoE */ if ( priv->connection_type != NM_TYPE_SETTING_VPN && priv->connection_type != NM_TYPE_SETTING_PPPOE && priv->connection_type != NM_TYPE_SETTING_GSM && priv->connection_type != NM_TYPE_SETTING_CDMA) { gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, _("Link-Local Only"), METHOD_COL_NUM, IP4_METHOD_LINK_LOCAL, METHOD_COL_ENABLED, TRUE, -1); gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, _("Shared to other computers"), METHOD_COL_NUM, IP4_METHOD_SHARED, METHOD_COL_ENABLED, TRUE, -1); } /* Disabled is only supported for types that also support IPv6 */ if (connection_supports_ip6 (connection)) { gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, _("Disabled"), METHOD_COL_NUM, IP4_METHOD_DISABLED, METHOD_COL_ENABLED, TRUE, -1); } gtk_combo_box_set_model (priv->method, GTK_TREE_MODEL (priv->method_store)); priv->addr_label = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_addr_label")); priv->addr_add = GTK_BUTTON (gtk_builder_get_object (builder, "ip4_addr_add_button")); priv->addr_delete = GTK_BUTTON (gtk_builder_get_object (builder, "ip4_addr_delete_button")); priv->addr_list = GTK_TREE_VIEW (gtk_builder_get_object (builder, "ip4_addresses")); priv->dns_servers_label = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_dns_servers_label")); priv->dns_servers = GTK_ENTRY (gtk_builder_get_object (builder, "ip4_dns_servers_entry")); priv->dns_searches_label = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_dns_searches_label")); priv->dns_searches = GTK_ENTRY (gtk_builder_get_object (builder, "ip4_dns_searches_entry")); priv->dhcp_client_id_label = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_dhcp_client_id_label")); priv->dhcp_client_id = GTK_ENTRY (gtk_builder_get_object (builder, "ip4_dhcp_client_id_entry")); /* Hide DHCP stuff if it'll never be used for a particular method */ if ( priv->connection_type == NM_TYPE_SETTING_VPN || priv->connection_type == NM_TYPE_SETTING_GSM || priv->connection_type == NM_TYPE_SETTING_CDMA || priv->connection_type == NM_TYPE_SETTING_PPPOE) { gtk_widget_hide (GTK_WIDGET (priv->dhcp_client_id_label)); gtk_widget_hide (GTK_WIDGET (priv->dhcp_client_id)); } priv->ip4_required = GTK_CHECK_BUTTON (gtk_builder_get_object (builder, "ip4_required_checkbutton")); /* Hide IP4-require button if it'll never be used for a particular method */ if ( priv->connection_type == NM_TYPE_SETTING_VPN || priv->connection_type == NM_TYPE_SETTING_GSM || priv->connection_type == NM_TYPE_SETTING_CDMA || priv->connection_type == NM_TYPE_SETTING_PPPOE) gtk_widget_hide (GTK_WIDGET (priv->ip4_required)); priv->routes_button = GTK_BUTTON (gtk_builder_get_object (builder, "ip4_routes_button")); }
static gboolean ui_to_setting (CEPageIP4 *self, GError **error) { CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); GtkTreeModel *model; GtkTreeIter tree_iter; int int_method = IP4_METHOD_AUTO; const char *method; GPtrArray *tmp_array = NULL; char **dns_servers = NULL; char **search_domains = NULL; GPtrArray *addresses = NULL; char *gateway = NULL; gboolean valid = FALSE, iter_valid; const char *text; gboolean ignore_auto_dns = FALSE; const char *dhcp_client_id = NULL; char **items = NULL, **iter; gboolean may_fail = FALSE; /* Method */ if (gtk_combo_box_get_active_iter (priv->method, &tree_iter)) { gtk_tree_model_get (GTK_TREE_MODEL (priv->method_store), &tree_iter, METHOD_COL_NUM, &int_method, -1); } switch (int_method) { case IP4_METHOD_LINK_LOCAL: method = NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL; break; case IP4_METHOD_MANUAL: method = NM_SETTING_IP4_CONFIG_METHOD_MANUAL; break; case IP4_METHOD_SHARED: method = NM_SETTING_IP4_CONFIG_METHOD_SHARED; break; case IP4_METHOD_DISABLED: method = NM_SETTING_IP4_CONFIG_METHOD_DISABLED; break; case IP4_METHOD_AUTO_ADDRESSES: ignore_auto_dns = TRUE; /* fall through */ default: method = NM_SETTING_IP4_CONFIG_METHOD_AUTO; break; } /* IP addresses */ model = gtk_tree_view_get_model (priv->addr_list); iter_valid = gtk_tree_model_get_iter_first (model, &tree_iter); addresses = g_ptr_array_sized_new (1); while (iter_valid) { char *addr = NULL, *netmask = NULL, *addr_gw = NULL; NMIPAddress *nm_addr; guint32 prefix; gtk_tree_model_get (model, &tree_iter, COL_ADDRESS, &addr, COL_PREFIX, &netmask, COL_GATEWAY, &addr_gw, -1); if ( !addr || !nm_utils_ipaddr_valid (AF_INET, addr) || is_address_unspecified (addr)) { g_set_error (error, NMA_ERROR, NMA_ERROR_GENERIC, _("IPv4 address \"%s\" invalid"), addr ? addr : ""); g_free (addr); g_free (netmask); g_free (addr_gw); goto out; } if (!parse_netmask (netmask, &prefix)) { g_set_error (error, NMA_ERROR, NMA_ERROR_GENERIC, _("IPv4 address netmask \"%s\" invalid"), netmask ? netmask : ""); g_free (addr); g_free (netmask); g_free (addr_gw); goto out; } /* Gateway is optional... */ if (addr_gw && *addr_gw && !nm_utils_ipaddr_valid (AF_INET, addr_gw)) { g_set_error (error, NMA_ERROR, NMA_ERROR_GENERIC, _("IPv4 gateway \"%s\" invalid"), addr_gw); g_free (addr); g_free (netmask); g_free (addr_gw); goto out; } nm_addr = nm_ip_address_new (AF_INET, addr, prefix, NULL); g_ptr_array_add (addresses, nm_addr); if (addresses->len == 1 && addr_gw && *addr_gw) { gateway = addr_gw; addr_gw = NULL; } g_free (addr); g_free (netmask); g_free (addr_gw); iter_valid = gtk_tree_model_iter_next (model, &tree_iter); } /* Don't pass empty array to the setting */ if (!addresses->len) { g_ptr_array_free (addresses, TRUE); addresses = NULL; } /* DNS servers */ tmp_array = g_ptr_array_new (); text = gtk_entry_get_text (GTK_ENTRY (priv->dns_servers)); if (text && strlen (text)) { items = g_strsplit_set (text, ", ;:", 0); for (iter = items; *iter; iter++) { struct in_addr tmp_addr; char *stripped = g_strstrip (*iter); if (!*stripped) continue; if (inet_pton (AF_INET, stripped, &tmp_addr)) g_ptr_array_add (tmp_array, g_strdup (stripped)); else { g_set_error (error, NMA_ERROR, NMA_ERROR_GENERIC, _("IPv4 DNS server \"%s\" invalid"), stripped); g_strfreev (items); g_ptr_array_free (tmp_array, TRUE); goto out; } } g_strfreev (items); } g_ptr_array_add (tmp_array, NULL); dns_servers = (char **) g_ptr_array_free (tmp_array, FALSE); /* Search domains */ tmp_array = g_ptr_array_new (); text = gtk_entry_get_text (GTK_ENTRY (priv->dns_searches)); if (text && strlen (text)) { items = g_strsplit_set (text, ", ;:", 0); for (iter = items; *iter; iter++) { char *stripped = g_strstrip (*iter); if (strlen (stripped)) g_ptr_array_add (tmp_array, g_strdup (stripped)); } g_strfreev (items); } g_ptr_array_add (tmp_array, NULL); search_domains = (char **) g_ptr_array_free (tmp_array, FALSE); /* DHCP client ID */ if (!strcmp (method, NM_SETTING_IP4_CONFIG_METHOD_AUTO)) { dhcp_client_id = gtk_entry_get_text (priv->dhcp_client_id); if (dhcp_client_id && !strlen (dhcp_client_id)) dhcp_client_id = NULL; } may_fail = !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->ip4_required)); /* Update setting */ g_object_set (priv->setting, NM_SETTING_IP_CONFIG_METHOD, method, NM_SETTING_IP_CONFIG_ADDRESSES, addresses, NM_SETTING_IP_CONFIG_GATEWAY, gateway, NM_SETTING_IP_CONFIG_DNS, dns_servers, NM_SETTING_IP_CONFIG_DNS_SEARCH, search_domains, NM_SETTING_IP_CONFIG_IGNORE_AUTO_DNS, ignore_auto_dns, NM_SETTING_IP4_CONFIG_DHCP_CLIENT_ID, dhcp_client_id, NM_SETTING_IP_CONFIG_MAY_FAIL, may_fail, NULL); valid = TRUE; out: if (addresses) { g_ptr_array_foreach (addresses, (GFunc) free_one_addr, NULL); g_ptr_array_free (addresses, TRUE); } g_free (gateway); g_strfreev (dns_servers); g_strfreev (search_domains); return valid; }