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 real_check_connection_compatible (NMModem *modem, NMConnection *connection, GError **error) { NMSettingConnection *s_con; NMSettingGsm *s_gsm; s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); if (strcmp (nm_setting_connection_get_connection_type (s_con), NM_SETTING_GSM_SETTING_NAME)) { g_set_error (error, NM_GSM_ERROR, NM_GSM_ERROR_CONNECTION_NOT_GSM, "The connection was not a GSM connection."); return FALSE; } s_gsm = NM_SETTING_GSM (nm_connection_get_setting (connection, NM_TYPE_SETTING_GSM)); if (!s_gsm) { g_set_error (error, NM_GSM_ERROR, NM_GSM_ERROR_CONNECTION_INVALID, "The connection was not a valid GSM connection."); return FALSE; } return TRUE; }
static gboolean real_check_connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { NMSettingConnection *s_con; NMSettingOlpcMesh *s_mesh; s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); if (strcmp (nm_setting_connection_get_connection_type (s_con), NM_SETTING_OLPC_MESH_SETTING_NAME)) { g_set_error (error, NM_OLPC_MESH_ERROR, NM_OLPC_MESH_ERROR_CONNECTION_NOT_MESH, "The connection was not a Mesh connection."); return FALSE; } s_mesh = NM_SETTING_OLPC_MESH (nm_connection_get_setting (connection, NM_TYPE_SETTING_OLPC_MESH)); if (!s_mesh) { g_set_error (error, NM_OLPC_MESH_ERROR, NM_OLPC_MESH_ERROR_CONNECTION_INVALID, "The connection was not a valid Mesh connection."); return FALSE; } return TRUE; }
static void connection_removed (NMManager *manager, NMConnection *connection, NMConnectionScope scope, gpointer user_data) { NMSettingConnection *s_con; GPtrArray *list; int i; s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); if (!s_con) return; list = nm_manager_get_active_connections_by_connection (manager, connection); if (!list) return; for (i = 0; i < list->len; i++) { char *path = g_ptr_array_index (list, i); GError *error = NULL; if (!nm_manager_deactivate_connection (manager, path, NM_DEVICE_STATE_REASON_CONNECTION_REMOVED, &error)) { nm_log_warn (LOGD_DEVICE, "Connection '%s' disappeared, but error deactivating it: (%d) %s", nm_setting_connection_get_id (s_con), error->code, error->message); g_error_free (error); } g_free (path); } g_ptr_array_free (list, TRUE); }
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 check_ethernet_compatible (NMDeviceEthernet *device, NMConnection *connection, GError **error) { NMSettingConnection *s_con; NMSettingWired *s_wired; const char *connection_type; gboolean is_pppoe = FALSE; g_return_val_if_fail (error == NULL || *error == NULL, FALSE); 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); if ( strcmp (connection_type, NM_SETTING_WIRED_SETTING_NAME) && strcmp (connection_type, NM_SETTING_PPPOE_SETTING_NAME)) { g_set_error (error, 0, 0, "The connection was not a wired or PPPoE connection."); return FALSE; } if (!strcmp (connection_type, NM_SETTING_PPPOE_SETTING_NAME)) is_pppoe = TRUE; s_wired = (NMSettingWired *) nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRED); /* Wired setting is optional for PPPoE */ if (!is_pppoe && !s_wired) { g_set_error (error, 0, 0, "The connection was not a valid wired connection."); return FALSE; } if (s_wired) { const GByteArray *mac; const char *device_mac_str; struct ether_addr *device_mac; device_mac_str = nm_device_ethernet_get_hw_address (device); device_mac = ether_aton (device_mac_str); if (!device_mac) { g_set_error (error, 0, 0, "Invalid device MAC address."); return FALSE; } mac = nm_setting_wired_get_mac_address (s_wired); if (mac && memcmp (mac->data, device_mac->ether_addr_octet, ETH_ALEN)) { g_set_error (error, 0, 0, "The connection's MAC address did not match this device."); return FALSE; } } // FIXME: check bitrate against device capabilities return TRUE; }
static void dialog_set_network_name (NMConnection *connection, GtkEntry *entry) { NMSettingConnection *setting; setting = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); gtk_widget_set_sensitive (GTK_WIDGET (entry), FALSE); gtk_entry_set_text (entry, nm_setting_connection_get_id (setting)); }
static gboolean real_check_connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE (device); NMSettingConnection *s_con; NMSettingBluetooth *s_bt; const GByteArray *array; char *str; int addr_match = FALSE; guint32 bt_type; s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); if (strcmp (nm_setting_connection_get_connection_type (s_con), NM_SETTING_BLUETOOTH_SETTING_NAME)) { g_set_error (error, NM_BT_ERROR, NM_BT_ERROR_CONNECTION_NOT_BT, "The connection was not a Bluetooth connection."); return FALSE; } s_bt = NM_SETTING_BLUETOOTH (nm_connection_get_setting (connection, NM_TYPE_SETTING_BLUETOOTH)); if (!s_bt) { g_set_error (error, NM_BT_ERROR, NM_BT_ERROR_CONNECTION_INVALID, "The connection was not a valid Bluetooth connection."); return FALSE; } array = nm_setting_bluetooth_get_bdaddr (s_bt); if (!array || (array->len != ETH_ALEN)) { g_set_error (error, NM_BT_ERROR, NM_BT_ERROR_CONNECTION_INVALID, "The connection did not contain a valid Bluetooth address."); return FALSE; } bt_type = get_connection_bt_type (connection); if (!(bt_type & priv->capabilities)) { g_set_error (error, NM_BT_ERROR, NM_BT_ERROR_CONNECTION_INCOMPATIBLE, "The connection was not compatible with the device's capabilities."); return FALSE; } str = g_strdup_printf ("%02X:%02X:%02X:%02X:%02X:%02X", array->data[0], array->data[1], array->data[2], array->data[3], array->data[4], array->data[5]); addr_match = !strcmp (priv->bdaddr, str); g_free (str); return addr_match; }
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; }
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 GtkWidget * create_info_label_security (NMConnection *connection) { NMSettingConnection *s_con; char *label = NULL; GtkWidget *w; const char *connection_type; 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); if (!strcmp (connection_type, NM_SETTING_WIRELESS_SETTING_NAME)) { NMSettingWireless *s_wireless; NMSettingWirelessSecurity *s_wireless_sec; NMSetting8021x *s_8021x; const char *security; s_wireless = NM_SETTING_WIRELESS (nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS)); s_wireless_sec = (NMSettingWirelessSecurity *) nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS_SECURITY); s_8021x = (NMSetting8021x *) nm_connection_get_setting (connection, NM_TYPE_SETTING_802_1X); security = s_wireless ? nm_setting_wireless_get_security (s_wireless) : NULL; if (security && !strcmp (security, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME) && s_wireless_sec) { const char *key_mgmt = nm_setting_wireless_security_get_key_mgmt (s_wireless_sec); if (!strcmp (key_mgmt, "none")) label = g_strdup (_("WEP")); else if (!strcmp (key_mgmt, "wpa-none")) label = g_strdup (_("WPA/WPA2")); else if (!strcmp (key_mgmt, "wpa-psk")) label = g_strdup (_("WPA/WPA2")); else label = get_eap_label (s_wireless_sec, s_8021x); } else { label = g_strdup (_("None")); } } else if (!strcmp (connection_type, NM_SETTING_WIRED_SETTING_NAME)) { NMSetting8021x *s_8021x; s_8021x = (NMSetting8021x *) nm_connection_get_setting (connection, NM_TYPE_SETTING_802_1X); if (s_8021x) label = get_eap_label (NULL, s_8021x); else label = g_strdup (_("None")); } w = create_info_label (label ? label : _("Unknown"), TRUE); g_free (label); return w; }
GtkWidget * applet_mobile_password_dialog_new (NMDevice *device, NMConnection *connection, GtkEntry **out_secret_entry) { GtkDialog *dialog; GtkWidget *w; GtkBox *box; char *dev_str; NMSettingConnection *s_con; char *tmp; const char *id; dialog = GTK_DIALOG (gtk_dialog_new ()); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); gtk_window_set_title (GTK_WINDOW (dialog), _("Mobile broadband network password")); w = gtk_dialog_add_button (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT); w = gtk_dialog_add_button (dialog, GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default (GTK_WINDOW (dialog), w); s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); id = nm_setting_connection_get_id (s_con); g_assert (id); tmp = g_strdup_printf (_("A password is required to connect to '%s'."), id); w = gtk_label_new (tmp); g_free (tmp); gtk_box_pack_start (GTK_BOX (dialog->vbox), w, TRUE, TRUE, 0); dev_str = g_strdup_printf ("<b>%s</b>", utils_get_device_description (device)); w = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (w), dev_str); g_free (dev_str); gtk_box_pack_start (GTK_BOX (dialog->vbox), w, TRUE, TRUE, 0); w = gtk_alignment_new (0.5, 0.5, 0, 1.0); gtk_box_pack_start (GTK_BOX (dialog->vbox), w, TRUE, TRUE, 0); box = GTK_BOX (gtk_hbox_new (FALSE, 6)); gtk_container_set_border_width (GTK_CONTAINER (box), 6); gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (box)); gtk_box_pack_start (box, gtk_label_new (_("Password:")), FALSE, FALSE, 0); w = gtk_entry_new (); *out_secret_entry = GTK_ENTRY (w); gtk_entry_set_activates_default (GTK_ENTRY (w), TRUE); gtk_box_pack_start (box, w, FALSE, FALSE, 0); gtk_widget_show_all (dialog->vbox); return GTK_WIDGET (dialog); }
static gboolean check_wifi_compatible (NMDeviceWifi *device, NMConnection *connection, GError **error) { NMSettingConnection *s_con; NMSettingWireless *s_wireless; g_return_val_if_fail (error == NULL || *error == NULL, FALSE); s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); if (strcmp (nm_setting_connection_get_connection_type (s_con), NM_SETTING_WIRELESS_SETTING_NAME)) { g_set_error (error, 0, 0, "The connection was not a WiFi connection."); return FALSE; } s_wireless = NM_SETTING_WIRELESS (nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS)); if (!s_wireless) { g_set_error (error, 0, 0, "The connection was not a valid WiFi connection."); return FALSE; } if (s_wireless) { const GByteArray *mac; const char *device_mac_str; struct ether_addr *device_mac; device_mac_str = nm_device_wifi_get_hw_address (device); device_mac = ether_aton (device_mac_str); if (!device_mac) { g_set_error (error, 0, 0, "Invalid device MAC address."); return FALSE; } mac = nm_setting_wireless_get_mac_address (s_wireless); if (mac && memcmp (mac->data, device_mac->ether_addr_octet, ETH_ALEN)) { g_set_error (error, 0, 0, "The connection's MAC address did not match this device."); return FALSE; } } // FIXME: check channel/freq/band against bands the hardware supports // FIXME: check encryption against device capabilities // FIXME: check bitrate against device capabilities return TRUE; }
static GtkWidget * fill_password (GladeXML *xml, const char *widget_name, NMConnection *connection, const char *password_type) { GtkWidget *widget = NULL; gchar *password = NULL; widget = glade_xml_get_widget (xml, widget_name); g_assert (widget); if (!connection) return widget; password = NULL; if (nm_connection_get_scope (connection) == NM_CONNECTION_SCOPE_SYSTEM) { NMSettingVPN *s_vpn; s_vpn = (NMSettingVPN *) nm_connection_get_setting (connection, NM_TYPE_SETTING_VPN); if (s_vpn) { const gchar *tmp = NULL; tmp = nm_setting_vpn_get_secret (s_vpn, password_type); if (tmp) password = gnome_keyring_memory_strdup (tmp); } } else { NMSettingConnection *s_con = NULL; gboolean unused; const char *uuid; s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); uuid = nm_setting_connection_get_uuid (s_con); password = keyring_helpers_lookup_secret (uuid, password_type, &unused); } if (password) { gtk_entry_set_text (GTK_ENTRY (widget), password); gnome_keyring_memory_free (password); } return widget; }
static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { NMSettingConnection *setting = NM_SETTING_CONNECTION (object); NMSettingConnectionPrivate *priv = NM_SETTING_CONNECTION_GET_PRIVATE (setting); switch (prop_id) { case PROP_ID: g_value_set_string (value, nm_setting_connection_get_id (setting)); break; case PROP_UUID: g_value_set_string (value, nm_setting_connection_get_uuid (setting)); break; case PROP_TYPE: g_value_set_string (value, nm_setting_connection_get_connection_type (setting)); break; case PROP_PERMISSIONS: g_value_take_boxed (value, perm_permlist_to_stringlist (priv->permissions)); break; case PROP_AUTOCONNECT: g_value_set_boolean (value, nm_setting_connection_get_autoconnect (setting)); break; case PROP_TIMESTAMP: g_value_set_uint64 (value, nm_setting_connection_get_timestamp (setting)); break; case PROP_READ_ONLY: g_value_set_boolean (value, nm_setting_connection_get_read_only (setting)); break; case PROP_ZONE: g_value_set_string (value, nm_setting_connection_get_zone (setting)); break; case PROP_MASTER: g_value_set_string (value, nm_setting_connection_get_master (setting)); break; case PROP_SLAVE_TYPE: g_value_set_string (value, nm_setting_connection_get_slave_type (setting)); break; case PROP_SECONDARIES: g_value_set_boxed (value, priv->secondaries); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
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 GtkWidget * create_info_notebook_label (NMConnection *connection, gboolean is_default) { GtkWidget *label; NMSettingConnection *s_con; GString *str; s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); str = g_string_new (nm_setting_connection_get_id (s_con)); if (is_default) str = g_string_append (str, " (default)"); label = gtk_label_new (str->str); g_string_free (str, TRUE); return label; }
static gboolean extract_details_from_connection (NMConnection *connection, const char **username, const char **password, GError **error) { NMSettingConnection *s_con; NMSetting *setting; const char *connection_type; g_return_val_if_fail (connection != NULL, FALSE); g_return_val_if_fail (username != NULL, FALSE); g_return_val_if_fail (password != NULL, FALSE); 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); setting = nm_connection_get_setting_by_name (connection, connection_type); if (!setting) { g_set_error_literal (error, NM_PPP_MANAGER_ERROR, NM_PPP_MANAGER_ERROR_UNKOWN, "Missing type-specific setting; no secrets could be found."); return FALSE; } /* FIXME: push this down to the settings and keep PPP manager generic */ if (NM_IS_SETTING_PPPOE (setting)) { *username = nm_setting_pppoe_get_username (NM_SETTING_PPPOE (setting)); *password = nm_setting_pppoe_get_password (NM_SETTING_PPPOE (setting)); } else if (NM_IS_SETTING_GSM (setting)) { *username = nm_setting_gsm_get_username (NM_SETTING_GSM (setting)); *password = nm_setting_gsm_get_password (NM_SETTING_GSM (setting)); } else if (NM_IS_SETTING_CDMA (setting)) { *username = nm_setting_cdma_get_username (NM_SETTING_CDMA (setting)); *password = nm_setting_cdma_get_password (NM_SETTING_CDMA (setting)); } return TRUE; }
static gboolean real_check_connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { NMDeviceWimaxPrivate *priv = NM_DEVICE_WIMAX_GET_PRIVATE (device); NMSettingConnection *s_con; NMSettingWimax *s_wimax; const char *connection_type; const GByteArray *mac; 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); if (strcmp (connection_type, NM_SETTING_WIMAX_SETTING_NAME)) { g_set_error (error, NM_WIMAX_ERROR, NM_WIMAX_ERROR_CONNECTION_NOT_WIMAX, "The connection was not a WiMAX connection."); return FALSE; } s_wimax = (NMSettingWimax *) nm_connection_get_setting (connection, NM_TYPE_SETTING_WIMAX); if (!s_wimax) { g_set_error (error, NM_WIMAX_ERROR, NM_WIMAX_ERROR_CONNECTION_INVALID, "The connection was not a valid WiMAX connection."); return FALSE; } mac = nm_setting_wimax_get_mac_address (s_wimax); if (mac && memcmp (mac->data, &(priv->hw_addr.ether_addr_octet), ETH_ALEN)) { g_set_error (error, NM_WIMAX_ERROR, NM_WIMAX_ERROR_CONNECTION_INCOMPATIBLE, "The connection's MAC address did not match this device."); return FALSE; } return TRUE; }
static void bridge_get_icon (NMDevice *device, NMDeviceState state, NMConnection *connection, GdkPixbuf **out_pixbuf, const char **out_icon_name, char **tip, NMApplet *applet) { NMSettingConnection *s_con; const char *id; id = nm_device_get_iface (NM_DEVICE (device)); if (connection) { s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); id = nm_setting_connection_get_id (s_con); } switch (state) { case NM_DEVICE_STATE_PREPARE: *tip = g_strdup_printf (_("Preparing bridge connection '%s'..."), id); break; case NM_DEVICE_STATE_CONFIG: *tip = g_strdup_printf (_("Configuring bridge connection '%s'..."), id); break; case NM_DEVICE_STATE_NEED_AUTH: *tip = g_strdup_printf (_("User authentication required for bridge connection '%s'..."), id); break; case NM_DEVICE_STATE_IP_CONFIG: *tip = g_strdup_printf (_("Requesting address for '%s'..."), id); break; case NM_DEVICE_STATE_ACTIVATED: *out_icon_name = "nm-device-wired"; *tip = g_strdup_printf (_("Bridge connection '%s' active"), id); break; default: break; } }
static gboolean wimax_new_auto_connection (NMDevice *device, gpointer dclass_data, AppletNewAutoConnectionCallback callback, gpointer callback_data) { WimaxMenuItemInfo *info = dclass_data; NMConnection *connection; NMSettingWimax *s_wimax = NULL; NMSettingConnection *s_con; char *uuid; const char *nsp_name; nsp_name = nm_wimax_nsp_get_name (info->nsp); connection = nm_connection_new (); s_wimax = NM_SETTING_WIMAX (nm_setting_wimax_new ()); g_object_set (s_wimax, NM_SETTING_WIMAX_NETWORK_NAME, nsp_name, NULL); nm_connection_add_setting (connection, NM_SETTING (s_wimax)); s_con = NM_SETTING_CONNECTION (nm_setting_connection_new ()); uuid = nm_utils_uuid_generate (); g_object_set (s_con, NM_SETTING_CONNECTION_ID, nsp_name, NM_SETTING_CONNECTION_TYPE, NM_SETTING_WIMAX_SETTING_NAME, NM_SETTING_CONNECTION_AUTOCONNECT, TRUE, NM_SETTING_CONNECTION_UUID, uuid, NULL); g_free (uuid); nm_connection_add_setting (connection, NM_SETTING (s_con)); (*callback) (connection, TRUE, FALSE, callback_data); return TRUE; }
static gboolean check_bt_compatible (NMDeviceBt *device, NMConnection *connection, GError **error) { NMSettingConnection *s_con; NMSettingBluetooth *s_bt; const GByteArray *array; char *str; const char *device_hw_str; int addr_match = FALSE; const char *bt_type_str; guint32 bt_type, bt_capab; g_return_val_if_fail (error == NULL || *error == NULL, FALSE); s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); if (strcmp (nm_setting_connection_get_connection_type (s_con), NM_SETTING_BLUETOOTH_SETTING_NAME)) { g_set_error (error, 0, 0, "The connection was not a Bluetooth connection."); return FALSE; } s_bt = NM_SETTING_BLUETOOTH (nm_connection_get_setting (connection, NM_TYPE_SETTING_BLUETOOTH)); if (!s_bt) { g_set_error (error, 0, 0, "The connection was not a valid Bluetooth connection."); return FALSE; } array = nm_setting_bluetooth_get_bdaddr (s_bt); if (!array || (array->len != ETH_ALEN)) { g_set_error (error, 0, 0, "The connection did not contain a valid Bluetooth address."); return FALSE; } bt_type_str = nm_setting_bluetooth_get_connection_type (s_bt); g_assert (bt_type_str); bt_type = NM_BT_CAPABILITY_NONE; if (!strcmp (bt_type_str, NM_SETTING_BLUETOOTH_TYPE_DUN)) bt_type = NM_BT_CAPABILITY_DUN; else if (!strcmp (bt_type_str, NM_SETTING_BLUETOOTH_TYPE_PANU)) bt_type = NM_BT_CAPABILITY_NAP; bt_capab = nm_device_bt_get_capabilities (device); if (!(bt_type & bt_capab)) { g_set_error (error, 0, 0, "The connection was not compatible with the device's capabilities."); return FALSE; } device_hw_str = nm_device_bt_get_hw_address (device); str = g_strdup_printf ("%02X:%02X:%02X:%02X:%02X:%02X", array->data[0], array->data[1], array->data[2], array->data[3], array->data[4], array->data[5]); addr_match = !strcmp (device_hw_str, str); g_free (str); return addr_match; }
static NMConnection * import (NMVpnPluginUiInterface *iface, const char *path, GError **error) { NMConnection *connection; NMSettingConnection *s_con; NMSettingVPN *s_vpn; NMSettingIP4Config *s_ip4; GKeyFile *keyfile; GKeyFileFlags flags; const char *buf; keyfile = g_key_file_new (); flags = G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS; if (!g_key_file_load_from_file (keyfile, path, flags, error)) { g_set_error (error, NM_IODINE_IMPORT_EXPORT_ERROR, NM_IODINE_IMPORT_EXPORT_ERROR_NOT_IODINE, "does not look like a %s VPN connection (parse failed)", IODINE_PLUGIN_NAME); return NULL; } connection = nm_connection_new (); s_con = NM_SETTING_CONNECTION (nm_setting_connection_new ()); nm_connection_add_setting (connection, NM_SETTING (s_con)); s_vpn = NM_SETTING_VPN (nm_setting_vpn_new ()); g_object_set (s_vpn, NM_SETTING_VPN_SERVICE_TYPE, NM_DBUS_SERVICE_IODINE, NULL); nm_connection_add_setting (connection, NM_SETTING (s_vpn)); s_ip4 = NM_SETTING_IP4_CONFIG (nm_setting_ip4_config_new ()); nm_connection_add_setting (connection, NM_SETTING (s_ip4)); /* top level domain */ buf = g_key_file_get_string (keyfile, "iodine", "topdomain", NULL); if (buf) { nm_setting_vpn_add_data_item (s_vpn, NM_IODINE_KEY_TOPDOMAIN, buf); } else { g_set_error (error, NM_IODINE_IMPORT_EXPORT_ERROR, NM_IODINE_IMPORT_EXPORT_ERROR_NOT_IODINE, "does not look like a %s VPN connection " "(no top level domain)", IODINE_PLUGIN_NAME); g_object_unref (connection); return NULL; } /* Optional Settings */ /* Description */ buf = g_key_file_get_string (keyfile, "iodine", "Description", NULL); if (buf) g_object_set (s_con, NM_SETTING_CONNECTION_ID, buf, NULL); /* Name server */ buf = g_key_file_get_string (keyfile, "iodine", "Nameserver", NULL); if (buf) nm_setting_vpn_add_data_item (s_vpn, NM_IODINE_KEY_NAMESERVER, buf); /* Fragment size */ buf = g_key_file_get_string (keyfile, "iodine", "Fragsize", NULL); if (buf) nm_setting_vpn_add_data_item (s_vpn, NM_IODINE_KEY_FRAGSIZE, "yes"); return connection; }
static gboolean auto_activate_device (gpointer user_data) { ActivateData *data = (ActivateData *) user_data; NMPolicy *policy; NMConnection *best_connection; char *specific_object = NULL; GSList *connections, *iter; g_assert (data); policy = data->policy; // FIXME: if a device is already activating (or activated) with a connection // but another connection now overrides the current one for that device, // deactivate the device and activate the new connection instead of just // bailing if the device is already active if (nm_device_get_act_request (data->device)) goto out; /* System connections first, then user connections */ connections = nm_manager_get_connections (policy->manager, NM_CONNECTION_SCOPE_SYSTEM); if (nm_manager_auto_user_connections_allowed (policy->manager)) connections = g_slist_concat (connections, nm_manager_get_connections (policy->manager, NM_CONNECTION_SCOPE_USER)); /* Remove connections that are in the invalid list. */ iter = connections; while (iter) { NMConnection *iter_connection = NM_CONNECTION (iter->data); GSList *next = g_slist_next (iter); if (g_object_get_data (G_OBJECT (iter_connection), INVALID_TAG)) { connections = g_slist_remove_link (connections, iter); g_object_unref (iter_connection); g_slist_free (iter); } iter = next; } best_connection = nm_device_get_best_auto_connection (data->device, connections, &specific_object); if (best_connection) { GError *error = NULL; if (!nm_manager_activate_connection (policy->manager, best_connection, specific_object, nm_device_get_path (data->device), FALSE, &error)) { NMSettingConnection *s_con; s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (best_connection, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); nm_log_info (LOGD_DEVICE, "Connection '%s' auto-activation failed: (%d) %s", nm_setting_connection_get_id (s_con), error->code, error->message); g_error_free (error); } } g_slist_foreach (connections, (GFunc) g_object_unref, NULL); g_slist_free (connections); out: /* Remove this call's handler ID */ policy->pending_activation_checks = g_slist_remove (policy->pending_activation_checks, data); g_object_unref (data->device); g_free (data); return FALSE; }
static gboolean connection_combo_init (NMAWirelessDialog *self, NMConnection *connection) { NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self); GtkListStore *store; GtkTreeIter tree_iter; GtkWidget *widget; GtkCellRenderer *renderer; g_return_val_if_fail (priv->connection == NULL, FALSE); /* Clear any old model */ model_free (priv->connection_model, C_NAME_COLUMN); /* New model */ store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_OBJECT, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN); priv->connection_model = GTK_TREE_MODEL (store); if (connection) { NMSettingConnection *s_con; const char *id; s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); id = nm_setting_connection_get_id (s_con); g_assert (id); gtk_list_store_append (store, &tree_iter); gtk_list_store_set (store, &tree_iter, C_NAME_COLUMN, id, C_CON_COLUMN, connection, -1); priv->connection = g_object_ref (connection); } widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "connection_combo")); gtk_cell_layout_clear (GTK_CELL_LAYOUT (widget)); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (widget), renderer, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (widget), renderer, "text", C_NAME_COLUMN); gtk_combo_box_set_wrap_width (GTK_COMBO_BOX (widget), 1); gtk_combo_box_set_model (GTK_COMBO_BOX (widget), priv->connection_model); gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (widget), connection_combo_separator_cb, NULL, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (connection_combo_changed), self); gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (priv->builder, "connection_label"))); gtk_widget_hide (widget); return TRUE; }
static void fill_connection (EAPMethod *parent, NMConnection *connection) { EAPMethodTLS *method = (EAPMethodTLS *) parent; NMSetting8021xCKFormat format = NM_SETTING_802_1X_CK_FORMAT_UNKNOWN; NMSetting8021x *s_8021x; NMSettingConnection *s_con; GtkWidget *widget; char *ca_filename, *pk_filename, *cc_filename; const char *password = NULL; GError *error = NULL; s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); s_8021x = NM_SETTING_802_1X (nm_connection_get_setting (connection, NM_TYPE_SETTING_802_1X)); g_assert (s_8021x); if (method->phase2) g_object_set (s_8021x, NM_SETTING_802_1X_PHASE2_AUTH, "tls", NULL); else nm_setting_802_1x_add_eap_method (s_8021x, "tls"); widget = glade_xml_get_widget (parent->xml, "eap_tls_identity_entry"); g_assert (widget); g_object_set (s_8021x, NM_SETTING_802_1X_IDENTITY, gtk_entry_get_text (GTK_ENTRY (widget)), NULL); /* TLS private key */ widget = glade_xml_get_widget (parent->xml, "eap_tls_private_key_password_entry"); g_assert (widget); password = gtk_entry_get_text (GTK_ENTRY (widget)); g_assert (password); widget = glade_xml_get_widget (parent->xml, "eap_tls_private_key_button"); g_assert (widget); pk_filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (widget)); g_assert (pk_filename); if (method->phase2) { if (!nm_setting_802_1x_set_phase2_private_key (s_8021x, pk_filename, password, NM_SETTING_802_1X_CK_SCHEME_PATH, &format, &error)) { g_warning ("Couldn't read phase2 private key '%s': %s", pk_filename, error ? error->message : "(unknown)"); g_clear_error (&error); } } else { if (!nm_setting_802_1x_set_private_key (s_8021x, pk_filename, password, NM_SETTING_802_1X_CK_SCHEME_PATH, &format, &error)) { g_warning ("Couldn't read private key '%s': %s", pk_filename, error ? error->message : "(unknown)"); g_clear_error (&error); } } g_free (pk_filename); /* TLS client certificate */ if (format != NM_SETTING_802_1X_CK_FORMAT_PKCS12) { /* If the key is pkcs#12 nm_setting_802_1x_set_private_key() already * set the client certificate for us. */ widget = glade_xml_get_widget (parent->xml, "eap_tls_user_cert_button"); g_assert (widget); cc_filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (widget)); g_assert (cc_filename); format = NM_SETTING_802_1X_CK_FORMAT_UNKNOWN; if (method->phase2) { if (!nm_setting_802_1x_set_phase2_client_cert (s_8021x, cc_filename, NM_SETTING_802_1X_CK_SCHEME_PATH, &format, &error)) { g_warning ("Couldn't read phase2 client certificate '%s': %s", cc_filename, error ? error->message : "(unknown)"); g_clear_error (&error); } } else { if (!nm_setting_802_1x_set_client_cert (s_8021x, cc_filename, NM_SETTING_802_1X_CK_SCHEME_PATH, &format, &error)) { g_warning ("Couldn't read client certificate '%s': %s", cc_filename, error ? error->message : "(unknown)"); g_clear_error (&error); } } g_free (cc_filename); } /* TLS CA certificate */ widget = glade_xml_get_widget (parent->xml, "eap_tls_ca_cert_button"); g_assert (widget); ca_filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (widget)); format = NM_SETTING_802_1X_CK_FORMAT_UNKNOWN; if (method->phase2) { if (!nm_setting_802_1x_set_phase2_ca_cert (s_8021x, ca_filename, NM_SETTING_802_1X_CK_SCHEME_PATH, &format, &error)) { g_warning ("Couldn't read phase2 CA certificate '%s': %s", ca_filename, error ? error->message : "(unknown)"); g_clear_error (&error); } } else { if (!nm_setting_802_1x_set_ca_cert (s_8021x, ca_filename, NM_SETTING_802_1X_CK_SCHEME_PATH, &format, &error)) { g_warning ("Couldn't read CA certificate '%s': %s", ca_filename, error ? error->message : "(unknown)"); g_clear_error (&error); } } nm_gconf_set_ignore_ca_cert (nm_setting_connection_get_uuid (s_con), method->phase2, eap_method_get_ignore_ca_cert (parent)); }
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 NMConnection * import (NMVpnPluginUiInterface *iface, const char *path, GError **error) { NMConnection *connection; NMSettingConnection *s_con; NMSettingVPN *s_vpn; NMSettingIP4Config *s_ip4; GKeyFile *keyfile; GKeyFileFlags flags; const char *buf; gboolean bval; keyfile = g_key_file_new (); flags = G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS; if (!g_key_file_load_from_file (keyfile, path, flags, NULL)) { g_set_error (error, NM_OPENCONNECT_IMPORT_EXPORT_ERROR, NM_OPENCONNECT_IMPORT_EXPORT_ERROR_NOT_OPENCONNECT, "does not look like a %s VPN connection (parse failed)", OPENCONNECT_PLUGIN_NAME); return NULL; } connection = nm_connection_new (); s_con = NM_SETTING_CONNECTION (nm_setting_connection_new ()); nm_connection_add_setting (connection, NM_SETTING (s_con)); s_vpn = NM_SETTING_VPN (nm_setting_vpn_new ()); g_object_set (s_vpn, NM_SETTING_VPN_SERVICE_TYPE, NM_DBUS_SERVICE_OPENCONNECT, NULL); nm_connection_add_setting (connection, NM_SETTING (s_vpn)); s_ip4 = NM_SETTING_IP4_CONFIG (nm_setting_ip4_config_new ()); nm_connection_add_setting (connection, NM_SETTING (s_ip4)); /* Host */ buf = g_key_file_get_string (keyfile, "openconnect", "Host", NULL); if (buf) { nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_GATEWAY, buf); } else { g_set_error (error, NM_OPENCONNECT_IMPORT_EXPORT_ERROR, NM_OPENCONNECT_IMPORT_EXPORT_ERROR_BAD_DATA, "does not look like a %s VPN connection (no Host)", OPENCONNECT_PLUGIN_NAME); g_object_unref (connection); return NULL; } /* Optional Settings */ /* Description */ buf = g_key_file_get_string (keyfile, "openconnect", "Description", NULL); if (buf) g_object_set (s_con, NM_SETTING_CONNECTION_ID, buf, NULL); /* CA Certificate */ buf = g_key_file_get_string (keyfile, "openconnect", "CACert", NULL); if (buf) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_CACERT, buf); /* Proxy */ buf = g_key_file_get_string (keyfile, "openconnect", "Proxy", NULL); if (buf) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_PROXY, buf); /* Cisco Secure Desktop */ bval = g_key_file_get_boolean (keyfile, "openconnect", "CSDEnable", NULL); if (bval) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_CSD_ENABLE, "yes"); /* Cisco Secure Desktop wrapper */ buf = g_key_file_get_string (keyfile, "openconnect", "CSDWrapper", NULL); if (buf) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_CSD_WRAPPER, buf); /* User Certificate */ buf = g_key_file_get_string (keyfile, "openconnect", "UserCertificate", NULL); if (buf) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_USERCERT, buf); /* Private Key */ buf = g_key_file_get_string (keyfile, "openconnect", "PrivateKey", NULL); if (buf) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_PRIVKEY, buf); /* FSID */ bval = g_key_file_get_boolean (keyfile, "openconnect", "FSID", NULL); if (bval) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_PEM_PASSPHRASE_FSID, "yes"); /* Soft token mode */ buf = g_key_file_get_string (keyfile, "openconnect", "StokenSource", NULL); if (buf) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_TOKEN_MODE, buf); /* Soft token secret */ buf = g_key_file_get_string (keyfile, "openconnect", "StokenString", NULL); if (buf) nm_setting_vpn_add_secret (s_vpn, NM_OPENCONNECT_KEY_TOKEN_SECRET, buf); return connection; }
GtkWidget * ws_802_1x_auth_combo_init (WirelessSecurity *sec, const char *combo_name, GCallback auth_combo_changed_cb, NMConnection *connection) { GtkWidget *combo; GtkListStore *auth_model; GtkTreeIter iter; EAPMethodTLS *em_tls; EAPMethodLEAP *em_leap; EAPMethodTTLS *em_ttls; EAPMethodPEAP *em_peap; const char *default_method = NULL; int active = -1, item = 0; gboolean wired = FALSE; /* Grab the default EAP method out of the security object */ if (connection) { NMSettingConnection *s_con; NMSetting8021x *s_8021x; s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); if (!strcmp (nm_setting_connection_get_connection_type (s_con), NM_SETTING_WIRED_SETTING_NAME)) wired = TRUE; s_8021x = (NMSetting8021x *) nm_connection_get_setting (connection, NM_TYPE_SETTING_802_1X); if (s_8021x && nm_setting_802_1x_get_num_eap_methods (s_8021x)) default_method = nm_setting_802_1x_get_eap_method (s_8021x, 0); } auth_model = gtk_list_store_new (2, G_TYPE_STRING, eap_method_get_g_type ()); em_tls = eap_method_tls_new (sec, connection, FALSE); gtk_list_store_append (auth_model, &iter); gtk_list_store_set (auth_model, &iter, AUTH_NAME_COLUMN, _("TLS"), AUTH_METHOD_COLUMN, em_tls, -1); eap_method_unref (EAP_METHOD (em_tls)); if (default_method && (active < 0) && !strcmp (default_method, "tls")) active = item; item++; if (!wired) { em_leap = eap_method_leap_new (sec, connection); gtk_list_store_append (auth_model, &iter); gtk_list_store_set (auth_model, &iter, AUTH_NAME_COLUMN, _("LEAP"), AUTH_METHOD_COLUMN, em_leap, -1); eap_method_unref (EAP_METHOD (em_leap)); if (default_method && (active < 0) && !strcmp (default_method, "leap")) active = item; item++; } em_ttls = eap_method_ttls_new (sec, connection); gtk_list_store_append (auth_model, &iter); gtk_list_store_set (auth_model, &iter, AUTH_NAME_COLUMN, _("Tunneled TLS"), AUTH_METHOD_COLUMN, em_ttls, -1); eap_method_unref (EAP_METHOD (em_ttls)); if (default_method && (active < 0) && !strcmp (default_method, "ttls")) active = item; item++; em_peap = eap_method_peap_new (sec, connection); gtk_list_store_append (auth_model, &iter); gtk_list_store_set (auth_model, &iter, AUTH_NAME_COLUMN, _("Protected EAP (PEAP)"), AUTH_METHOD_COLUMN, em_peap, -1); eap_method_unref (EAP_METHOD (em_peap)); if (default_method && (active < 0) && !strcmp (default_method, "peap")) active = item; item++; combo = GTK_WIDGET (gtk_builder_get_object (sec->builder, combo_name)); g_assert (combo); gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (auth_model)); g_object_unref (G_OBJECT (auth_model)); gtk_combo_box_set_active (GTK_COMBO_BOX (combo), active < 0 ? 0 : (guint32) active); g_signal_connect (G_OBJECT (combo), "changed", auth_combo_changed_cb, sec); return combo; }