CEPage *
ce_page_ip4_new (NMConnection *connection, GtkWindow *parent_window, GError **error)
{
CEPageIP4 *self;
CEPageIP4Private *priv;
CEPage *parent;
NMSettingConnection *s_con;
self = CE_PAGE_IP4 (g_object_new (CE_TYPE_PAGE_IP4,
CE_PAGE_CONNECTION, connection,
CE_PAGE_PARENT_WINDOW, parent_window,
NULL));
parent = CE_PAGE (self);
parent->xml = glade_xml_new (GLADEDIR "/ce-page-ip4.glade", "IP4Page", NULL);
if (!parent->xml) {
g_set_error (error, 0, 0, "%s", _("Could not load IPv4 user interface."));
g_object_unref (self);
return NULL;
}
parent->page = glade_xml_get_widget (parent->xml, "IP4Page");
if (!parent->page) {
g_set_error (error, 0, 0, "%s", _("Could not load IPv4 user interface."));
g_object_unref (self);
return NULL;
}
g_object_ref_sink (parent->page);
parent->title = g_strdup (_("IPv4 Settings"));
ip4_private_init (self, connection);
priv = CE_PAGE_IP4_GET_PRIVATE (self);
priv->window_group = gtk_window_group_new ();
s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION));
g_assert (s_con);
priv->connection_id = g_strdup (nm_setting_connection_get_id (s_con));
priv->setting = (NMSettingIP4Config *) nm_connection_get_setting (connection, NM_TYPE_SETTING_IP4_CONFIG);
if (!priv->setting) {
priv->setting = NM_SETTING_IP4_CONFIG (nm_setting_ip4_config_new ());
nm_connection_add_setting (connection, NM_SETTING (priv->setting));
}
g_signal_connect (self, "initialized", G_CALLBACK (finish_setup), NULL);
if (!ce_page_initialize (parent, NULL, error)) {
g_object_unref (self);
return NULL;
}
return CE_PAGE (self);
}
static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMSettingIP4Config *setting = NM_SETTING_IP4_CONFIG (object);
NMSettingIP4ConfigPrivate *priv = NM_SETTING_IP4_CONFIG_GET_PRIVATE (setting);
switch (prop_id) {
case PROP_METHOD:
g_value_set_string (value, nm_setting_ip4_config_get_method (setting));
break;
case PROP_DNS:
g_value_set_boxed (value, priv->dns);
break;
case PROP_DNS_SEARCH:
g_value_set_boxed (value, priv->dns_search);
break;
case PROP_ADDRESSES:
nm_utils_ip4_addresses_to_gvalue (priv->addresses, value);
break;
case PROP_ROUTES:
nm_utils_ip4_routes_to_gvalue (priv->routes, value);
break;
case PROP_IGNORE_AUTO_ROUTES:
g_value_set_boolean (value, nm_setting_ip4_config_get_ignore_auto_routes (setting));
break;
case PROP_IGNORE_AUTO_DNS:
g_value_set_boolean (value, nm_setting_ip4_config_get_ignore_auto_dns (setting));
break;
case PROP_DHCP_CLIENT_ID:
g_value_set_string (value, nm_setting_ip4_config_get_dhcp_client_id (setting));
break;
case PROP_DHCP_SEND_HOSTNAME:
g_value_set_boolean (value, nm_setting_ip4_config_get_dhcp_send_hostname (setting));
break;
case PROP_DHCP_HOSTNAME:
g_value_set_string (value, nm_setting_ip4_config_get_dhcp_hostname (setting));
break;
case PROP_NEVER_DEFAULT:
g_value_set_boolean (value, priv->never_default);
break;
case PROP_MAY_FAIL:
g_value_set_boolean (value, priv->may_fail);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
finalize (GObject *object)
{
NMSettingIP4Config *self = NM_SETTING_IP4_CONFIG (object);
NMSettingIP4ConfigPrivate *priv = NM_SETTING_IP4_CONFIG_GET_PRIVATE (self);
g_free (priv->method);
g_array_free (priv->dns, TRUE);
nm_utils_slist_free (priv->dns_search, g_free);
nm_utils_slist_free (priv->addresses, (GDestroyNotify) nm_ip4_address_unref);
nm_utils_slist_free (priv->routes, (GDestroyNotify) nm_ip4_route_unref);
G_OBJECT_CLASS (nm_setting_ip4_config_parent_class)->finalize (object);
}
static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMSettingIP4Config *s_ip4 = NM_SETTING_IP4_CONFIG (object);
switch (prop_id) {
case PROP_DHCP_CLIENT_ID:
g_value_set_string (value, nm_setting_ip4_config_get_dhcp_client_id (s_ip4));
break;
case PROP_DHCP_FQDN:
g_value_set_string (value, nm_setting_ip4_config_get_dhcp_fqdn (s_ip4));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
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 void
set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
NMSettingIP4Config *setting = NM_SETTING_IP4_CONFIG (object);
NMSettingIP4ConfigPrivate *priv = NM_SETTING_IP4_CONFIG_GET_PRIVATE (setting);
switch (prop_id) {
case PROP_METHOD:
g_free (priv->method);
priv->method = g_value_dup_string (value);
break;
case PROP_DNS:
g_array_free (priv->dns, TRUE);
priv->dns = g_value_dup_boxed (value);
if (!priv->dns)
priv->dns = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 3);
break;
case PROP_DNS_SEARCH:
nm_utils_slist_free (priv->dns_search, g_free);
priv->dns_search = g_value_dup_boxed (value);
break;
case PROP_ADDRESSES:
nm_utils_slist_free (priv->addresses, (GDestroyNotify) nm_ip4_address_unref);
priv->addresses = nm_utils_ip4_addresses_from_gvalue (value);
break;
case PROP_ROUTES:
nm_utils_slist_free (priv->routes, (GDestroyNotify) nm_ip4_route_unref);
priv->routes = nm_utils_ip4_routes_from_gvalue (value);
break;
case PROP_IGNORE_AUTO_ROUTES:
priv->ignore_auto_routes = g_value_get_boolean (value);
break;
case PROP_IGNORE_AUTO_DNS:
priv->ignore_auto_dns = g_value_get_boolean (value);
break;
case PROP_DHCP_CLIENT_ID:
g_free (priv->dhcp_client_id);
priv->dhcp_client_id = g_value_dup_string (value);
break;
case PROP_DHCP_SEND_HOSTNAME:
priv->dhcp_send_hostname = g_value_get_boolean (value);
break;
case PROP_DHCP_HOSTNAME:
g_free (priv->dhcp_hostname);
priv->dhcp_hostname = g_value_dup_string (value);
/* FIXME: Is this a good idea? */
if (priv->dhcp_hostname)
priv->dhcp_send_hostname = TRUE;
break;
case PROP_NEVER_DEFAULT:
priv->never_default = g_value_get_boolean (value);
break;
case PROP_MAY_FAIL:
priv->may_fail = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
populate_ui (CEPageIP4 *self)
{
CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self);
NMSettingIPConfig *setting = priv->setting;
GtkListStore *store;
GtkTreeIter model_iter;
int method = IP4_METHOD_AUTO;
GString *string = NULL;
SetMethodInfo info;
const char *str_method;
int i;
/* Method */
gtk_combo_box_set_active (priv->method, 0);
str_method = nm_setting_ip_config_get_method (setting);
if (str_method) {
if (!strcmp (str_method, NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL))
method = IP4_METHOD_LINK_LOCAL;
else if (!strcmp (str_method, NM_SETTING_IP4_CONFIG_METHOD_MANUAL))
method = IP4_METHOD_MANUAL;
else if (!strcmp (str_method, NM_SETTING_IP4_CONFIG_METHOD_SHARED))
method = IP4_METHOD_SHARED;
else if (!strcmp (str_method, NM_SETTING_IP4_CONFIG_METHOD_DISABLED))
method = IP4_METHOD_DISABLED;
}
if (method == IP4_METHOD_AUTO && nm_setting_ip_config_get_ignore_auto_dns (setting))
method = IP4_METHOD_AUTO_ADDRESSES;
info.method = method;
info.combo = priv->method;
gtk_tree_model_foreach (GTK_TREE_MODEL (priv->method_store), set_method, &info);
/* Addresses */
store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
for (i = 0; i < nm_setting_ip_config_get_num_addresses (setting); i++) {
NMIPAddress *addr = nm_setting_ip_config_get_address (setting, i);
char buf[32];
if (!addr) {
g_warning ("%s: empty IP4 Address structure!", __func__);
continue;
}
snprintf (buf, sizeof (buf), "%u", nm_ip_address_get_prefix (addr));
gtk_list_store_append (store, &model_iter);
gtk_list_store_set (store, &model_iter,
COL_ADDRESS, nm_ip_address_get_address (addr),
COL_PREFIX, buf,
/* FIXME */
COL_GATEWAY, i == 0 ? nm_setting_ip_config_get_gateway (setting) : NULL,
-1);
}
gtk_tree_view_set_model (priv->addr_list, GTK_TREE_MODEL (store));
g_signal_connect_swapped (store, "row-inserted", G_CALLBACK (ce_page_changed), self);
g_signal_connect_swapped (store, "row-deleted", G_CALLBACK (ce_page_changed), self);
g_object_unref (store);
/* DNS servers */
string = g_string_new ("");
for (i = 0; i < nm_setting_ip_config_get_num_dns (setting); i++) {
const char *dns;
dns = nm_setting_ip_config_get_dns (setting, i);
if (!dns)
continue;
if (string->len)
g_string_append (string, ", ");
g_string_append (string, dns);
}
gtk_entry_set_text (priv->dns_servers, string->str);
g_string_free (string, TRUE);
/* DNS searches */
string = g_string_new ("");
for (i = 0; i < nm_setting_ip_config_get_num_dns_searches (setting); i++) {
if (string->len)
g_string_append (string, ", ");
g_string_append (string, nm_setting_ip_config_get_dns_search (setting, i));
}
gtk_entry_set_text (priv->dns_searches, string->str);
g_string_free (string, TRUE);
if ((method == IP4_METHOD_AUTO) || (method == IP4_METHOD_AUTO_ADDRESSES)) {
if (nm_setting_ip4_config_get_dhcp_client_id (NM_SETTING_IP4_CONFIG (setting))) {
gtk_entry_set_text (priv->dhcp_client_id,
nm_setting_ip4_config_get_dhcp_client_id (NM_SETTING_IP4_CONFIG (setting)));
}
}
/* IPv4 required */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->ip4_required),
!nm_setting_ip_config_get_may_fail (setting));
}
static 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;
}
