void ws_802_1x_fill_connection (WirelessSecurity *sec, const char *combo_name, NMConnection *connection) { GtkWidget *widget; NMSettingWireless *s_wireless; NMSettingWirelessSecurity *s_wireless_sec; NMSetting8021x *s_8021x; EAPMethod *eap = NULL; GtkTreeModel *model; GtkTreeIter iter; s_wireless = nm_connection_get_setting_wireless (connection); g_assert (s_wireless); g_object_set (s_wireless, NM_SETTING_WIRELESS_SEC, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NULL); /* Blow away the old wireless security setting by adding a clear one */ s_wireless_sec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new (); nm_connection_add_setting (connection, (NMSetting *) s_wireless_sec); /* Blow away the old 802.1x setting by adding a clear one */ s_8021x = (NMSetting8021x *) nm_setting_802_1x_new (); nm_connection_add_setting (connection, (NMSetting *) s_8021x); widget = GTK_WIDGET (gtk_builder_get_object (sec->builder, combo_name)); model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget)); gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter); gtk_tree_model_get (model, &iter, AUTH_METHOD_COLUMN, &eap, -1); g_assert (eap); eap_method_fill_connection (eap, connection); eap_method_unref (eap); }
void nm_utils_complete_generic (NMConnection *connection, const char *ctype, const GSList *existing, const char *format, const char *preferred, gboolean default_enable_ipv6) { NMSettingConnection *s_con; NMSettingIP4Config *s_ip4; NMSettingIP6Config *s_ip6; const char *method; char *id, *uuid; s_con = nm_connection_get_setting_connection (connection); if (!s_con) { s_con = (NMSettingConnection *) nm_setting_connection_new (); nm_connection_add_setting (connection, NM_SETTING (s_con)); } g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_TYPE, ctype, NULL); if (!nm_setting_connection_get_uuid (s_con)) { uuid = nm_utils_uuid_generate (); g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_UUID, uuid, NULL); g_free (uuid); } /* Add a connection ID if absent */ if (!nm_setting_connection_get_id (s_con)) { id = get_new_connection_name (existing, format, preferred); g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_ID, id, NULL); g_free (id); } /* Add an 'auto' IPv4 connection if present */ s_ip4 = nm_connection_get_setting_ip4_config (connection); if (!s_ip4) { s_ip4 = (NMSettingIP4Config *) nm_setting_ip4_config_new (); nm_connection_add_setting (connection, NM_SETTING (s_ip4)); } method = nm_setting_ip4_config_get_method (s_ip4); if (!method) { g_object_set (G_OBJECT (s_ip4), NM_SETTING_IP4_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO, NULL); } /* Add an 'auto' IPv6 setting if allowed and not preset */ s_ip6 = nm_connection_get_setting_ip6_config (connection); if (!s_ip6 && default_enable_ipv6) { s_ip6 = (NMSettingIP6Config *) nm_setting_ip6_config_new (); nm_connection_add_setting (connection, NM_SETTING (s_ip6)); } if (s_ip6 && !nm_setting_ip6_config_get_method (s_ip6)) { g_object_set (G_OBJECT (s_ip6), NM_SETTING_IP6_CONFIG_METHOD, NM_SETTING_IP6_CONFIG_METHOD_AUTO, NM_SETTING_IP6_CONFIG_MAY_FAIL, TRUE, NULL); } }
void dsl_connection_new (FUNC_TAG_PAGE_NEW_CONNECTION_IMPL, GtkWindow *parent, const char *detail, gpointer detail_data, NMConnection *connection, NMClient *client, PageNewConnectionResultFunc result_func, gpointer user_data) { NMSetting *setting; gs_unref_object NMConnection *connection_tmp = NULL; connection = _ensure_connection_other (connection, &connection_tmp); ce_page_complete_connection (connection, _("DSL connection %d"), NM_SETTING_PPPOE_SETTING_NAME, FALSE, client); nm_connection_add_setting (connection, nm_setting_pppoe_new ()); nm_connection_add_setting (connection, nm_setting_wired_new ()); setting = nm_setting_ppp_new (); /* Set default values for lcp-echo-failure and lcp-echo-interval */ g_object_set (G_OBJECT (setting), NM_SETTING_PPP_LCP_ECHO_FAILURE, 5, NM_SETTING_PPP_LCP_ECHO_INTERVAL, 30, NULL); nm_connection_add_setting (connection, setting); (*result_func) (FUNC_TAG_PAGE_NEW_CONNECTION_RESULT_CALL, connection, FALSE, NULL, user_data); }
static void add_pan_connection (NmaBtDevice *self) { NmaBtDevicePrivate *priv = NMA_BT_DEVICE_GET_PRIVATE (self); NMConnection *connection; NMSetting *setting, *bt_setting, *ip_setting; char *id, *uuid; /* The connection */ connection = nm_connection_new (); /* The connection settings */ setting = nm_setting_connection_new (); id = g_strdup_printf (_("%s Network"), priv->alias ? priv->alias : priv->bdaddr); uuid = nm_utils_uuid_generate (); g_object_set (G_OBJECT (setting), NM_SETTING_CONNECTION_ID, id, NM_SETTING_CONNECTION_UUID, uuid, NM_SETTING_CONNECTION_TYPE, NM_SETTING_BLUETOOTH_SETTING_NAME, NM_SETTING_CONNECTION_AUTOCONNECT, FALSE, NULL); g_free (id); g_free (uuid); nm_setting_connection_add_permission ((NMSettingConnection *) setting, "user", g_get_user_name (), NULL); nm_connection_add_setting (connection, setting); /* The Bluetooth settings */ bt_setting = nm_setting_bluetooth_new (); g_object_set (G_OBJECT (bt_setting), NM_SETTING_BLUETOOTH_BDADDR, priv->bdaddr_array, NM_SETTING_BLUETOOTH_TYPE, NM_SETTING_BLUETOOTH_TYPE_PANU, NULL); nm_connection_add_setting (connection, bt_setting); /* IPv4 */ ip_setting = nm_setting_ip4_config_new (); g_object_set (G_OBJECT (ip_setting), NM_SETTING_IP4_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO, NM_SETTING_IP4_CONFIG_MAY_FAIL, FALSE, NULL); nm_connection_add_setting (connection, ip_setting); /* IPv6 */ ip_setting = nm_setting_ip6_config_new (); g_object_set (G_OBJECT (ip_setting), NM_SETTING_IP6_CONFIG_METHOD, NM_SETTING_IP6_CONFIG_METHOD_AUTO, NM_SETTING_IP6_CONFIG_MAY_FAIL, TRUE, NULL); nm_connection_add_setting (connection, ip_setting); /* Add the connection to the settings service */ nm_remote_settings_add_connection (priv->settings, connection, pan_add_cb, self); }
static void update_connection (NMDevice *device, NMConnection *connection) { NMDeviceTeam *self = NM_DEVICE_TEAM (device); NMSettingTeam *s_team = nm_connection_get_setting_team (connection); NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE (self); if (!s_team) { s_team = (NMSettingTeam *) nm_setting_team_new (); nm_connection_add_setting (connection, (NMSetting *) s_team); } g_object_set (G_OBJECT (s_team), NM_SETTING_TEAM_CONFIG, NULL, NULL); if (priv->tdc) { const char *config = NULL; int err; err = teamdctl_config_get_raw_direct (NM_DEVICE_TEAM_GET_PRIVATE (device)->tdc, (char **)&config); if (err == 0) g_object_set (G_OBJECT (s_team), NM_SETTING_TEAM_CONFIG, config, NULL); else _LOGE (LOGD_TEAM, "failed to read teamd config (err=%d)", err); } }
static gboolean complete_connection (NMDevice *device, NMConnection *connection, const char *specific_object, const GSList *existing_connections, GError **error) { NMSettingTeam *s_team; nm_utils_complete_generic (NM_PLATFORM_GET, connection, NM_SETTING_TEAM_SETTING_NAME, existing_connections, NULL, _("Team connection"), "team", TRUE); s_team = nm_connection_get_setting_team (connection); if (!s_team) { s_team = (NMSettingTeam *) nm_setting_team_new (); nm_connection_add_setting (connection, NM_SETTING (s_team)); } return TRUE; }
static void update_connection (NMDevice *device, NMConnection *connection) { NMSettingInfiniband *s_infiniband = nm_connection_get_setting_infiniband (connection); const char *mac = nm_device_get_hw_address (device); char *mode_path, *contents = NULL; const char *transport_mode = "datagram"; if (!s_infiniband) { s_infiniband = (NMSettingInfiniband *) nm_setting_infiniband_new (); nm_connection_add_setting (connection, (NMSetting *) s_infiniband); } if (mac && !nm_utils_hwaddr_matches (mac, -1, NULL, INFINIBAND_ALEN)) g_object_set (s_infiniband, NM_SETTING_INFINIBAND_MAC_ADDRESS, mac, NULL); mode_path = g_strdup_printf ("/sys/class/net/%s/mode", ASSERT_VALID_PATH_COMPONENT (nm_device_get_iface (device))); contents = nm_platform_sysctl_get (mode_path); g_free (mode_path); if (contents) { if (strstr (contents, "datagram")) transport_mode = "datagram"; else if (strstr (contents, "connected")) transport_mode = "connected"; g_free (contents); } g_object_set (G_OBJECT (s_infiniband), NM_SETTING_INFINIBAND_TRANSPORT_MODE, transport_mode, NULL); }
static gboolean complete_connection (NMDevice *device, NMConnection *connection, const char *specific_object, const GSList *existing_connections, GError **error) { NMSettingBridge *s_bridge; nm_utils_complete_generic (NM_PLATFORM_GET, connection, NM_SETTING_BRIDGE_SETTING_NAME, existing_connections, NULL, _("Bridge connection"), "bridge", TRUE); s_bridge = nm_connection_get_setting_bridge (connection); if (!s_bridge) { s_bridge = (NMSettingBridge *) nm_setting_bridge_new (); nm_connection_add_setting (connection, NM_SETTING (s_bridge)); } return TRUE; }
static void update_connection (NMDevice *device, NMConnection *connection) { NMDeviceBridge *self = NM_DEVICE_BRIDGE (device); NMSettingBridge *s_bridge = nm_connection_get_setting_bridge (connection); int ifindex = nm_device_get_ifindex (device); const Option *option; if (!s_bridge) { s_bridge = (NMSettingBridge *) nm_setting_bridge_new (); nm_connection_add_setting (connection, (NMSetting *) s_bridge); } for (option = master_options; option->name; option++) { gs_free char *str = nm_platform_sysctl_master_get_option (NM_PLATFORM_GET, ifindex, option->sysname); int value; if (str) { value = strtol (str, NULL, 10); /* See comments in set_sysfs_uint() about centiseconds. */ if (option->user_hz_compensate) value /= 100; g_object_set (s_bridge, option->name, value, NULL); } else _LOGW (LOGD_BRIDGE, "failed to read bridge setting '%s'", option->sysname); } }
gboolean nm_team_update_slave_connection (NMDevice *slave, NMConnection *connection) { NMSettingTeamPort *s_port; const char *iface = nm_device_get_iface (slave); char *port_config = NULL; gboolean with_teamdctl = FALSE; int err = 0; #if WITH_TEAMDCTL const char *master_iface; int master_ifindex; struct teamdctl *tdc; const char *team_port_config = NULL; #endif g_return_val_if_fail (NM_IS_DEVICE (slave), FALSE); g_return_val_if_fail (NM_IS_CONNECTION (connection), FALSE); #if WITH_TEAMDCTL master_ifindex = nm_platform_link_get_master (nm_device_get_ifindex (slave)); g_assert (master_ifindex > 0); master_iface = nm_platform_link_get_name (master_ifindex); g_assert (master_iface); tdc = teamdctl_alloc (); g_assert (tdc); err = teamdctl_connect (tdc, master_iface, NULL, NULL); if (err) { nm_log_err (LOGD_TEAM, "(%s): failed to connect to teamd for master %s (err=%d)", iface, master_iface, err); teamdctl_free (tdc); return FALSE; } err = teamdctl_port_config_get_raw_direct (tdc, iface, (char **)&team_port_config); port_config = g_strdup (team_port_config); teamdctl_free (tdc); with_teamdctl = TRUE; #endif s_port = nm_connection_get_setting_team_port (connection); if (!s_port) { s_port = (NMSettingTeamPort *) nm_setting_team_port_new (); nm_connection_add_setting (connection, NM_SETTING (s_port)); } g_object_set (G_OBJECT (s_port), NM_SETTING_TEAM_PORT_CONFIG, port_config, NULL); g_free (port_config); if (!with_teamdctl || err != 0) { if (!with_teamdctl) nm_log_err (LOGD_TEAM, "(%s): failed to read teamd port configuration " " (compiled without libteamdctl support)", iface); else nm_log_err (LOGD_TEAM, "(%s): failed to read teamd port configuration (err=%d)", iface, err); return FALSE; } return TRUE; }
void ce_page_complete_connection (NMConnection *connection, const char *format, const char *ctype, gboolean autoconnect, NMClient *client) { NMSettingConnection *s_con; char *id, *uuid; const GPtrArray *connections; s_con = nm_connection_get_setting_connection (connection); if (!s_con) { s_con = NM_SETTING_CONNECTION (nm_setting_connection_new ()); nm_connection_add_setting (connection, NM_SETTING (s_con)); } if (!nm_setting_connection_get_id (s_con)) { connections = nm_client_get_connections (client); id = ce_page_get_next_available_name (connections, format); g_object_set (s_con, NM_SETTING_CONNECTION_ID, id, NULL); g_free (id); } uuid = nm_utils_uuid_generate (); g_object_set (s_con, NM_SETTING_CONNECTION_UUID, uuid, NM_SETTING_CONNECTION_TYPE, ctype, NM_SETTING_CONNECTION_AUTOCONNECT, autoconnect, NULL); g_free (uuid); }
static gboolean complete_connection (NMDevice *device, NMConnection *connection, const char *specific_object, const GSList *existing_connections, GError **error) { NMSettingBond *s_bond; nm_utils_complete_generic (NM_PLATFORM_GET, connection, NM_SETTING_BOND_SETTING_NAME, existing_connections, NULL, _("Bond connection"), "bond", TRUE); s_bond = nm_connection_get_setting_bond (connection); if (!s_bond) { s_bond = (NMSettingBond *) nm_setting_bond_new (); nm_connection_add_setting (connection, NM_SETTING (s_bond)); } return TRUE; }
static void update_connection (NMDevice *device, NMConnection *connection) { NMSettingBridge *s_bridge = nm_connection_get_setting_bridge (connection); const char *ifname = nm_device_get_iface (device); int ifindex = nm_device_get_ifindex (device); const Option *option; if (!s_bridge) { s_bridge = (NMSettingBridge *) nm_setting_bridge_new (); nm_connection_add_setting (connection, (NMSetting *) s_bridge); g_object_set (s_bridge, NM_SETTING_BRIDGE_INTERFACE_NAME, ifname, NULL); } for (option = master_options; option->name; option++) { gs_free char *str = nm_platform_master_get_option (ifindex, option->sysname); int value = strtol (str, NULL, 10); /* See comments in set_sysfs_uint() about centiseconds. */ if (option->user_hz_compensate) value /= 100; g_object_set (s_bridge, option->name, value, NULL); } }
static void update_connection (NMDevice *device, NMConnection *connection) { NMSettingBond *s_bond = nm_connection_get_setting_bond (connection); int ifindex = nm_device_get_ifindex (device); const char **options; if (!s_bond) { s_bond = (NMSettingBond *) nm_setting_bond_new (); nm_connection_add_setting (connection, (NMSetting *) s_bond); } /* Read bond options from sysfs and update the Bond setting to match */ options = nm_setting_bond_get_valid_options (s_bond); while (options && *options) { gs_free char *value = nm_platform_sysctl_master_get_option (nm_device_get_platform(device), ifindex, *options); const char *defvalue = nm_setting_bond_get_option_default (s_bond, *options); if (value && !ignore_if_zero (*options, value) && (g_strcmp0 (value, defvalue) != 0)) { /* Replace " " with "," for arp_ip_targets from the kernel */ if (strcmp (*options, "arp_ip_target") == 0) { char *p = value; while (p && *p) { if (*p == ' ') *p = ','; p++; } } nm_setting_bond_add_option (s_bond, *options, value); } options++; } }
static void update_connection (NMDevice *device, NMConnection *connection) { NMSettingTeam *s_team = nm_connection_get_setting_team (connection); const char *iface = nm_device_get_iface (device); if (!s_team) { s_team = (NMSettingTeam *) nm_setting_team_new (); nm_connection_add_setting (connection, (NMSetting *) s_team); g_object_set (G_OBJECT (s_team), NM_SETTING_TEAM_INTERFACE_NAME, iface, NULL); } g_object_set (G_OBJECT (s_team), NM_SETTING_TEAM_CONFIG, NULL, NULL); #if WITH_TEAMDCTL if (ensure_teamd_connection (device)) { const char *config = NULL; int err; err = teamdctl_config_get_raw_direct (NM_DEVICE_TEAM_GET_PRIVATE (device)->tdc, (char **)&config); if (err == 0) g_object_set (G_OBJECT (s_team), NM_SETTING_TEAM_CONFIG, config, NULL); else nm_log_err (LOGD_TEAM, "(%s): failed to read teamd config (err=%d)", iface, err); } #endif }
CEPage * ce_page_wired_new (NMConnection *connection, GtkWindow *parent_window, NMClient *client, const char **out_secrets_setting_name, GError **error) { CEPageWired *self; CEPageWiredPrivate *priv; self = CE_PAGE_WIRED (ce_page_new (CE_TYPE_PAGE_WIRED, connection, parent_window, client, UIDIR "/ce-page-wired.ui", "WiredPage", _("Wired"))); if (!self) { g_set_error_literal (error, NMA_ERROR, NMA_ERROR_GENERIC, _("Could not load wired user interface.")); return NULL; } wired_private_init (self); priv = CE_PAGE_WIRED_GET_PRIVATE (self); priv->setting = nm_connection_get_setting_wired (connection); if (!priv->setting) { priv->setting = NM_SETTING_WIRED (nm_setting_wired_new ()); nm_connection_add_setting (connection, NM_SETTING (priv->setting)); } g_signal_connect (self, "initialized", G_CALLBACK (finish_setup), NULL); return CE_PAGE (self); }
void vpn_connection_new (GtkWindow *parent, PageNewConnectionResultFunc result_func, PageGetConnectionsFunc get_connections_func, gpointer user_data) { char *service = NULL; NMConnection *connection; NMSetting *s_vpn; service = vpn_ask_connection_type (parent); if (!service) { (*result_func) (NULL, TRUE, NULL, user_data); return; } connection = ce_page_new_connection (_("VPN connection %d"), NM_SETTING_VPN_SETTING_NAME, FALSE, get_connections_func, user_data); s_vpn = nm_setting_vpn_new (); g_object_set (s_vpn, NM_SETTING_VPN_SERVICE_TYPE, service, NULL); g_free (service); nm_connection_add_setting (connection, s_vpn); (*result_func) (connection, FALSE, NULL, user_data); }
static NMConnection * dun_new_gsm (NMAMobileWizardAccessMethod *method) { NMConnection *connection; NMSetting *setting; char *uuid, *id; connection = nm_connection_new (); setting = nm_setting_gsm_new (); g_object_set (setting, NM_SETTING_GSM_NUMBER, "*99#", NM_SETTING_GSM_USERNAME, method->username, NM_SETTING_GSM_PASSWORD, method->password, NM_SETTING_GSM_PASSWORD_FLAGS, NM_SETTING_SECRET_FLAG_AGENT_OWNED, NM_SETTING_GSM_APN, method->gsm_apn, NULL); nm_connection_add_setting (connection, setting); /* Serial setting */ setting = nm_setting_serial_new (); g_object_set (setting, NM_SETTING_SERIAL_BAUD, 115200, NM_SETTING_SERIAL_BITS, 8, NM_SETTING_SERIAL_PARITY, 'n', NM_SETTING_SERIAL_STOPBITS, 1, NULL); nm_connection_add_setting (connection, setting); nm_connection_add_setting (connection, nm_setting_ppp_new ()); setting = nm_setting_connection_new (); id = utils_create_mobile_connection_id (method->provider_name, method->plan_name); uuid = nm_utils_uuid_generate (); g_object_set (setting, NM_SETTING_CONNECTION_ID, id, NM_SETTING_CONNECTION_TYPE, NM_SETTING_BLUETOOTH_SETTING_NAME, NM_SETTING_CONNECTION_AUTOCONNECT, FALSE, NM_SETTING_CONNECTION_UUID, uuid, NULL); g_free (uuid); g_free (id); nm_setting_connection_add_permission ((NMSettingConnection *) setting, "user", g_get_user_name (), NULL); nm_connection_add_setting (connection, setting); return connection; }
static void update_wired_setting_from_if_block(NMConnection *connection, if_block *block) { NMSettingWired *s_wired = NULL; s_wired = NM_SETTING_WIRED(nm_setting_wired_new()); nm_connection_add_setting(connection, NM_SETTING(s_wired)); }
static void test_add_connection (void) { gs_unref_object NMConnection *connection = NULL; NMSettingConnection *s_con; NMSettingWired *s_wired; char *uuid; gboolean success; time_t start, now; gboolean done = FALSE; connection = nm_connection_new (); s_con = (NMSettingConnection *) nm_setting_connection_new (); uuid = nm_utils_uuid_generate (); g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_ID, TEST_CON_ID, NM_SETTING_CONNECTION_UUID, uuid, NM_SETTING_CONNECTION_TYPE, NM_SETTING_WIRED_SETTING_NAME, NULL); g_free (uuid); nm_connection_add_setting (connection, NM_SETTING (s_con)); s_wired = (NMSettingWired *) nm_setting_wired_new (); nm_connection_add_setting (connection, NM_SETTING (s_wired)); success = nm_remote_settings_add_connection (settings, connection, add_cb, &done); g_assert (success == TRUE); start = time (NULL); do { now = time (NULL); g_main_context_iteration (NULL, FALSE); } while ((done == FALSE) && (now - start < 5)); g_assert (done == TRUE); g_assert (remote != NULL); /* Make sure the connection is the same as what we added */ g_assert (nm_connection_compare (connection, NM_CONNECTION (remote), NM_SETTING_COMPARE_FLAG_EXACT) == TRUE); }
static gboolean add_connection (NMRemoteSettings *settings, GMainLoop *loop, const char *con_name) { NMConnection *connection; NMSettingConnection *s_con; NMSettingWired *s_wired; NMSettingIP4Config *s_ip4; char *uuid; gboolean success; /* Create a new connection object */ connection = nm_connection_new (); /* Build up the 'connection' Setting */ s_con = (NMSettingConnection *) nm_setting_connection_new (); uuid = nm_utils_uuid_generate (); g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_UUID, uuid, NM_SETTING_CONNECTION_ID, con_name, NM_SETTING_CONNECTION_TYPE, "802-3-ethernet", NULL); g_free (uuid); nm_connection_add_setting (connection, NM_SETTING (s_con)); /* Build up the 'wired' Setting */ s_wired = (NMSettingWired *) nm_setting_wired_new (); nm_connection_add_setting (connection, NM_SETTING (s_wired)); /* Build up the 'ipv4' Setting */ s_ip4 = (NMSettingIP4Config *) nm_setting_ip4_config_new (); g_object_set (G_OBJECT (s_ip4), NM_SETTING_IP4_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO, NULL); nm_connection_add_setting (connection, NM_SETTING (s_ip4)); /* Ask the settings service to add the new connection; we'll quit the * mainloop and exit when the callback is called. */ success = nm_remote_settings_add_connection (settings, connection, added_cb, loop); if (!success) g_print ("Error adding connection\n"); g_object_unref (connection); return success; }
static void fill_connection (WirelessSecurity *parent, NMConnection *connection) { WirelessSecurityWPAPSK *wpa_psk = (WirelessSecurityWPAPSK *) parent; GtkWidget *widget, *passwd_entry; const char *key; NMSettingWireless *s_wireless; NMSettingWirelessSecurity *s_wireless_sec; NMSettingSecretFlags secret_flags; const char *mode; gboolean is_adhoc = FALSE; s_wireless = nm_connection_get_setting_wireless (connection); g_assert (s_wireless); mode = nm_setting_wireless_get_mode (s_wireless); if (mode && !strcmp (mode, "adhoc")) is_adhoc = TRUE; /* Blow away the old security setting by adding a clear one */ s_wireless_sec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new (); nm_connection_add_setting (connection, (NMSetting *) s_wireless_sec); widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "wpa_psk_entry")); passwd_entry = widget; key = gtk_entry_get_text (GTK_ENTRY (widget)); g_object_set (s_wireless_sec, NM_SETTING_WIRELESS_SECURITY_PSK, key, NULL); /* Save PSK_FLAGS to the connection */ secret_flags = nma_utils_menu_to_secret_flags (passwd_entry); nm_setting_set_secret_flags (NM_SETTING (s_wireless_sec), NM_SETTING_WIRELESS_SECURITY_PSK, secret_flags, NULL); /* Update secret flags and popup when editing the connection */ if (wpa_psk->editing_connection) nma_utils_update_password_storage (passwd_entry, secret_flags, NM_SETTING (s_wireless_sec), wpa_psk->password_flags_name); wireless_security_clear_ciphers (connection); if (is_adhoc) { /* Ad-Hoc settings as specified by the supplicant */ g_object_set (s_wireless_sec, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "wpa-none", NULL); nm_setting_wireless_security_add_proto (s_wireless_sec, "wpa"); nm_setting_wireless_security_add_pairwise (s_wireless_sec, "none"); /* Ad-hoc can only have _one_ group cipher... default to TKIP to be more * compatible for now. Maybe we'll support selecting CCMP later. */ nm_setting_wireless_security_add_group (s_wireless_sec, "tkip"); } else { g_object_set (s_wireless_sec, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "wpa-psk", NULL); /* Just leave ciphers and protocol empty, the supplicant will * figure that out magically based on the AP IEs and card capabilities. */ } }
static NMConnection * dun_new_cdma (NMAMobileWizardAccessMethod *method) { NMConnection *connection; NMSetting *setting; char *uuid, *id; connection = nm_connection_new (); setting = nm_setting_cdma_new (); g_object_set (setting, NM_SETTING_CDMA_NUMBER, "#777", NM_SETTING_CDMA_USERNAME, method->username, NM_SETTING_CDMA_PASSWORD, method->password, NULL); nm_connection_add_setting (connection, setting); /* Serial setting */ setting = nm_setting_serial_new (); g_object_set (setting, NM_SETTING_SERIAL_BAUD, 115200, NM_SETTING_SERIAL_BITS, 8, NM_SETTING_SERIAL_PARITY, 'n', NM_SETTING_SERIAL_STOPBITS, 1, NULL); nm_connection_add_setting (connection, setting); nm_connection_add_setting (connection, nm_setting_ppp_new ()); setting = nm_setting_connection_new (); id = utils_create_mobile_connection_id (method->provider_name, method->plan_name); uuid = nm_utils_uuid_generate (); g_object_set (setting, NM_SETTING_CONNECTION_ID, id, NM_SETTING_CONNECTION_TYPE, NM_SETTING_BLUETOOTH_SETTING_NAME, NM_SETTING_CONNECTION_AUTOCONNECT, FALSE, NM_SETTING_CONNECTION_UUID, uuid, NULL); g_free (uuid); g_free (id); nm_connection_add_setting (connection, setting); return connection; }
static void add_profile (GtkButton *button, NetDeviceEthernet *device) { NMRemoteSettings *settings; NMConnection *connection; NMSettingConnection *sc; gchar *uuid, *id; NetConnectionEditor *editor; GtkWidget *window; NMClient *client; NMDevice *nmdev; GSList *connections; connection = nm_connection_new (); sc = NM_SETTING_CONNECTION (nm_setting_connection_new ()); nm_connection_add_setting (connection, NM_SETTING (sc)); uuid = nm_utils_uuid_generate (); settings = net_object_get_remote_settings (NET_OBJECT (device)); connections = nm_remote_settings_list_connections (settings); id = ce_page_get_next_available_name (connections, _("Profile %d")); g_slist_free (connections); g_object_set (sc, NM_SETTING_CONNECTION_UUID, uuid, NM_SETTING_CONNECTION_ID, id, NM_SETTING_CONNECTION_TYPE, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_CONNECTION_AUTOCONNECT, TRUE, NULL); nm_connection_add_setting (connection, nm_setting_wired_new ()); g_free (uuid); g_free (id); window = gtk_widget_get_toplevel (GTK_WIDGET (button)); nmdev = net_device_get_nm_device (NET_DEVICE (device)); client = net_object_get_client (NET_OBJECT (device)); editor = net_connection_editor_new (GTK_WINDOW (window), connection, nmdev, NULL, client, settings); g_signal_connect (editor, "done", G_CALLBACK (editor_done), device); net_connection_editor_run (editor); }
static void import_cb (NMConnection *connection, gpointer user_data) { NewVpnInfo *info = (NewVpnInfo *) user_data; NMSettingConnection *s_con; NMSettingVPN *s_vpn; const char *service_type; char *s; GError *error = NULL; /* Basic sanity checks of the connection */ s_con = nm_connection_get_setting_connection (connection); if (!s_con) { s_con = NM_SETTING_CONNECTION (nm_setting_connection_new ()); nm_connection_add_setting (connection, NM_SETTING (s_con)); } s = (char *) nm_setting_connection_get_id (s_con); if (!s) { GSList *connections; connections = nm_remote_settings_list_connections (info->settings); s = ce_page_get_next_available_name (connections, _("VPN connection %d")); g_object_set (s_con, NM_SETTING_CONNECTION_ID, s, NULL); g_free (s); g_slist_free (connections); } s = (char *) nm_setting_connection_get_connection_type (s_con); if (!s || strcmp (s, NM_SETTING_VPN_SETTING_NAME)) g_object_set (s_con, NM_SETTING_CONNECTION_TYPE, NM_SETTING_VPN_SETTING_NAME, NULL); s = (char *) nm_setting_connection_get_uuid (s_con); if (!s) { s = nm_utils_uuid_generate (); g_object_set (s_con, NM_SETTING_CONNECTION_UUID, s, NULL); g_free (s); } s_vpn = nm_connection_get_setting_vpn (connection); service_type = s_vpn ? nm_setting_vpn_get_service_type (s_vpn) : NULL; if (!service_type || !strlen (service_type)) { g_object_unref (connection); connection = NULL; error = g_error_new_literal (NMA_ERROR, NMA_ERROR_GENERIC, _("The VPN plugin failed to import the VPN connection correctly\n\nError: no VPN service type.")); } info->result_func (connection, FALSE, error, info->user_data); g_clear_error (&error); g_object_unref (info->settings); g_slice_free (NewVpnInfo, info); }
static gboolean complete_connection (NMDevice *device, NMConnection *connection, const char *specific_object, const GSList *existing_connections, GError **error) { NMSettingBridge *s_bridge, *tmp; guint32 i = 0; char *name; const GSList *iter; gboolean found; nm_utils_complete_generic (connection, NM_SETTING_BRIDGE_SETTING_NAME, existing_connections, _("Bridge connection %d"), NULL, TRUE); s_bridge = nm_connection_get_setting_bridge (connection); if (!s_bridge) { s_bridge = (NMSettingBridge *) nm_setting_bridge_new (); nm_connection_add_setting (connection, NM_SETTING (s_bridge)); } /* Grab the first name that doesn't exist in either our connections * or a device on the system. */ while (i < 500 && !nm_setting_bridge_get_interface_name (s_bridge)) { name = g_strdup_printf ("br%u", i); /* check interface names */ if (!nm_platform_link_exists (name)) { /* check existing bridge connections */ for (iter = existing_connections, found = FALSE; iter; iter = g_slist_next (iter)) { NMConnection *candidate = iter->data; tmp = nm_connection_get_setting_bridge (candidate); if (tmp && nm_connection_is_type (candidate, NM_SETTING_BRIDGE_SETTING_NAME)) { if (g_strcmp0 (nm_setting_bridge_get_interface_name (tmp), name) == 0) { found = TRUE; break; } } } if (!found) g_object_set (G_OBJECT (s_bridge), NM_SETTING_BRIDGE_INTERFACE_NAME, name, NULL); } g_free (name); i++; } return TRUE; }
NMConnection * nma_ethernet_dialog_get_connection (GtkWidget *dialog) { NMConnection *connection, *tmp_connection; WirelessSecurity *security; NMSetting *s_8021x, *s_con; g_return_val_if_fail (dialog != NULL, NULL); connection = g_object_get_data (G_OBJECT (dialog), "connection"); security = g_object_get_data (G_OBJECT (dialog), "security"); /* Here's a nice hack to work around the fact that ws_802_1x_fill_connection() * needs a wireless setting and a connection setting for various things. */ tmp_connection = nm_simple_connection_new (); /* Add the fake connection setting (mainly for the UUID for cert ignore checking) */ s_con = nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION); g_assert (s_con); nm_connection_add_setting (tmp_connection, NM_SETTING (g_object_ref (s_con))); /* And the fake wireless setting */ nm_connection_add_setting (tmp_connection, nm_setting_wireless_new ()); /* Fill up the 802.1x setting */ ws_802_1x_fill_connection (security, "wpa_eap_auth_combo", tmp_connection); /* Grab it and add it to our original connection */ s_8021x = nm_connection_get_setting (tmp_connection, NM_TYPE_SETTING_802_1X); nm_connection_add_setting (connection, NM_SETTING (g_object_ref (s_8021x))); /* Save new CA cert ignore values to GSettings */ eap_method_ca_cert_ignore_save (tmp_connection); /* Remove the 8021x setting to prevent the clearing of secrets when the * simple-connection is destroyed. */ nm_connection_remove_setting (tmp_connection, NM_TYPE_SETTING_802_1X); g_object_unref (tmp_connection); return connection; }
gboolean ifupdown_update_connection_from_if_block (NMConnection *connection, if_block *block, GError **error) { const char *type = NULL; char *idstr = NULL; char *uuid_base = NULL; char *uuid = NULL; NMSettingConnection *s_con; gboolean success = FALSE; s_con = nm_connection_get_setting_connection (connection); if(!s_con) { s_con = NM_SETTING_CONNECTION (nm_setting_connection_new()); g_assert (s_con); nm_connection_add_setting (connection, NM_SETTING (s_con)); } type = _ifupdownplugin_guess_connection_type (block); idstr = g_strconcat ("Ifupdown (", block->name, ")", NULL); uuid_base = idstr; uuid = nm_utils_uuid_generate_from_string (uuid_base, -1, NM_UTILS_UUID_TYPE_LEGACY, NULL); g_object_set (s_con, NM_SETTING_CONNECTION_TYPE, type, NM_SETTING_CONNECTION_INTERFACE_NAME, block->name, NM_SETTING_CONNECTION_ID, idstr, NM_SETTING_CONNECTION_UUID, uuid, NM_SETTING_CONNECTION_READ_ONLY, TRUE, NM_SETTING_CONNECTION_AUTOCONNECT, FALSE, NULL); g_free (uuid); nm_log_info (LOGD_SETTINGS, "update_connection_setting_from_if_block: name:%s, type:%s, id:%s, uuid: %s", block->name, type, idstr, nm_setting_connection_get_uuid (s_con)); if (!strcmp (NM_SETTING_WIRED_SETTING_NAME, type)) update_wired_setting_from_if_block (connection, block); else if (!strcmp (NM_SETTING_WIRELESS_SETTING_NAME, type)) { update_wireless_setting_from_if_block (connection, block); update_wireless_security_setting_from_if_block (connection, block); } if (ifparser_haskey(block, "inet6")) success = update_ip6_setting_from_if_block (connection, block, error); else success = update_ip4_setting_from_if_block (connection, block, error); if (success == TRUE) success = nm_connection_verify (connection, error); g_free (idstr); return success; }
static void nmt_page_team_constructed (GObject *object) { NmtPageTeam *team = NMT_PAGE_TEAM (object); NmtPageTeamPrivate *priv = NMT_PAGE_TEAM_GET_PRIVATE (team); NmtEditorSection *section; NmtNewtGrid *grid; NMSettingTeam *s_team; NmtNewtWidget *widget; NMConnection *conn; conn = nmt_editor_page_get_connection (NMT_EDITOR_PAGE (team)); s_team = nm_connection_get_setting_team (conn); if (!s_team) { nm_connection_add_setting (conn, nm_setting_team_new ()); s_team = nm_connection_get_setting_team (conn); } priv->s_team = s_team; section = nmt_editor_section_new (_("TEAM"), NULL, TRUE); widget = nmt_newt_grid_new (); nmt_editor_grid_append (nmt_editor_section_get_body (section), NULL, widget, NULL); grid = NMT_NEWT_GRID (widget); widget = nmt_newt_label_new (_("Slaves")); nmt_newt_grid_add (grid, widget, 0, 0); widget = nmt_slave_list_new (conn, team_connection_type_filter, team); g_signal_connect (widget, "notify::connections", G_CALLBACK (slaves_changed), team); nmt_newt_grid_add (grid, widget, 0, 1); nmt_newt_widget_set_padding (widget, 0, 0, 0, 1); priv->slaves = NMT_SLAVE_LIST (widget); slaves_changed (G_OBJECT (priv->slaves), NULL, team); widget = nmt_newt_label_new (_("JSON configuration")); nmt_newt_grid_add (grid, widget, 0, 2); widget = nmt_newt_textbox_new (NMT_NEWT_TEXTBOX_SCROLLABLE | NMT_NEWT_TEXTBOX_SET_BACKGROUND, 60); g_object_bind_property (s_team, NM_SETTING_TEAM_CONFIG, widget, "text", G_BINDING_SYNC_CREATE); nmt_newt_grid_add (grid, widget, 0, 3); nmt_newt_widget_set_padding (widget, 2, 0, 2, 1); widget = nmt_newt_button_new (_("Edit...")); g_signal_connect (widget, "clicked", G_CALLBACK (edit_clicked), team); nmt_newt_grid_add (grid, widget, 0, 4); nmt_editor_page_add_section (NMT_EDITOR_PAGE (team), section); G_OBJECT_CLASS (nmt_page_team_parent_class)->constructed (object); }
void bond_connection_new (GtkWindow *parent, const char *detail, NMRemoteSettings *settings, PageNewConnectionResultFunc result_func, gpointer user_data) { NMConnection *connection; int bond_num, max_bond_num, num; GSList *connections, *iter; NMConnection *conn2; NMSettingBond *s_bond; const char *iface; char *my_iface; connection = ce_page_new_connection (_("Bond connection %d"), NM_SETTING_BOND_SETTING_NAME, TRUE, settings, user_data); nm_connection_add_setting (connection, nm_setting_bond_new ()); /* Find an available interface name */ bond_num = max_bond_num = 0; connections = nm_remote_settings_list_connections (settings); for (iter = connections; iter; iter = iter->next) { conn2 = iter->data; if (!nm_connection_is_type (conn2, NM_SETTING_BOND_SETTING_NAME)) continue; s_bond = nm_connection_get_setting_bond (conn2); if (!s_bond) continue; iface = nm_setting_bond_get_interface_name (s_bond); if (!iface || strncmp (iface, "bond", 4) != 0 || !g_ascii_isdigit (iface[4])) continue; num = atoi (iface + 4); if (num > max_bond_num) max_bond_num = num; if (num == bond_num) bond_num = max_bond_num + 1; } g_slist_free (connections); my_iface = g_strdup_printf ("bond%d", bond_num); s_bond = nm_connection_get_setting_bond (connection); g_object_set (G_OBJECT (s_bond), NM_SETTING_BOND_INTERFACE_NAME, my_iface, NULL); g_free (my_iface); (*result_func) (connection, FALSE, NULL, user_data); }