static void fill_connection (WirelessSecurity *parent, NMConnection *connection) { NMSettingWirelessSecurity *s_wireless_sec; ws_802_1x_fill_connection (parent, "wpa_eap_auth_combo", connection); s_wireless_sec = NM_SETTING_WIRELESS_SECURITY (nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS_SECURITY)); g_assert (s_wireless_sec); g_object_set (s_wireless_sec, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "wpa-eap", NULL); }
void wireless_security_clear_ciphers (NMConnection *connection) { NMSettingWirelessSecurity *s_wireless_sec; g_return_if_fail (connection != NULL); s_wireless_sec = NM_SETTING_WIRELESS_SECURITY (nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS_SECURITY)); g_assert (s_wireless_sec); nm_setting_wireless_security_clear_protos (s_wireless_sec); nm_setting_wireless_security_clear_pairwise (s_wireless_sec); nm_setting_wireless_security_clear_groups (s_wireless_sec); }
static void connection_secrets_response_cb (NMAWirelessDialog *dialog, gint response, gpointer user_data) { SecretsRequestInfo *info = user_data; NMConnection *connection; GHashTable *settings = NULL; NMSetting *s_wireless_sec; const char *key_mgmt; GError *error = NULL; gtk_widget_hide (GTK_WIDGET (dialog)); connection = nma_wireless_dialog_get_connection (dialog); if (response != GTK_RESPONSE_OK) { error = g_error_new (NM_SETTINGS_INTERFACE_ERROR, NM_SETTINGS_INTERFACE_ERROR_SECRETS_REQUEST_CANCELED, "%s.%d (%s): canceled", __FILE__, __LINE__, __func__); goto done; } /* Returned secrets are a{sa{sv}}; this is the outer a{s...} hash that * will contain all the individual settings hashes. */ settings = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_hash_table_destroy); /* If the user chose an 802.1x-based auth method, return 802.1x secrets, * not wireless secrets. Can happen with Dynamic WEP, because NM doesn't * know the capabilities of the AP (since Dynamic WEP APs don't broadcast * beacons), and therefore defaults to requesting WEP secrets from the * wireless-security setting, not the 802.1x setting. */ s_wireless_sec = nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS_SECURITY); key_mgmt = nm_setting_wireless_security_get_key_mgmt (NM_SETTING_WIRELESS_SECURITY (s_wireless_sec)); if (!strcmp (key_mgmt, "ieee8021x") || !strcmp (key_mgmt, "wpa-eap")) { const char *auth_alg; /* LEAP secrets aren't in the 802.1x setting */ auth_alg = nm_setting_wireless_security_get_auth_alg (NM_SETTING_WIRELESS_SECURITY (s_wireless_sec)); if (!auth_alg || strcmp (auth_alg, "leap")) { NMSetting *s_8021x; s_8021x = nm_connection_get_setting (connection, NM_TYPE_SETTING_802_1X); if (!s_8021x) { error = g_error_new (NM_SETTINGS_INTERFACE_ERROR, NM_SETTINGS_INTERFACE_ERROR_INVALID_CONNECTION, "%s.%d (%s): requested setting '802-1x' didn't" " exist in the connection.", __FILE__, __LINE__, __func__); goto done; } /* Add the 802.1x setting */ g_hash_table_insert (settings, g_strdup (nm_setting_get_name (s_8021x)), nm_setting_to_hash (s_8021x)); } } /* Add the 802-11-wireless-security setting no matter what */ g_hash_table_insert (settings, g_strdup (nm_setting_get_name (s_wireless_sec)), nm_setting_to_hash (s_wireless_sec)); info->callback ((NMSettingsConnectionInterface *) connection, settings, NULL, info->callback_data); /* Save the connection back to GConf _after_ hashing it, because * saving to GConf might trigger the GConf change notifiers, resulting * in the connection being read back in from GConf which clears secrets. */ if (NM_IS_GCONF_CONNECTION (connection)) { nm_settings_connection_interface_update (NM_SETTINGS_CONNECTION_INTERFACE (connection), update_cb, NULL); } done: if (settings) g_hash_table_destroy (settings); if (error) { g_warning ("%s", error->message); info->callback (NM_SETTINGS_CONNECTION_INTERFACE (connection), NULL, error, info->callback_data); g_error_free (error); } g_free (info); if (connection) nm_connection_clear_secrets (connection); gtk_widget_destroy (GTK_WIDGET (dialog)); }
static void update_wireless_security_setting_from_if_block(NMConnection *connection, if_block *block) { gint wpa_l= strlen("wpa-"); gint wireless_l= strlen("wireless-"); if_data *curr = block->info; const gchar* value = ifparser_getkey (block, "inet"); struct _Mapping mapping[] = { {"psk", "psk"}, {"identity", "leap-username"}, {"password", "leap-password"}, {"key", "wep-key0"}, {"key-mgmt", "key-mgmt"}, {"group", "group"}, {"pairwise", "pairwise"}, {"proto", "proto"}, {"pin", "pin"}, {"wep-key0", "wep-key0"}, {"wep-key1", "wep-key1"}, {"wep-key2", "wep-key2"}, {"wep-key3", "wep-key3"}, {"wep-tx-keyidx", "wep-tx-keyidx"}, { NULL, NULL} }; struct _Mapping dupe_mapping[] = { {"psk", normalize_psk}, {"identity", normalize_dupe}, {"password", normalize_dupe}, {"key", normalize_dupe_wireless_key}, {"key-mgmt", normalize_tolower}, {"group", normalize_tolower}, {"pairwise", normalize_tolower}, {"proto", normalize_tolower}, {"pin", normalize_dupe}, {"wep-key0", normalize_dupe_wireless_key}, {"wep-key1", normalize_dupe_wireless_key}, {"wep-key2", normalize_dupe_wireless_key}, {"wep-key3", normalize_dupe_wireless_key}, {"wep-tx-keyidx", normalize_dupe}, { NULL, NULL} }; struct _Mapping type_mapping[] = { {"group", string_to_glist_of_strings}, {"pairwise", string_to_glist_of_strings}, {"proto", string_to_glist_of_strings}, {"wep-tx-keyidx", string_to_gpointerint}, { NULL, NULL} }; struct _Mapping free_type_mapping[] = { {"group", slist_free_all}, {"pairwise", slist_free_all}, {"proto", slist_free_all}, { NULL, NULL} }; NMSettingWirelessSecurity *wireless_security_setting; NMSettingWireless *s_wireless; gboolean security = FALSE; if(value && !strcmp("ppp", value)) { return; } s_wireless = nm_connection_get_setting_wireless(connection); g_return_if_fail(s_wireless); nm_log_info (LOGD_SETTINGS, "update wireless security settings (%s).", block->name); wireless_security_setting = NM_SETTING_WIRELESS_SECURITY(nm_setting_wireless_security_new()); while(curr) { if(strlen(curr->key) > wireless_l && !strncmp("wireless-", curr->key, wireless_l)) { gchar *property_value = NULL; gpointer typed_property_value = NULL; const gchar* newkey = map_by_mapping(mapping, curr->key+wireless_l); IfupdownStrDupeFunc dupe_func = map_by_mapping (dupe_mapping, curr->key+wireless_l); IfupdownStrToTypeFunc type_map_func = map_by_mapping (type_mapping, curr->key+wireless_l); GFreeFunc free_func = map_by_mapping (free_type_mapping, curr->key+wireless_l); if(!newkey || !dupe_func) goto next; property_value = (*dupe_func) (curr->data, connection); nm_log_info (LOGD_SETTINGS, "setting wireless security key: %s=%s", newkey, property_value); if (type_map_func) { errno = 0; typed_property_value = (*type_map_func) (property_value); if(errno) goto wireless_next; } g_object_set(wireless_security_setting, newkey, typed_property_value ? typed_property_value : property_value, NULL); security = TRUE; wireless_next: g_free(property_value); if (typed_property_value && free_func) (*free_func) (typed_property_value); } else if(strlen(curr->key) > wpa_l && !strncmp("wpa-", curr->key, wpa_l)) { gchar *property_value = NULL; gpointer typed_property_value = NULL; const gchar* newkey = map_by_mapping(mapping, curr->key+wpa_l); IfupdownStrDupeFunc dupe_func = map_by_mapping (dupe_mapping, curr->key+wpa_l); IfupdownStrToTypeFunc type_map_func = map_by_mapping (type_mapping, curr->key+wpa_l); GFreeFunc free_func = map_by_mapping (free_type_mapping, curr->key+wpa_l); if(!newkey || !dupe_func) goto next; property_value = (*dupe_func) (curr->data, connection); nm_log_info (LOGD_SETTINGS, "setting wpa security key: %s=%s", newkey, #ifdef DEBUG_SECRETS property_value #else /* DEBUG_SECRETS */ !strcmp("key", newkey) || !strcmp("leap-password", newkey) || !strcmp("pin", newkey) || !strcmp("psk", newkey) || !strcmp("wep-key0", newkey) || !strcmp("wep-key1", newkey) || !strcmp("wep-key2", newkey) || !strcmp("wep-key3", newkey) || NULL ? "<omitted>" : property_value #endif /* DEBUG_SECRETS */ ); if (type_map_func) { errno = 0; typed_property_value = (*type_map_func) (property_value); if(errno) goto wpa_next; } g_object_set(wireless_security_setting, newkey, typed_property_value ? typed_property_value : property_value, NULL); security = TRUE; wpa_next: g_free(property_value); if (free_func && typed_property_value) (*free_func) (typed_property_value); } next: curr = curr->next; } if (security) nm_connection_add_setting (connection, NM_SETTING (wireless_security_setting)); }
CEPage * ce_page_wireless_security_new (NMConnection *connection, GtkWindow *parent_window, GError **error) { CEPageWirelessSecurity *self; CEPage *parent; NMSettingWireless *s_wireless; NMSettingWirelessSecurity *s_wsec = NULL; const char *setting_name = NULL; NMUtilsSecurityType default_type = NMU_SEC_NONE; const char *security; self = CE_PAGE_WIRELESS_SECURITY (g_object_new (CE_TYPE_PAGE_WIRELESS_SECURITY, CE_PAGE_CONNECTION, connection, CE_PAGE_PARENT_WINDOW, parent_window, NULL)); parent = CE_PAGE (self); s_wireless = NM_SETTING_WIRELESS (nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS)); if (!s_wireless) { g_set_error (error, 0, 0, "%s", _("Could not load WiFi security user interface; missing WiFi setting.")); g_object_unref (self); return NULL; } parent->xml = glade_xml_new (GLADEDIR "/ce-page-wireless-security.glade", "WirelessSecurityPage", NULL); if (!parent->xml) { g_set_error (error, 0, 0, "%s", _("Could not load WiFi security user interface.")); g_object_unref (self); return NULL; } parent->page = glade_xml_get_widget (parent->xml, "WirelessSecurityPage"); if (!parent->page) { g_set_error (error, 0, 0, "%s", _("Could not load WiFi security user interface.")); g_object_unref (self); return NULL; } g_object_ref_sink (parent->page); parent->title = g_strdup (_("Wireless Security")); self->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); s_wsec = NM_SETTING_WIRELESS_SECURITY (nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS_SECURITY)); security = nm_setting_wireless_get_security (s_wireless); if (!security || strcmp (security, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME)) s_wsec = NULL; if (s_wsec) default_type = get_default_type_for_security (s_wsec); /* Get secrets if the connection is not 802.1x enabled */ if ( default_type == NMU_SEC_STATIC_WEP || default_type == NMU_SEC_LEAP || default_type == NMU_SEC_WPA_PSK || default_type == NMU_SEC_WPA2_PSK) { setting_name = NM_SETTING_WIRELESS_SECURITY_SETTING_NAME; } /* Or if it is 802.1x enabled */ if ( default_type == NMU_SEC_DYNAMIC_WEP || default_type == NMU_SEC_WPA_ENTERPRISE || default_type == NMU_SEC_WPA2_ENTERPRISE) { setting_name = NM_SETTING_802_1X_SETTING_NAME; } g_signal_connect (self, "initialized", G_CALLBACK (finish_setup), NULL); if (!ce_page_initialize (parent, setting_name, error)) { g_object_unref (self); return NULL; } return CE_PAGE (self); }
static void finish_setup (CEPageWirelessSecurity *self, gpointer unused, GError *error, gpointer user_data) { CEPage *parent = CE_PAGE (self); NMSettingWireless *s_wireless; NMSettingWirelessSecurity *s_wireless_sec; NMConnection *connection = parent->connection; gboolean is_adhoc = FALSE; GtkListStore *sec_model; GtkTreeIter iter; const char *mode; const char *security; guint32 dev_caps = 0; NMUtilsSecurityType default_type = NMU_SEC_NONE; int active = -1; int item = 0; const char *glade_file = GLADEDIR "/applet.glade"; GtkComboBox *combo; if (error) return; s_wireless = NM_SETTING_WIRELESS (nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS)); g_assert (s_wireless); combo = GTK_COMBO_BOX (glade_xml_get_widget (parent->xml, "wireless_security_combo")); dev_caps = NM_WIFI_DEVICE_CAP_CIPHER_WEP40 | NM_WIFI_DEVICE_CAP_CIPHER_WEP104 | NM_WIFI_DEVICE_CAP_CIPHER_TKIP | NM_WIFI_DEVICE_CAP_CIPHER_CCMP | NM_WIFI_DEVICE_CAP_WPA | NM_WIFI_DEVICE_CAP_RSN; mode = nm_setting_wireless_get_mode (s_wireless); if (mode && !strcmp (mode, "adhoc")) is_adhoc = TRUE; s_wireless_sec = NM_SETTING_WIRELESS_SECURITY (nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS_SECURITY)); security = nm_setting_wireless_get_security (s_wireless); if (!security || strcmp (security, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME)) s_wireless_sec = NULL; if (s_wireless_sec) default_type = get_default_type_for_security (s_wireless_sec); sec_model = gtk_list_store_new (2, G_TYPE_STRING, wireless_security_get_g_type ()); if (nm_utils_security_valid (NMU_SEC_NONE, dev_caps, FALSE, is_adhoc, 0, 0, 0)) { gtk_list_store_append (sec_model, &iter); gtk_list_store_set (sec_model, &iter, S_NAME_COLUMN, _("None"), -1); if (default_type == NMU_SEC_NONE) active = item; item++; } if (nm_utils_security_valid (NMU_SEC_STATIC_WEP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) { WirelessSecurityWEPKey *ws_wep; NMWepKeyType wep_type = NM_WEP_KEY_TYPE_KEY; if (default_type == NMU_SEC_STATIC_WEP) { NMSettingWirelessSecurity *s_wsec; s_wsec = (NMSettingWirelessSecurity *) nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS_SECURITY); if (s_wsec) wep_type = nm_setting_wireless_security_get_wep_key_type (s_wsec); if (wep_type == NM_WEP_KEY_TYPE_UNKNOWN) wep_type = NM_WEP_KEY_TYPE_KEY; } ws_wep = ws_wep_key_new (glade_file, connection, NM_WEP_KEY_TYPE_KEY, FALSE, FALSE); if (ws_wep) { add_security_item (self, WIRELESS_SECURITY (ws_wep), sec_model, &iter, _("WEP 40/128-bit Key")); if ((active < 0) && (default_type == NMU_SEC_STATIC_WEP) && (wep_type == NM_WEP_KEY_TYPE_KEY)) active = item; item++; } ws_wep = ws_wep_key_new (glade_file, connection, NM_WEP_KEY_TYPE_PASSPHRASE, FALSE, FALSE); if (ws_wep) { add_security_item (self, WIRELESS_SECURITY (ws_wep), sec_model, &iter, _("WEP 128-bit Passphrase")); if ((active < 0) && (default_type == NMU_SEC_STATIC_WEP) && (wep_type == NM_WEP_KEY_TYPE_PASSPHRASE)) active = item; item++; } } if (nm_utils_security_valid (NMU_SEC_LEAP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) { WirelessSecurityLEAP *ws_leap; ws_leap = ws_leap_new (glade_file, connection); if (ws_leap) { add_security_item (self, WIRELESS_SECURITY (ws_leap), sec_model, &iter, _("LEAP")); if ((active < 0) && (default_type == NMU_SEC_LEAP)) active = item; item++; } } if (nm_utils_security_valid (NMU_SEC_DYNAMIC_WEP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) { WirelessSecurityDynamicWEP *ws_dynamic_wep; ws_dynamic_wep = ws_dynamic_wep_new (glade_file, connection); if (ws_dynamic_wep) { add_security_item (self, WIRELESS_SECURITY (ws_dynamic_wep), sec_model, &iter, _("Dynamic WEP (802.1x)")); if ((active < 0) && (default_type == NMU_SEC_DYNAMIC_WEP)) active = item; item++; } } if ( nm_utils_security_valid (NMU_SEC_WPA_PSK, dev_caps, FALSE, is_adhoc, 0, 0, 0) || nm_utils_security_valid (NMU_SEC_WPA2_PSK, dev_caps, FALSE, is_adhoc, 0, 0, 0)) { WirelessSecurityWPAPSK *ws_wpa_psk; ws_wpa_psk = ws_wpa_psk_new (glade_file, connection); if (ws_wpa_psk) { add_security_item (self, WIRELESS_SECURITY (ws_wpa_psk), sec_model, &iter, _("WPA & WPA2 Personal")); if ((active < 0) && ((default_type == NMU_SEC_WPA_PSK) || (default_type == NMU_SEC_WPA2_PSK))) active = item; item++; } } if ( nm_utils_security_valid (NMU_SEC_WPA_ENTERPRISE, dev_caps, FALSE, is_adhoc, 0, 0, 0) || nm_utils_security_valid (NMU_SEC_WPA2_ENTERPRISE, dev_caps, FALSE, is_adhoc, 0, 0, 0)) { WirelessSecurityWPAEAP *ws_wpa_eap; ws_wpa_eap = ws_wpa_eap_new (glade_file, connection); if (ws_wpa_eap) { add_security_item (self, WIRELESS_SECURITY (ws_wpa_eap), sec_model, &iter, _("WPA & WPA2 Enterprise")); if ((active < 0) && ((default_type == NMU_SEC_WPA_ENTERPRISE) || (default_type == NMU_SEC_WPA2_ENTERPRISE))) active = item; item++; } } gtk_combo_box_set_model (combo, GTK_TREE_MODEL (sec_model)); gtk_combo_box_set_active (combo, active < 0 ? 0 : (guint32) active); g_object_unref (G_OBJECT (sec_model)); self->security_combo = combo; wireless_security_combo_changed (combo, self); g_signal_connect (combo, "changed", G_CALLBACK (wireless_security_combo_changed), self); }
WirelessSecurityWEPKey * ws_wep_key_new (const char *glade_file, NMConnection *connection, NMWepKeyType type, gboolean adhoc_create, gboolean simple) { WirelessSecurityWEPKey *sec; GtkWidget *widget; GladeXML *xml; NMSettingWirelessSecurity *s_wsec = NULL; guint8 default_key_idx = 0; gboolean is_adhoc = adhoc_create; gboolean is_shared_key = FALSE; g_return_val_if_fail (glade_file != NULL, NULL); xml = glade_xml_new (glade_file, "wep_key_notebook", NULL); if (xml == NULL) { g_warning ("Couldn't get wep_key_widget from glade xml"); return NULL; } widget = glade_xml_get_widget (xml, "wep_key_notebook"); g_assert (widget); g_object_ref_sink (widget); sec = g_slice_new0 (WirelessSecurityWEPKey); if (!sec) { g_object_unref (xml); g_object_unref (widget); return NULL; } wireless_security_init (WIRELESS_SECURITY (sec), validate, add_to_size_group, fill_connection, update_secrets, destroy, xml, widget, "wep_key_entry"); sec->type = type; widget = glade_xml_get_widget (xml, "wep_key_entry"); g_assert (widget); gtk_entry_set_width_chars (GTK_ENTRY (widget), 28); if (connection) { NMSettingWireless *s_wireless; const char *mode, *auth_alg; s_wireless = (NMSettingWireless *) nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS); mode = s_wireless ? nm_setting_wireless_get_mode (s_wireless) : NULL; if (mode && !strcmp (mode, "adhoc")) is_adhoc = TRUE; s_wsec = NM_SETTING_WIRELESS_SECURITY (nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS_SECURITY)); if (s_wsec) { auth_alg = nm_setting_wireless_security_get_auth_alg (s_wsec); if (auth_alg && !strcmp (auth_alg, "shared")) is_shared_key = TRUE; } } g_signal_connect (G_OBJECT (widget), "changed", (GCallback) wireless_security_changed_cb, sec); g_signal_connect (G_OBJECT (widget), "insert-text", (GCallback) wep_entry_filter_cb, sec); if (sec->type == NM_WEP_KEY_TYPE_KEY) gtk_entry_set_max_length (GTK_ENTRY (widget), 26); else if (sec->type == NM_WEP_KEY_TYPE_PASSPHRASE) gtk_entry_set_max_length (GTK_ENTRY (widget), 64); widget = glade_xml_get_widget (xml, "key_index_combo"); if (connection && s_wsec) default_key_idx = nm_setting_wireless_security_get_wep_tx_keyidx (s_wsec); gtk_combo_box_set_active (GTK_COMBO_BOX (widget), default_key_idx); sec->cur_index = default_key_idx; g_signal_connect (G_OBJECT (widget), "changed", (GCallback) key_index_combo_changed_cb, sec); /* Key index is useless with adhoc networks */ if (is_adhoc || simple) { gtk_widget_hide (widget); widget = glade_xml_get_widget (xml, "key_index_label"); gtk_widget_hide (widget); } /* Fill the key entry with the key for that index */ if (connection) update_secrets (WIRELESS_SECURITY (sec), connection); widget = glade_xml_get_widget (xml, "show_checkbutton"); g_assert (widget); g_signal_connect (G_OBJECT (widget), "toggled", (GCallback) show_toggled_cb, sec); widget = glade_xml_get_widget (xml, "auth_method_combo"); gtk_combo_box_set_active (GTK_COMBO_BOX (widget), is_shared_key ? 1 : 0); g_signal_connect (G_OBJECT (widget), "changed", (GCallback) wireless_security_changed_cb, sec); /* Don't show auth method for adhoc (which always uses open-system) or * when in "simple" mode. */ if (is_adhoc || simple) { /* Ad-Hoc connections can't use Shared Key auth */ if (is_adhoc) gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); gtk_widget_hide (widget); widget = glade_xml_get_widget (xml, "auth_method_label"); gtk_widget_hide (widget); } return sec; }
static void nmt_page_wifi_constructed (GObject *object) { NmtPageWifiPrivate *priv = NMT_PAGE_WIFI_GET_PRIVATE (object); NmtPageWifi *wifi = NMT_PAGE_WIFI (object); NmtDeviceEntry *deventry; NmtEditorSection *section; NmtEditorGrid *grid; NMSettingWireless *s_wireless; NMSettingWirelessSecurity *s_wsec; NmtNewtWidget *widget, *hbox, *subgrid; NmtNewtWidget *mode, *band, *security, *entry; NmtNewtStack *stack; NMConnection *conn; conn = nmt_editor_page_get_connection (NMT_EDITOR_PAGE (wifi)); s_wireless = nm_connection_get_setting_wireless (conn); if (!s_wireless) { nm_connection_add_setting (conn, nm_setting_wireless_new ()); s_wireless = nm_connection_get_setting_wireless (conn); } s_wsec = nm_connection_get_setting_wireless_security (conn); if (!s_wsec) { /* It makes things simpler if we always have a * NMSettingWirelessSecurity; we'll hold a ref on one, and add * it to and remove it from the connection as needed. */ s_wsec = NM_SETTING_WIRELESS_SECURITY (nm_setting_wireless_security_new ()); } priv->s_wsec = g_object_ref_sink (s_wsec); deventry = nmt_editor_page_device_get_device_entry (NMT_EDITOR_PAGE_DEVICE (object)); g_object_bind_property (s_wireless, NM_SETTING_WIRELESS_MAC_ADDRESS, deventry, "mac-address", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); section = nmt_editor_section_new (_("WI-FI"), NULL, TRUE); grid = nmt_editor_section_get_body (section); widget = nmt_newt_entry_new (40, NMT_NEWT_ENTRY_NONEMPTY); g_object_bind_property_full (s_wireless, NM_SETTING_WIRELESS_SSID, widget, "text", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE, ssid_transform_to_entry, ssid_transform_from_entry, s_wireless, NULL); nmt_editor_grid_append (grid, _("SSID"), widget, NULL); widget = nmt_newt_popup_new (wifi_mode); g_object_bind_property (s_wireless, NM_SETTING_WIRELESS_MODE, widget, "active-id", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); nmt_editor_grid_append (grid, _("Mode"), widget, NULL); mode = widget; hbox = nmt_newt_grid_new (); widget = nmt_newt_popup_new (wifi_band); g_object_bind_property (s_wireless, NM_SETTING_WIRELESS_BAND, widget, "active-id", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); nmt_newt_grid_add (NMT_NEWT_GRID (hbox), widget, 0, 0); band = widget; widget = nmt_newt_entry_numeric_new (10, 0, 255); g_object_bind_property (s_wireless, NM_SETTING_WIRELESS_CHANNEL, widget, "text", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); nmt_newt_grid_add (NMT_NEWT_GRID (hbox), widget, 1, 0); nmt_newt_widget_set_padding (widget, 1, 0, 0, 0); g_object_bind_property_full (band, "active-id", widget, "visible", G_BINDING_SYNC_CREATE, band_transform_to_channel_visibility, NULL, NULL, NULL); g_object_bind_property_full (mode, "active-id", hbox, "visible", G_BINDING_SYNC_CREATE, mode_transform_to_band_visibility, NULL, NULL, NULL); nmt_editor_grid_append (grid, _("Channel"), hbox, NULL); nmt_editor_grid_append (grid, NULL, nmt_newt_separator_new (), NULL); widget = nmt_newt_popup_new (wifi_security); nmt_editor_grid_append (grid, _("Security"), widget, NULL); security = widget; widget = nmt_newt_stack_new (); stack = NMT_NEWT_STACK (widget); /* none */ subgrid = nmt_editor_grid_new (); nmt_newt_stack_add (stack, "none", subgrid); /* wpa-personal */ subgrid = nmt_editor_grid_new (); widget = nmt_password_fields_new (40, NMT_PASSWORD_FIELDS_SHOW_PASSWORD); g_object_bind_property (s_wsec, NM_SETTING_WIRELESS_SECURITY_PSK, widget, "password", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); nmt_editor_grid_append (NMT_EDITOR_GRID (subgrid), _("Password"), widget, NULL); nmt_newt_stack_add (stack, "wpa-personal", subgrid); /* "wpa-enterprise" */ // FIXME widget = nmt_newt_label_new (_("(No support for wpa-enterprise yet...)")); nmt_newt_stack_add (stack, "wpa-enterprise", widget); /* wep-key */ subgrid = nmt_editor_grid_new (); widget = entry = nmt_password_fields_new (40, NMT_PASSWORD_FIELDS_SHOW_PASSWORD); nmt_editor_grid_append (NMT_EDITOR_GRID (subgrid), _("Key"), widget, NULL); widget = nmt_newt_popup_new (wep_index); nmt_editor_grid_append (NMT_EDITOR_GRID (subgrid), _("WEP index"), widget, NULL); nm_editor_bind_wireless_security_wep_key (s_wsec, entry, "password", widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); widget = nmt_newt_popup_new (wep_auth); nmt_editor_grid_append (NMT_EDITOR_GRID (subgrid), _("Authentication"), widget, NULL); nmt_newt_stack_add (stack, "wep-key", subgrid); /* wep-passphrase */ subgrid = nmt_editor_grid_new (); widget = entry = nmt_password_fields_new (40, NMT_PASSWORD_FIELDS_SHOW_PASSWORD); nmt_editor_grid_append (NMT_EDITOR_GRID (subgrid), _("Password"), widget, NULL); widget = nmt_newt_popup_new (wep_index); nmt_editor_grid_append (NMT_EDITOR_GRID (subgrid), _("WEP index"), widget, NULL); nm_editor_bind_wireless_security_wep_key (s_wsec, entry, "password", widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); widget = nmt_newt_popup_new (wep_auth); nmt_editor_grid_append (NMT_EDITOR_GRID (subgrid), _("Authentication"), widget, NULL); nmt_newt_stack_add (stack, "wep-passphrase", subgrid); /* "dynamic-wep" */ // FIXME widget = nmt_newt_label_new (_("(No support for dynamic-wep yet...)")); nmt_newt_stack_add (stack, "dynamic-wep", widget); /* leap */ subgrid = nmt_editor_grid_new (); widget = nmt_newt_entry_new (40, NMT_NEWT_ENTRY_NONEMPTY); nmt_editor_grid_append (NMT_EDITOR_GRID (subgrid), _("Username"), widget, NULL); g_object_bind_property (s_wsec, NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME, widget, "text", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); widget = nmt_password_fields_new (40, NMT_PASSWORD_FIELDS_SHOW_PASSWORD); g_object_bind_property (s_wsec, NM_SETTING_WIRELESS_SECURITY_LEAP_PASSWORD, widget, "password", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); nmt_editor_grid_append (NMT_EDITOR_GRID (subgrid), _("Password"), widget, NULL); nmt_newt_stack_add (stack, "leap", subgrid); nmt_editor_grid_append (grid, NULL, NMT_NEWT_WIDGET (stack), NULL); g_object_bind_property (security, "active-id", stack, "active-id", G_BINDING_SYNC_CREATE); nm_editor_bind_wireless_security_method (conn, s_wsec, security, "active-id", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); nmt_editor_grid_append (grid, NULL, nmt_newt_separator_new (), NULL); widget = nmt_mac_entry_new (40, ETH_ALEN); g_object_bind_property (s_wireless, NM_SETTING_WIRELESS_BSSID, widget, "mac-address", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); nmt_editor_grid_append (grid, _("BSSID"), widget, NULL); widget = nmt_mac_entry_new (40, ETH_ALEN); g_object_bind_property (s_wireless, NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS, widget, "mac-address", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); nmt_editor_grid_append (grid, _("Cloned MAC address"), widget, NULL); widget = nmt_mtu_entry_new (); g_object_bind_property (s_wireless, NM_SETTING_WIRELESS_MTU, widget, "mtu", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); nmt_editor_grid_append (grid, _("MTU"), widget, NULL); nmt_editor_page_add_section (NMT_EDITOR_PAGE (wifi), section); G_OBJECT_CLASS (nmt_page_wifi_parent_class)->constructed (object); }
static gboolean security_combo_init (NMAWirelessDialog *self) { NMAWirelessDialogPrivate *priv; GtkListStore *sec_model; GtkTreeIter iter; guint32 ap_flags = 0; guint32 ap_wpa = 0; guint32 ap_rsn = 0; guint32 dev_caps; NMSettingWirelessSecurity *wsec = NULL; NMUtilsSecurityType default_type = NMU_SEC_NONE; NMWepKeyType wep_type = NM_WEP_KEY_TYPE_KEY; int active = -1; int item = 0; NMSettingWireless *s_wireless = NULL; gboolean is_adhoc; g_return_val_if_fail (self != NULL, FALSE); priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self); g_return_val_if_fail (priv->device != NULL, FALSE); g_return_val_if_fail (priv->sec_combo != NULL, FALSE); is_adhoc = priv->adhoc_create; /* The security options displayed are filtered based on device * capabilities, and if provided, additionally by access point capabilities. * If a connection is given, that connection's options should be selected * by default. */ dev_caps = nm_device_wifi_get_capabilities (NM_DEVICE_WIFI (priv->device)); if (priv->ap != NULL) { ap_flags = nm_access_point_get_flags (priv->ap); ap_wpa = nm_access_point_get_wpa_flags (priv->ap); ap_rsn = nm_access_point_get_rsn_flags (priv->ap); } if (priv->connection) { const char *mode; const char *security; s_wireless = NM_SETTING_WIRELESS (nm_connection_get_setting (priv->connection, NM_TYPE_SETTING_WIRELESS)); mode = nm_setting_wireless_get_mode (s_wireless); if (mode && !strcmp (mode, "adhoc")) is_adhoc = TRUE; wsec = NM_SETTING_WIRELESS_SECURITY (nm_connection_get_setting (priv->connection, NM_TYPE_SETTING_WIRELESS_SECURITY)); security = nm_setting_wireless_get_security (s_wireless); if (!security || strcmp (security, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME)) wsec = NULL; if (wsec) { default_type = get_default_type_for_security (wsec, !!priv->ap, ap_flags, dev_caps); if (default_type == NMU_SEC_STATIC_WEP) wep_type = nm_setting_wireless_security_get_wep_key_type (wsec); if (wep_type == NM_WEP_KEY_TYPE_UNKNOWN) wep_type = NM_WEP_KEY_TYPE_KEY; } } else if (is_adhoc) { default_type = NMU_SEC_STATIC_WEP; wep_type = NM_WEP_KEY_TYPE_PASSPHRASE; } sec_model = gtk_list_store_new (2, G_TYPE_STRING, wireless_security_get_g_type ()); if (nm_utils_security_valid (NMU_SEC_NONE, dev_caps, !!priv->ap, is_adhoc, ap_flags, ap_wpa, ap_rsn)) { gtk_list_store_append (sec_model, &iter); gtk_list_store_set (sec_model, &iter, S_NAME_COLUMN, _("None"), -1); if (default_type == NMU_SEC_NONE) active = item; item++; } /* Don't show Static WEP if both the AP and the device are capable of WPA, * even though technically it's possible to have this configuration. */ if ( nm_utils_security_valid (NMU_SEC_STATIC_WEP, dev_caps, !!priv->ap, is_adhoc, ap_flags, ap_wpa, ap_rsn) && ((!ap_wpa && !ap_rsn) || !(dev_caps & (NM_WIFI_DEVICE_CAP_WPA | NM_WIFI_DEVICE_CAP_RSN)))) { WirelessSecurityWEPKey *ws_wep; ws_wep = ws_wep_key_new (priv->connection, NM_WEP_KEY_TYPE_KEY, priv->adhoc_create); if (ws_wep) { add_security_item (self, WIRELESS_SECURITY (ws_wep), sec_model, &iter, _("WEP 40/128-bit Key")); if ((active < 0) && (default_type == NMU_SEC_STATIC_WEP) && (wep_type == NM_WEP_KEY_TYPE_KEY)) active = item; item++; } ws_wep = ws_wep_key_new (priv->connection, NM_WEP_KEY_TYPE_PASSPHRASE, priv->adhoc_create); if (ws_wep) { add_security_item (self, WIRELESS_SECURITY (ws_wep), sec_model, &iter, _("WEP 128-bit Passphrase")); if ((active < 0) && (default_type == NMU_SEC_STATIC_WEP) && (wep_type == NM_WEP_KEY_TYPE_PASSPHRASE)) active = item; item++; } } /* Don't show LEAP if both the AP and the device are capable of WPA, * even though technically it's possible to have this configuration. */ if ( nm_utils_security_valid (NMU_SEC_LEAP, dev_caps, !!priv->ap, is_adhoc, ap_flags, ap_wpa, ap_rsn) && ((!ap_wpa && !ap_rsn) || !(dev_caps & (NM_WIFI_DEVICE_CAP_WPA | NM_WIFI_DEVICE_CAP_RSN)))) { WirelessSecurityLEAP *ws_leap; ws_leap = ws_leap_new (priv->connection); if (ws_leap) { add_security_item (self, WIRELESS_SECURITY (ws_leap), sec_model, &iter, _("LEAP")); if ((active < 0) && (default_type == NMU_SEC_LEAP)) active = item; item++; } } if (nm_utils_security_valid (NMU_SEC_DYNAMIC_WEP, dev_caps, !!priv->ap, is_adhoc, ap_flags, ap_wpa, ap_rsn)) { WirelessSecurityDynamicWEP *ws_dynamic_wep; ws_dynamic_wep = ws_dynamic_wep_new (priv->connection); if (ws_dynamic_wep) { add_security_item (self, WIRELESS_SECURITY (ws_dynamic_wep), sec_model, &iter, _("Dynamic WEP (802.1x)")); if ((active < 0) && (default_type == NMU_SEC_DYNAMIC_WEP)) active = item; item++; } } if ( nm_utils_security_valid (NMU_SEC_WPA_PSK, dev_caps, !!priv->ap, is_adhoc, ap_flags, ap_wpa, ap_rsn) || nm_utils_security_valid (NMU_SEC_WPA2_PSK, dev_caps, !!priv->ap, is_adhoc, ap_flags, ap_wpa, ap_rsn)) { WirelessSecurityWPAPSK *ws_wpa_psk; ws_wpa_psk = ws_wpa_psk_new (priv->connection); if (ws_wpa_psk) { add_security_item (self, WIRELESS_SECURITY (ws_wpa_psk), sec_model, &iter, _("WPA & WPA2 Personal")); if ((active < 0) && ((default_type == NMU_SEC_WPA_PSK) || (default_type == NMU_SEC_WPA2_PSK))) active = item; item++; } } if ( nm_utils_security_valid (NMU_SEC_WPA_ENTERPRISE, dev_caps, !!priv->ap, is_adhoc, ap_flags, ap_wpa, ap_rsn) || nm_utils_security_valid (NMU_SEC_WPA2_ENTERPRISE, dev_caps, !!priv->ap, is_adhoc, ap_flags, ap_wpa, ap_rsn)) { WirelessSecurityWPAEAP *ws_wpa_eap; ws_wpa_eap = ws_wpa_eap_new (priv->connection); if (ws_wpa_eap) { add_security_item (self, WIRELESS_SECURITY (ws_wpa_eap), sec_model, &iter, _("WPA & WPA2 Enterprise")); if ((active < 0) && ((default_type == NMU_SEC_WPA_ENTERPRISE) || (default_type == NMU_SEC_WPA2_ENTERPRISE))) active = item; item++; } } gtk_combo_box_set_model (GTK_COMBO_BOX (priv->sec_combo), GTK_TREE_MODEL (sec_model)); gtk_combo_box_set_active (GTK_COMBO_BOX (priv->sec_combo), active < 0 ? 0 : (guint32) active); g_object_unref (G_OBJECT (sec_model)); return TRUE; }