static GValue *
addr_to_gvalue (const char *str)
{
struct in_addr temp_addr;
/* Empty */
if (!str || strlen (str) < 1)
return NULL;
if (inet_pton (AF_INET, str, &temp_addr) <= 0)
return NULL;
return uint_to_gvalue (temp_addr.s_addr);
}
static void
test_update_secrets_wifi (void)
{
NMConnection *connection;
NMSettingConnection *s_con;
NMSettingWireless *s_wifi;
NMSettingWirelessSecurity *s_wsec;
unsigned char tmpssid[] = { 0x31, 0x33, 0x33, 0x37 };
const char *wepkey = "11111111111111111111111111";
GHashTable *secrets;
GError *error = NULL;
char *uuid;
GByteArray *ssid;
gboolean success;
connection = nm_connection_new ();
g_assert (connection);
/* Connection setting */
s_con = (NMSettingConnection *) nm_setting_connection_new ();
g_assert (s_con);
uuid = nm_utils_uuid_generate ();
g_object_set (s_con,
NM_SETTING_CONNECTION_ID, "Test Wireless",
NM_SETTING_CONNECTION_UUID, uuid,
NM_SETTING_CONNECTION_AUTOCONNECT, FALSE,
NM_SETTING_CONNECTION_TYPE, NM_SETTING_WIRELESS_SETTING_NAME,
NULL);
g_free (uuid);
nm_connection_add_setting (connection, NM_SETTING (s_con));
/* Wireless setting */
s_wifi = (NMSettingWireless *) nm_setting_wireless_new ();
g_assert (s_wifi);
ssid = g_byte_array_sized_new (sizeof (tmpssid));
g_byte_array_append (ssid, &tmpssid[0], sizeof (tmpssid));
g_object_set (s_wifi,
NM_SETTING_WIRELESS_SSID, ssid,
NM_SETTING_WIRELESS_SEC, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME,
NULL);
g_byte_array_free (ssid, TRUE);
nm_connection_add_setting (connection, NM_SETTING (s_wifi));
/* Wifi security */
s_wsec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new ();
g_assert (s_wsec);
g_object_set (G_OBJECT (s_wsec),
NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "none",
NULL);
nm_connection_add_setting (connection, NM_SETTING (s_wsec));
/* Build up the secrets hash */
secrets = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, value_destroy);
g_hash_table_insert (secrets, NM_SETTING_WIRELESS_SECURITY_WEP_KEY0, string_to_gvalue (wepkey));
g_hash_table_insert (secrets, NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE, uint_to_gvalue (NM_WEP_KEY_TYPE_KEY));
success = nm_connection_update_secrets (connection,
NM_SETTING_WIRELESS_SECURITY_SETTING_NAME,
secrets,
&error);
if (!success) {
/* Print the warning message before we assert success */
g_assert (error);
g_warning ("Error updating connection secrets: %s", error->message);
g_clear_error (&error);
}
g_assert (success);
}
static gboolean
nm_openssh_send_ip4_config (sshtun_handle_t handle)
{
DBusGConnection *connection;
GError *err = NULL;
GHashTable *config;
GValue *val;
struct in_addr temp_addr;
const char *tmp;
connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &err);
if (!connection)
return FALSE;
config = g_hash_table_new (g_str_hash, g_str_equal);
/* Gateway */
val = addr_to_gvalue (sshtun_get_param (handle, SSHTUN_PARAM_GW_ADDR));
if (val)
g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_GATEWAY, val);
else {
helper_failed (connection, "VPN Gateway");
dbus_g_connection_unref (connection);
return FALSE;
}
/* Tunnel device */
val = str_to_gvalue (sshtun_get_param (handle, SSHTUN_PARAM_TUN_DEV),
FALSE);
if (val)
g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_TUNDEV, val);
else {
helper_failed (connection, "Tunnel Device");
dbus_g_connection_unref (connection);
return FALSE;
}
/* IP address */
val = addr_to_gvalue (sshtun_get_param (handle, SSHTUN_PARAM_ADDR));
if (val)
g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_ADDRESS, val);
else {
helper_failed (connection, "IP4 Address");
dbus_g_connection_unref (connection);
return FALSE;
}
/* PTP address */
val = addr_to_gvalue (sshtun_get_param (handle, SSHTUN_PARAM_PEER_ADDR));
if (val)
g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_PTP, val);
/* Netmask */
tmp = sshtun_get_param (handle, SSHTUN_PARAM_NETMASK);
if (tmp && inet_pton (AF_INET, tmp, &temp_addr) > 0) {
val = uint_to_gvalue (nm_utils_ip4_netmask_to_prefix (temp_addr.s_addr));
g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_PREFIX, val);
}
/* MTU */
tmp = sshtun_get_param (handle, SSHTUN_PARAM_MTU);
if (tmp && strlen (tmp)) {
long int mtu;
errno = 0;
mtu = strtol (tmp, NULL, 10);
if (errno || mtu < 0 || mtu > 20000) {
nm_warning ("Ignoring invalid tunnel MTU '%s'", tmp);
} else {
val = uint_to_gvalue ((guint32) mtu);
g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_MTU, val);
}
}
send_ip4_config (connection, config);
dbus_g_connection_unref (connection);
return TRUE;
}
static void
nm_ip_up (void *data, int arg)
{
guint32 pppd_made_up_address = htonl (0x0a404040 + ifunit);
ipcp_options opts = ipcp_gotoptions[0];
ipcp_options peer_opts = ipcp_hisoptions[0];
GHashTable *hash;
GArray *array;
GValue *val;
struct sockaddr_in addr;
g_return_if_fail (DBUS_IS_G_PROXY (proxy));
g_message ("nm-sstp-ppp-plugin: (%s): ip-up event", __func__);
if (!opts.ouraddr) {
g_warning ("nm-sstp-ppp-plugin: (%s): didn't receive an internal IP from pppd!", __func__);
return;
}
hash = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, value_destroy);
/* Request the address of the server sstpc connected to */
if (0 == nm_sstp_getaddr(&addr))
{
/* This will eliminate the need to have nm-sstp-service
* insert a new entry for "gateway" as we have already set it.
*/
g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_EXT_GATEWAY,
uint_to_gvalue (addr.sin_addr.s_addr));
}
g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_TUNDEV,
str_to_gvalue (ifname));
/* Prefer the peer options remote address first, _unless_ pppd made the
* address up, at which point prefer the local options remote address,
* and if that's not right, use the made-up address as a last resort.
*/
if (peer_opts.hisaddr && (peer_opts.hisaddr != pppd_made_up_address)) {
g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_PTP,
uint_to_gvalue (peer_opts.hisaddr));
} else if (opts.hisaddr) {
g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_PTP,
uint_to_gvalue (opts.hisaddr));
} else if (peer_opts.hisaddr == pppd_made_up_address) {
/* As a last resort, use the made-up address */
g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_PTP,
uint_to_gvalue (peer_opts.hisaddr));
}
g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_ADDRESS,
uint_to_gvalue (opts.ouraddr));
g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_PREFIX, uint_to_gvalue (32));
if (opts.dnsaddr[0] || opts.dnsaddr[1]) {
array = g_array_new (FALSE, FALSE, sizeof (guint32));
if (opts.dnsaddr[0])
g_array_append_val (array, opts.dnsaddr[0]);
if (opts.dnsaddr[1])
g_array_append_val (array, opts.dnsaddr[1]);
val = g_slice_new0 (GValue);
g_value_init (val, DBUS_TYPE_G_UINT_ARRAY);
g_value_set_boxed (val, array);
g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_DNS, val);
}
/* Default MTU to 1400, which is also what Windows XP/Vista use */
g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_MTU, uint_to_gvalue (1400));
g_message ("nm-sstp-ppp-plugin: (%s): sending Ip4Config to NetworkManager-sstp...", __func__);
dbus_g_proxy_call_no_reply (proxy, "SetIp4Config",
DBUS_TYPE_G_MAP_OF_VARIANT, hash, G_TYPE_INVALID,
G_TYPE_INVALID);
g_hash_table_destroy (hash);
}
