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);
}
}
/* Print details of connection */
static void
show_connection (NMConnection *connection)
{
NMSettingConnection *s_con;
guint64 timestamp;
char *timestamp_str;
char timestamp_real_str[64];
const char *val1, *val2, *val3, *val3a, *val4, *val5;
s_con = nm_connection_get_setting_connection (connection);
if (s_con) {
/* Get various info from NMSettingConnection and show it */
timestamp = nm_setting_connection_get_timestamp (s_con);
timestamp_str = g_strdup_printf ("%" G_GUINT64_FORMAT, timestamp);
strftime (timestamp_real_str, sizeof (timestamp_real_str), "%c", localtime ((time_t *) ×tamp));
val1 = nm_setting_connection_get_id (s_con);
val2 = nm_setting_connection_get_uuid (s_con);
val3 = nm_setting_connection_get_connection_type (s_con);
val3a = nm_setting_connection_get_interface_name (s_con);
val4 = nm_connection_get_path (connection);
val5 = timestamp ? timestamp_real_str : "never";
printf ("%-25s | %s | %-15s | %10s | %-43s | %s\n", val1, val2, val3, val3a, val4, val5);
g_free (timestamp_str);
}
}
static void
test_non_utf8_import (NMVpnPluginUiInterface *plugin, const char *dir)
{
NMConnection *connection;
NMSettingConnection *s_con;
NMSettingVPN *s_vpn;
const char *expected_id = "Att äta en ko";
const char *charset = NULL;
/* Change charset to ISO-8859-15 to match iso885915.pcf */
g_get_charset (&charset);
setlocale (LC_ALL, "de_DE@euro");
connection = get_basic_connection ("non-utf8-import", plugin, dir, "iso885915.pcf");
setlocale (LC_ALL, charset);
ASSERT (connection != NULL, "non-utf8-import", "failed to import connection");
/* Connection setting */
s_con = nm_connection_get_setting_connection (connection);
ASSERT (s_con != NULL,
"non-utf8-import", "missing 'connection' setting");
ASSERT (strcmp (nm_setting_connection_get_id (s_con), expected_id) == 0,
"non-utf8-import", "unexpected connection ID");
ASSERT (nm_setting_connection_get_uuid (s_con) == NULL,
"non-utf8-import", "unexpected valid UUID");
/* VPN setting */
s_vpn = nm_connection_get_setting_vpn (connection);
ASSERT (s_vpn != NULL,
"non-utf8-import", "missing 'vpn' setting");
g_object_unref (connection);
}
static void
device_state_changed (NMDevice *device,
NMDeviceState new_state,
NMDeviceState old_state,
NMDeviceStateReason reason,
NMApplet *applet)
{
NMConnection *connection;
NMSettingConnection *s_con = NULL;
const char *str = NULL;
if (new_state != NM_DEVICE_STATE_ACTIVATED)
return;
connection = applet_find_active_connection_for_device (device, applet, NULL);
if (connection) {
s_con = nm_connection_get_setting_connection (connection);
str = s_con ? nm_setting_connection_get_id (s_con) : NULL;
}
applet_do_notify_with_pref (applet,
_("Connected"),
str ? str : _("Mobile Broadband network"),
"nm-device-wwan",
PREF_DISABLE_CONNECTED_NOTIFICATIONS);
}
void
mobile_helper_get_icon (NMDevice *device,
NMDeviceState state,
NMConnection *connection,
GdkPixbuf **out_pixbuf,
char **out_indicator_icon,
char **tip,
NMApplet *applet,
guint32 mb_state,
guint32 mb_tech,
guint32 quality,
gboolean quality_valid)
{
NMSettingConnection *s_con;
const char *id;
id = nm_device_get_iface (NM_DEVICE (device));
if (connection) {
s_con = nm_connection_get_setting_connection (connection);
id = nm_setting_connection_get_id (s_con);
}
switch (state) {
case NM_DEVICE_STATE_PREPARE:
*tip = g_strdup_printf (_("Preparing mobile broadband connection '%s'..."), id);
break;
case NM_DEVICE_STATE_CONFIG:
*tip = g_strdup_printf (_("Configuring mobile broadband connection '%s'..."), id);
break;
case NM_DEVICE_STATE_NEED_AUTH:
*tip = g_strdup_printf (_("User authentication required for mobile broadband connection '%s'..."), id);
break;
case NM_DEVICE_STATE_IP_CONFIG:
*tip = g_strdup_printf (_("Requesting a network address for '%s'..."), id);
break;
case NM_DEVICE_STATE_ACTIVATED:
*out_pixbuf = mobile_helper_get_status_pixbuf (quality,
quality_valid,
mb_state,
mb_tech,
applet);
*out_indicator_icon = mobile_helper_get_quality_icon (quality_valid ?
quality : 0,
applet);
if ((mb_state != MB_STATE_UNKNOWN) && quality_valid) {
gboolean roaming = (mb_state == MB_STATE_ROAMING);
*tip = g_strdup_printf (_("Mobile broadband connection '%s' active: (%d%%%s%s)"),
id, quality,
roaming ? ", " : "",
roaming ? _("roaming") : "");
} else
*tip = g_strdup_printf (_("Mobile broadband connection '%s' active"), id);
break;
default:
break;
}
}
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 void
device_state_changed (NMDevice *device,
NMDeviceState new_state,
NMDeviceState old_state,
NMDeviceStateReason reason,
NMApplet *applet)
{
NMConnection *connection;
NMSettingConnection *s_con = NULL;
char *str = NULL;
if (new_state != NM_DEVICE_STATE_ACTIVATED)
return;
connection = applet_find_active_connection_for_device (device, applet, NULL);
if (connection) {
const char *id;
s_con = nm_connection_get_setting_connection (connection);
id = s_con ? nm_setting_connection_get_id (s_con) : NULL;
if (id)
str = g_strdup_printf (_("You are now connected to '%s'."), id);
}
applet_do_notify_with_pref (applet,
_("Connection Established"),
str ? str : _("You are now connected to the Mobile Broadband network."),
"nm-device-wwan",
PREF_DISABLE_CONNECTED_NOTIFICATIONS);
g_free (str);
}
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 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 void
dialog_set_network_name (NMConnection *connection, GtkEntry *entry)
{
NMSettingConnection *setting;
setting = nm_connection_get_setting_connection (connection);
gtk_widget_set_sensitive (GTK_WIDGET (entry), FALSE);
gtk_entry_set_text (entry, nm_setting_connection_get_id (setting));
}
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 const char *
get_connection_id (NMConnection *connection)
{
NMSettingConnection *s_con;
g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL);
s_con = (NMSettingConnection *) nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION);
g_return_val_if_fail (s_con != NULL, NULL);
return nm_setting_connection_get_id (s_con);
}
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 void
connection_added (NMRemoteSettings *settings,
NMRemoteConnection *connection,
gpointer user_data)
{
NMConnectionList *self = NM_CONNECTION_LIST (user_data);
GtkTreeIter parent_iter, iter;
NMSettingConnection *s_con;
char *last_used;
gboolean expand = TRUE;
if (!get_parent_iter_for_connection (self, connection, &parent_iter))
return;
s_con = nm_connection_get_setting_connection (NM_CONNECTION (connection));
last_used = format_last_used (nm_setting_connection_get_timestamp (s_con));
gtk_tree_store_append (GTK_TREE_STORE (self->model), &iter, &parent_iter);
gtk_tree_store_set (GTK_TREE_STORE (self->model), &iter,
COL_ID, nm_setting_connection_get_id (s_con),
COL_LAST_USED, last_used,
COL_TIMESTAMP, nm_setting_connection_get_timestamp (s_con),
COL_CONNECTION, connection,
-1);
g_free (last_used);
if (self->displayed_type) {
GType added_type;
gtk_tree_model_get (self->model, &parent_iter,
COL_GTYPE, &added_type,
-1);
if (added_type != self->displayed_type)
expand = FALSE;
}
if (expand) {
GtkTreePath *path, *filtered_path;
path = gtk_tree_model_get_path (self->model, &parent_iter);
filtered_path = gtk_tree_model_filter_convert_child_path_to_path (self->filter, path);
gtk_tree_view_expand_row (self->connection_list, filtered_path, FALSE);
gtk_tree_path_free (filtered_path);
gtk_tree_path_free (path);
}
g_signal_connect (connection, NM_REMOTE_CONNECTION_REMOVED, G_CALLBACK (connection_removed), self);
g_signal_connect (connection, NM_REMOTE_CONNECTION_UPDATED, G_CALLBACK (connection_updated), self);
gtk_tree_model_filter_refilter (self->filter);
}
void
nm_utils_complete_generic (NMPlatform *platform,
NMConnection *connection,
const char *ctype,
const GSList *existing,
const char *preferred_id,
const char *fallback_id_prefix,
const char *ifname_prefix,
gboolean default_enable_ipv6)
{
NMSettingConnection *s_con;
char *id, *uuid, *ifname;
GHashTable *parameters;
g_assert (fallback_id_prefix);
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, preferred_id, fallback_id_prefix);
g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_ID, id, NULL);
g_free (id);
}
/* Add an interface name, if requested */
if (ifname_prefix && !nm_setting_connection_get_interface_name (s_con)) {
ifname = get_new_connection_ifname (platform, existing, ifname_prefix);
g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_INTERFACE_NAME, ifname, NULL);
g_free (ifname);
}
/* Normalize */
parameters = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (parameters, NM_CONNECTION_NORMALIZE_PARAM_IP6_CONFIG_METHOD,
default_enable_ipv6 ? NM_SETTING_IP6_CONFIG_METHOD_AUTO : NM_SETTING_IP6_CONFIG_METHOD_IGNORE);
nm_connection_normalize (connection, parameters, NULL, NULL);
g_hash_table_destroy (parameters);
}
CEPage *
ce_page_ppp_new (NMConnection *connection,
GtkWindow *parent_window,
NMClient *client,
const char **out_secrets_setting_name,
GError **error)
{
CEPagePpp *self;
CEPagePppPrivate *priv;
NMSettingConnection *s_con;
self = CE_PAGE_PPP (ce_page_new (CE_TYPE_PAGE_PPP,
connection,
parent_window,
client,
UIDIR "/ce-page-ppp.ui",
"PppPage",
_("PPP Settings")));
if (!self) {
g_set_error_literal (error, NMA_ERROR, NMA_ERROR_GENERIC, _("Could not load PPP user interface."));
return NULL;
}
ppp_private_init (self);
priv = CE_PAGE_PPP_GET_PRIVATE (self);
priv->setting = nm_connection_get_setting_ppp (connection);
if (!priv->setting) {
priv->setting = NM_SETTING_PPP (nm_setting_ppp_new ());
g_object_set (G_OBJECT (priv->setting),
NM_SETTING_PPP_LCP_ECHO_FAILURE, 5,
NM_SETTING_PPP_LCP_ECHO_INTERVAL, 30,
NULL);
nm_connection_add_setting (connection, NM_SETTING (priv->setting));
}
priv->window_group = gtk_window_group_new ();
s_con = nm_connection_get_setting_connection (connection);
g_assert (s_con);
priv->connection_id = g_strdup (nm_setting_connection_get_id (s_con));
g_signal_connect (self, "initialized", G_CALLBACK (finish_setup), NULL);
*out_secrets_setting_name = NM_SETTING_PPP_SETTING_NAME;
return CE_PAGE (self);
}
static void
populate_connection_ui (NMConnectionEditor *editor)
{
NMSettingConnection *s_con;
GtkWidget *name;
name = GTK_WIDGET (gtk_builder_get_object (editor->builder, "connection_name"));
s_con = nm_connection_get_setting_connection (editor->connection);
gtk_entry_set_text (GTK_ENTRY (name), s_con ? nm_setting_connection_get_id (s_con) : NULL);
gtk_widget_set_tooltip_text (name, nm_connection_get_uuid (editor->connection));
g_signal_connect_swapped (name, "changed", G_CALLBACK (connection_editor_validate), editor);
connection_editor_validate (editor);
}
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
nm_connection_editor_update_title (NMConnectionEditor *editor)
{
NMSettingConnection *s_con;
const char *id;
g_return_if_fail (editor != NULL);
s_con = nm_connection_get_setting_connection (editor->connection);
g_assert (s_con);
id = nm_setting_connection_get_id (s_con);
if (id && strlen (id)) {
char *title = g_strdup_printf (_("Editing %s"), id);
gtk_window_set_title (GTK_WINDOW (editor->window), title);
g_free (title);
} else
gtk_window_set_title (GTK_WINDOW (editor->window), _("Editing un-named connection"));
}
static void
detail_vpn (gpointer data, gpointer user_data)
{
NMActiveConnection *active = NM_ACTIVE_CONNECTION (data);
NMConnection *connection;
NMSettingConnection *s_con;
NMVPNConnectionState state;
const char *banner;
if (!NM_IS_VPN_CONNECTION (active))
return;
connection = get_connection_for_active (active);
g_return_if_fail (connection != NULL);
s_con = (NMSettingConnection *) nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION);
g_return_if_fail (s_con != NULL);
print_header ("VPN", NULL, nm_setting_connection_get_id (s_con));
state = nm_vpn_connection_get_vpn_state (NM_VPN_CONNECTION (active));
print_string ("State", get_vpn_state_string (state));
if (nm_active_connection_get_default (active))
print_string ("Default", "yes");
else
print_string ("Default", "no");
banner = nm_vpn_connection_get_banner (NM_VPN_CONNECTION (active));
if (banner) {
char **lines, **iter;
printf ("\n Message:\n");
lines = g_strsplit_set (banner, "\n\r", -1);
for (iter = lines; *iter; iter++) {
if (*iter && strlen (*iter))
printf (" %s\n", *iter);
}
g_strfreev (lines);
}
printf ("\n\n");
}
static void
test_nat_force_natt (NMVpnPluginUiInterface *plugin, const char *dir)
{
NMConnection *connection;
NMSettingConnection *s_con;
NMSettingVPN *s_vpn;
GError *error = NULL;
char *pcf;
const char *expected_id = "Force NAT-T";
const char *value;
pcf = g_build_path ("/", dir, "force-natt.pcf", NULL);
ASSERT (pcf != NULL,
"force-natt", "failed to create pcf path");
connection = nm_vpn_plugin_ui_interface_import (plugin, pcf, &error);
if (error)
FAIL ("force-natt", "error importing %s: %s", pcf, error->message);
ASSERT (connection != NULL,
"force-natt", "error importing %s: (unknown)", pcf);
/* Connection setting */
s_con = nm_connection_get_setting_connection (connection);
ASSERT (s_con != NULL,
"force-natt", "missing 'connection' setting");
ASSERT (strcmp (nm_setting_connection_get_id (s_con), expected_id) == 0,
"force-natt", "unexpected connection ID");
/* VPN setting */
s_vpn = nm_connection_get_setting_vpn (connection);
ASSERT (s_vpn != NULL,
"force-natt", "missing 'vpn' setting");
value = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_NAT_TRAVERSAL_MODE);
ASSERT (value != NULL,
"force-natt", "unexpected missing value for item %s", NM_VPNC_KEY_NAT_TRAVERSAL_MODE);
ASSERT (strcmp (value, NM_VPNC_NATT_MODE_NATT_ALWAYS) == 0,
"force-natt", "unexpected value for item %s", NM_VPNC_KEY_NAT_TRAVERSAL_MODE);
g_free (pcf);
}
GnomeKeyringAttributeList *
utils_create_keyring_add_attr_list (NMConnection *connection,
const char *connection_uuid,
const char *connection_id,
const char *setting_name,
const char *setting_key,
char **out_display_name)
{
GnomeKeyringAttributeList *attrs = NULL;
NMSettingConnection *s_con;
if (connection) {
s_con = nm_connection_get_setting_connection (connection);
g_return_val_if_fail (s_con != NULL, NULL);
connection_uuid = nm_setting_connection_get_uuid (s_con);
connection_id = nm_setting_connection_get_id (s_con);
}
g_return_val_if_fail (connection_uuid != NULL, NULL);
g_return_val_if_fail (connection_id != NULL, NULL);
g_return_val_if_fail (setting_name != NULL, NULL);
g_return_val_if_fail (setting_key != NULL, NULL);
if (out_display_name) {
*out_display_name = g_strdup_printf ("Network secret for %s/%s/%s",
connection_id,
setting_name,
setting_key);
}
attrs = gnome_keyring_attribute_list_new ();
gnome_keyring_attribute_list_append_string (attrs,
KEYRING_UUID_TAG,
connection_uuid);
gnome_keyring_attribute_list_append_string (attrs,
KEYRING_SN_TAG,
setting_name);
gnome_keyring_attribute_list_append_string (attrs,
KEYRING_SK_TAG,
setting_key);
return attrs;
}
static void
test_legacy_ike_port_1_import (NMVpnPluginUiInterface *plugin, const char *dir)
{
NMConnection *connection;
NMSettingConnection *s_con;
NMSettingVPN *s_vpn;
GError *error = NULL;
char *pcf;
const char *expected_id = "Don't use Legacy IKE Port (500)";
const char *value;
pcf = g_build_path ("/", dir, "use-legacy-ike-port-1.pcf", NULL);
ASSERT (pcf != NULL,
"use-legacy-ike-port-1", "failed to create pcf path");
connection = nm_vpn_plugin_ui_interface_import (plugin, pcf, &error);
if (error)
FAIL ("", "error importing %s: %s", pcf, error->message);
ASSERT (connection != NULL,
"use-legacy-ike-port-1", "error importing %s: (unknown)", pcf);
/* Connection setting */
s_con = nm_connection_get_setting_connection (connection);
ASSERT (s_con != NULL,
"use-legacy-ike-port-1", "missing 'connection' setting");
ASSERT (strcmp (nm_setting_connection_get_id (s_con), expected_id) == 0,
"use-legacy-ike-port-1", "unexpected connection ID");
/* VPN setting */
s_vpn = nm_connection_get_setting_vpn (connection);
ASSERT (s_vpn != NULL,
"use-legacy-ike-port-1", "missing 'vpn' setting");
value = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_LOCAL_PORT);
ASSERT (value != NULL,
"use-legacy-ike-port-1", "unexpected missing value for item %s", NM_VPNC_KEY_LOCAL_PORT);
ASSERT (strcmp (value, "500") == 0,
"use-legacy-ike-port-1", "unexpected value for item %s", NM_VPNC_KEY_LOCAL_PORT);
g_free (pcf);
}
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;
}
CEPage *
ce_page_ip4_new (NMConnectionEditor *editor,
NMConnection *connection,
GtkWindow *parent_window,
NMClient *client,
const char **out_secrets_setting_name,
GError **error)
{
CEPageIP4 *self;
CEPageIP4Private *priv;
NMSettingConnection *s_con;
self = CE_PAGE_IP4 (ce_page_new (CE_TYPE_PAGE_IP4,
editor,
connection,
parent_window,
client,
UIDIR "/ce-page-ip4.ui",
"IP4Page",
_("IPv4 Settings")));
if (!self) {
g_set_error_literal (error, NMA_ERROR, NMA_ERROR_GENERIC, _("Could not load IPv4 user interface."));
return NULL;
}
ip4_private_init (self, connection);
priv = CE_PAGE_IP4_GET_PRIVATE (self);
priv->window_group = gtk_window_group_new ();
s_con = nm_connection_get_setting_connection (connection);
g_assert (s_con);
priv->connection_id = g_strdup (nm_setting_connection_get_id (s_con));
priv->setting = nm_connection_get_setting_ip4_config (connection);
g_assert (priv->setting);
g_signal_connect (self, "initialized", G_CALLBACK (finish_setup), NULL);
return CE_PAGE (self);
}
static void
test_everything_via_vpn (NMVpnPluginUiInterface *plugin, const char *dir)
{
NMConnection *connection;
NMSettingConnection *s_con;
NMSettingIP4Config *s_ip4;
GError *error = NULL;
char *pcf;
const char *expected_id = "All your traffic are belong to VPN";
pcf = g_build_path ("/", dir, "everything-via-vpn.pcf", NULL);
ASSERT (pcf != NULL,
"everything-via-vpn", "failed to create pcf path");
connection = nm_vpn_plugin_ui_interface_import (plugin, pcf, &error);
if (error)
FAIL ("everything-via-vpn", "error importing %s: %s", pcf, error->message);
ASSERT (connection != NULL,
"everything-via-vpn", "error importing %s: (unknown)", pcf);
/* Connection setting */
s_con = nm_connection_get_setting_connection (connection);
ASSERT (s_con != NULL,
"everything-via-vpn", "missing 'connection' setting");
ASSERT (strcmp (nm_setting_connection_get_id (s_con), expected_id) == 0,
"everything-via-vpn", "unexpected connection ID");
/* IP4 setting */
s_ip4 = nm_connection_get_setting_ip4_config (connection);
ASSERT (s_ip4 != NULL,
"everything-via-vpn", "missing 'ip4-config' setting");
ASSERT (nm_setting_ip4_config_get_never_default (s_ip4) == FALSE,
"everything-via-vpn", "never-default unexpectedly FALSE");
ASSERT (nm_setting_ip4_config_get_num_routes (s_ip4) == 0,
"everything-via-vpn", "unexpected number of routes");
g_free (pcf);
}
static GdkPixbuf *
bt_get_icon (NMDevice *device,
NMDeviceState state,
NMConnection *connection,
char **tip,
NMApplet *applet)
{
NMSettingConnection *s_con;
GdkPixbuf *pixbuf = NULL;
const char *id;
id = nm_device_get_iface (NM_DEVICE (device));
if (connection) {
s_con = nm_connection_get_setting_connection (connection);
id = nm_setting_connection_get_id (s_con);
}
switch (state) {
case NM_DEVICE_STATE_PREPARE:
*tip = g_strdup_printf (_("Preparing mobile broadband connection '%s'..."), id);
break;
case NM_DEVICE_STATE_CONFIG:
*tip = g_strdup_printf (_("Configuring mobile broadband connection '%s'..."), id);
break;
case NM_DEVICE_STATE_NEED_AUTH:
*tip = g_strdup_printf (_("User authentication required for mobile broadband connection '%s'..."), id);
break;
case NM_DEVICE_STATE_IP_CONFIG:
*tip = g_strdup_printf (_("Requesting a network address for '%s'..."), id);
break;
case NM_DEVICE_STATE_ACTIVATED:
pixbuf = nma_icon_check_and_load ("nm-device-wwan", &applet->wwan_icon, applet);
*tip = g_strdup_printf (_("Mobile broadband connection '%s' active"), id);
break;
default:
break;
}
return pixbuf ? g_object_ref (pixbuf) : NULL;
}
static void
test_always_ask (NMVpnPluginUiInterface *plugin, const char *dir)
{
NMConnection *connection;
NMSettingConnection *s_con;
NMSettingVPN *s_vpn;
GError *error = NULL;
char *pcf;
const char *expected_id = "Always Ask For Password";
const char *value;
pcf = g_build_path ("/", dir, "always-ask.pcf", NULL);
ASSERT (pcf != NULL,
"always-ask", "failed to create pcf path");
connection = nm_vpn_plugin_ui_interface_import (plugin, pcf, &error);
if (error)
FAIL ("always-ask", "error importing %s: %s", pcf, error->message);
ASSERT (connection != NULL,
"always-ask", "error importing %s: (unknown)", pcf);
/* Connection setting */
s_con = nm_connection_get_setting_connection (connection);
ASSERT (s_con != NULL,
"always-ask", "missing 'connection' setting");
ASSERT (strcmp (nm_setting_connection_get_id (s_con), expected_id) == 0,
"always-ask", "unexpected connection ID");
/* VPN setting */
s_vpn = nm_connection_get_setting_vpn (connection);
ASSERT (s_vpn != NULL,
"always-ask", "missing 'vpn' setting");
value = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_XAUTH_PASSWORD_TYPE);
ASSERT (value == NULL,
"always-ask", "unexpected value for item %s", NM_VPNC_KEY_XAUTH_PASSWORD_TYPE);
g_free (pcf);
}
static void
bt_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_connection_get_setting_connection (connection);
id = nm_setting_connection_get_id (s_con);
}
switch (state) {
case NM_DEVICE_STATE_PREPARE:
*tip = g_strdup_printf (_("Preparing mobile broadband connection '%s'..."), id);
break;
case NM_DEVICE_STATE_CONFIG:
*tip = g_strdup_printf (_("Configuring mobile broadband connection '%s'..."), id);
break;
case NM_DEVICE_STATE_NEED_AUTH:
*tip = g_strdup_printf (_("User authentication required for mobile broadband connection '%s'..."), id);
break;
case NM_DEVICE_STATE_IP_CONFIG:
*tip = g_strdup_printf (_("Requesting a network address for '%s'..."), id);
break;
case NM_DEVICE_STATE_ACTIVATED:
*out_icon_name = "nm-device-wwan";
*tip = g_strdup_printf (_("Mobile broadband connection '%s' active"), id);
break;
default:
break;
}
}