colin/NetworkManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

core: switch nm-ip4-config's NMIP[46]Address to NMPlatformIP[46]Address

Browse Source
This commit is contained in:
Pavel Šimerda
2013-06-29 13:33:36 +02:00
parent 74621a8f5c
commit d8e6065f63
18 changed files with 280 additions and 301 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/devices/nm-device.c
View File

@@ -1899,16 +1899,16 @@ static NMIP4Config *
aipd_get_ip4_config (NMDevice *self, struct in_addr lla) aipd_get_ip4_config (NMDevice *self, struct in_addr lla)
{ {
NMIP4Config *config = NULL; NMIP4Config *config = NULL;
NMIP4Address *addr; NMPlatformIP4Address address;
NMIP4Route *route; NMIP4Route *route;
config = nm_ip4_config_new (); config = nm_ip4_config_new ();
g_assert (config); g_assert (config);
addr = nm_ip4_address_new (); memset (&address, 0, sizeof (address));
nm_ip4_address_set_address (addr, (guint32) lla.s_addr); address.address = lla.s_addr;
nm_ip4_address_set_prefix (addr, 16); address.plen = 16;
nm_ip4_config_take_address (config, addr); nm_ip4_config_add_address (config, &address);
/* Add a multicast route for link-local connections: destination= 224.0.0.0, netmask=240.0.0.0 */ /* Add a multicast route for link-local connections: destination= 224.0.0.0, netmask=240.0.0.0 */
route = nm_ip4_route_new (); route = nm_ip4_route_new ();
@@ -2382,7 +2382,7 @@ static NMIP4Config *
shared4_new_config (NMDevice *self, NMDeviceStateReason *reason) shared4_new_config (NMDevice *self, NMDeviceStateReason *reason)
{ {
NMIP4Config *config = NULL; NMIP4Config *config = NULL;
NMIP4Address *addr; NMPlatformIP4Address address;
guint32 tmp_addr; guint32 tmp_addr;
g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (self != NULL, NULL);
@@ -2397,10 +2397,10 @@ shared4_new_config (NMDevice *self, NMDeviceStateReason *reason)
} }
config = nm_ip4_config_new (); config = nm_ip4_config_new ();
addr = nm_ip4_address_new (); memset (&address, 0, sizeof (address));
nm_ip4_address_set_address (addr, tmp_addr); address.address = tmp_addr;
nm_ip4_address_set_prefix (addr, 24); address.plen = 24;
nm_ip4_config_take_address (config, addr); nm_ip4_config_add_address (config, &address);
/* Remove the address lock when the object gets disposed */ /* Remove the address lock when the object gets disposed */
g_object_set_data_full (G_OBJECT (config), "shared-ip", g_object_set_data_full (G_OBJECT (config), "shared-ip",
@@ -3575,7 +3575,7 @@ start_sharing (NMDevice *self, NMIP4Config *config)
char str_addr[INET_ADDRSTRLEN + 1]; char str_addr[INET_ADDRSTRLEN + 1];
char str_mask[INET_ADDRSTRLEN + 1]; char str_mask[INET_ADDRSTRLEN + 1];
guint32 netmask, network; guint32 netmask, network;
NMIP4Address *ip4_addr; const NMPlatformIP4Address *ip4_addr;
const char *ip_iface; const char *ip_iface;
g_return_val_if_fail (config != NULL, FALSE); g_return_val_if_fail (config != NULL, FALSE);
@@ -3583,14 +3583,14 @@ start_sharing (NMDevice *self, NMIP4Config *config)
ip_iface = nm_device_get_ip_iface (self); ip_iface = nm_device_get_ip_iface (self);
ip4_addr = nm_ip4_config_get_address (config, 0); ip4_addr = nm_ip4_config_get_address (config, 0);
if (!ip4_addr || !nm_ip4_address_get_address (ip4_addr)) if (!ip4_addr || !ip4_addr->address)
return FALSE; return FALSE;
netmask = nm_utils_ip4_prefix_to_netmask (nm_ip4_address_get_prefix (ip4_addr)); netmask = nm_utils_ip4_prefix_to_netmask (ip4_addr->plen);
if (!inet_ntop (AF_INET, &netmask, str_mask, sizeof (str_mask))) if (!inet_ntop (AF_INET, &netmask, str_mask, sizeof (str_mask)))
return FALSE; return FALSE;
network = nm_ip4_address_get_address (ip4_addr) & netmask; network = ip4_addr->address & netmask;
if (!inet_ntop (AF_INET, &network, str_addr, sizeof (str_addr))) if (!inet_ntop (AF_INET, &network, str_addr, sizeof (str_addr)))
return FALSE; return FALSE;
@@ -5998,11 +5998,11 @@ ip4_match_config (NMDevice *self, NMConnection *connection)
/* Find at least one lease's address on the device */ /* Find at least one lease's address on the device */
for (iter = leases; iter; iter = g_slist_next (iter)) { for (iter = leases; iter; iter = g_slist_next (iter)) {
NMIP4Config *ip4_config = iter->data; NMIP4Config *ip4_config = iter->data;
NMIP4Address *addr = nm_ip4_config_get_address (ip4_config, 0); const NMPlatformIP4Address *address = nm_ip4_config_get_address (ip4_config, 0);
if (addr && nm_platform_ip4_address_exists (nm_device_get_ip_ifindex (self), if (address && nm_platform_ip4_address_exists (nm_device_get_ip_ifindex (self),
nm_ip4_address_get_address (addr), address->address,
nm_ip4_address_get_prefix (addr))) { address->plen)) {
found = TRUE; /* Yay, device has same address as a lease */ found = TRUE; /* Yay, device has same address as a lease */
break; break;
} }

37
src/dhcp-manager/nm-dhcp-client.c
View File

@@ -1136,9 +1136,9 @@ ip4_options_to_config (NMDHCPClient *self)
NMDHCPClientPrivate *priv; NMDHCPClientPrivate *priv;
NMIP4Config *ip4_config = NULL; NMIP4Config *ip4_config = NULL;
struct in_addr tmp_addr; struct in_addr tmp_addr;
NMIP4Address *addr = NULL; NMPlatformIP4Address address;
char *str = NULL; char *str = NULL;
guint32 gwaddr = 0, prefix = 0; guint32 gwaddr = 0, plen = 0;
g_return_val_if_fail (NM_IS_DHCP_CLIENT (self), NULL); g_return_val_if_fail (NM_IS_DHCP_CLIENT (self), NULL);
@@ -1146,25 +1146,25 @@ ip4_options_to_config (NMDHCPClient *self)
g_return_val_if_fail (priv->options != NULL, NULL); g_return_val_if_fail (priv->options != NULL, NULL);
ip4_config = nm_ip4_config_new (); ip4_config = nm_ip4_config_new ();
addr = nm_ip4_address_new (); memset (&address, 0, sizeof (address));
str = g_hash_table_lookup (priv->options, "new_ip_address"); str = g_hash_table_lookup (priv->options, "new_ip_address");
if (str && (inet_pton (AF_INET, str, &tmp_addr) > 0)) { if (str && (inet_pton (AF_INET, str, &tmp_addr) > 0)) {
nm_ip4_address_set_address (addr, tmp_addr.s_addr); address.address = tmp_addr.s_addr;
nm_log_info (LOGD_DHCP4, " address %s", str); nm_log_info (LOGD_DHCP4, " address %s", str);
} else } else
goto error; goto error;
str = g_hash_table_lookup (priv->options, "new_subnet_mask"); str = g_hash_table_lookup (priv->options, "new_subnet_mask");
if (str && (inet_pton (AF_INET, str, &tmp_addr) > 0)) { if (str && (inet_pton (AF_INET, str, &tmp_addr) > 0)) {
prefix = nm_utils_ip4_netmask_to_prefix (tmp_addr.s_addr); plen = nm_utils_ip4_netmask_to_prefix (tmp_addr.s_addr);
nm_log_info (LOGD_DHCP4, " prefix %d (%s)", prefix, str); nm_log_info (LOGD_DHCP4, " plen %d (%s)", plen, str);
} else { } else {
/* Get default netmask for the IP according to appropriate class. */ /* Get default netmask for the IP according to appropriate class. */
prefix = nm_utils_ip4_get_default_prefix (nm_ip4_address_get_address (addr)); plen = nm_utils_ip4_get_default_prefix (address.address);
nm_log_info (LOGD_DHCP4, " prefix %d (default)", prefix); nm_log_info (LOGD_DHCP4, " plen %d (default)", plen);
} }
nm_ip4_address_set_prefix (addr, prefix); address.plen = plen;
/* Routes: if the server returns classless static routes, we MUST ignore /* Routes: if the server returns classless static routes, we MUST ignore
* the 'static_routes' option. * the 'static_routes' option.
@@ -1200,8 +1200,7 @@ ip4_options_to_config (NMDHCPClient *self)
} }
} }
nm_ip4_config_take_address (ip4_config, addr); nm_ip4_config_add_address (ip4_config, &address);
addr = NULL;
str = g_hash_table_lookup (priv->options, "new_host_name"); str = g_hash_table_lookup (priv->options, "new_host_name");
if (str) if (str)
@@ -1290,8 +1289,6 @@ ip4_options_to_config (NMDHCPClient *self)
return ip4_config; return ip4_config;
error: error:
if (addr)
nm_ip4_address_unref (addr);
g_object_unref (ip4_config); g_object_unref (ip4_config);
return NULL; return NULL;
} }
@@ -1333,7 +1330,7 @@ ip6_options_to_config (NMDHCPClient *self)
NMDHCPClientPrivate *priv; NMDHCPClientPrivate *priv;
NMIP6Config *ip6_config = NULL; NMIP6Config *ip6_config = NULL;
struct in6_addr tmp_addr; struct in6_addr tmp_addr;
NMIP6Address *addr = NULL; NMPlatformIP6Address address;
char *str = NULL; char *str = NULL;
GHashTableIter iter; GHashTableIter iter;
gpointer key, value; gpointer key, value;
@@ -1359,14 +1356,12 @@ ip6_options_to_config (NMDHCPClient *self)
goto error; goto error;
} }
addr = nm_ip6_address_new (); memset (&address, 0, sizeof (address));
g_assert (addr); address.address = tmp_addr;
nm_ip6_address_set_address (addr, &tmp_addr); address.plen = 128;
/* DHCPv6 IA_NA assignments are single address only */ nm_log_info (LOGD_DHCP6, " address %s", str);
nm_ip6_address_set_prefix (addr, 128);
nm_log_info (LOGD_DHCP6, " address %s/128", str);
nm_ip6_config_take_address (ip6_config, addr); nm_ip6_config_add_address (ip6_config, &address);
} else if (priv->info_only == FALSE) { } else if (priv->info_only == FALSE) {
/* No address in Managed mode is a hard error */ /* No address in Managed mode is a hard error */
goto error; goto error;

17
src/dhcp-manager/nm-dhcp-dhclient.c
View File

@@ -236,10 +236,10 @@ nm_dhcp_dhclient_get_lease_config (const char *iface, const char *uuid, gboolean
for (iter = parsed; iter; iter = g_slist_next (iter)) { for (iter = parsed; iter; iter = g_slist_next (iter)) {
NMIP4Config *ip4; NMIP4Config *ip4;
NMIP4Address *addr; NMPlatformIP4Address address;
const char *data; const char *data;
struct in_addr tmp; struct in_addr tmp;
guint32 prefix; guint32 plen;
struct tm expire; struct tm expire;
hash = iter->data; hash = iter->data;
@@ -295,14 +295,14 @@ nm_dhcp_dhclient_get_lease_config (const char *iface, const char *uuid, gboolean
continue; continue;
ip4 = nm_ip4_config_new (); ip4 = nm_ip4_config_new ();
addr = nm_ip4_address_new (); memset (&address, 0, sizeof (address));
/* IP4 address */ /* IP4 address */
if (!inet_pton (AF_INET, data, &tmp)) { if (!inet_pton (AF_INET, data, &tmp)) {
nm_log_warn (LOGD_DHCP, "couldn't parse DHCP lease file IP4 address '%s'", data); nm_log_warn (LOGD_DHCP, "couldn't parse DHCP lease file IP4 address '%s'", data);
goto error; goto error;
} }
nm_ip4_address_set_address (addr, tmp.s_addr); address.address = tmp.s_addr;
/* Netmask */ /* Netmask */
data = g_hash_table_lookup (hash, "option subnet-mask"); data = g_hash_table_lookup (hash, "option subnet-mask");
@@ -311,12 +311,12 @@ nm_dhcp_dhclient_get_lease_config (const char *iface, const char *uuid, gboolean
nm_log_warn (LOGD_DHCP, "couldn't parse DHCP lease file IP4 subnet mask '%s'", data); nm_log_warn (LOGD_DHCP, "couldn't parse DHCP lease file IP4 subnet mask '%s'", data);
goto error; goto error;
} }
prefix = nm_utils_ip4_netmask_to_prefix (tmp.s_addr); plen = nm_utils_ip4_netmask_to_prefix (tmp.s_addr);
} else { } else {
/* Get default netmask for the IP according to appropriate class. */ /* Get default netmask for the IP according to appropriate class. */
prefix = nm_utils_ip4_get_default_prefix (nm_ip4_address_get_address (addr)); plen = nm_utils_ip4_get_default_prefix (address.address);
} }
nm_ip4_address_set_prefix (addr, prefix); address.plen = plen;
/* Gateway */ /* Gateway */
data = g_hash_table_lookup (hash, "option routers"); data = g_hash_table_lookup (hash, "option routers");
@@ -328,12 +328,11 @@ nm_dhcp_dhclient_get_lease_config (const char *iface, const char *uuid, gboolean
nm_ip4_config_set_gateway (ip4, tmp.s_addr); nm_ip4_config_set_gateway (ip4, tmp.s_addr);
} }
nm_ip4_config_take_address (ip4, addr); nm_ip4_config_add_address (ip4, &address);
leases = g_slist_append (leases, ip4); leases = g_slist_append (leases, ip4);
continue; continue;
error: error:
nm_ip4_address_unref (addr);
g_object_unref (ip4); g_object_unref (ip4);
} }

4
src/dns-manager/nm-dns-utils.c
View File

@@ -79,9 +79,9 @@ nm_dns_utils_get_ip4_rdns_domains (NMIP4Config *ip4)
*/ */
for (i = 0; i < nm_ip4_config_get_num_addresses (ip4); i++) { for (i = 0; i < nm_ip4_config_get_num_addresses (ip4); i++) {
NMIP4Address *addr = nm_ip4_config_get_address (ip4, i); const NMPlatformIP4Address *address = nm_ip4_config_get_address (ip4, i);
add_ip4_to_rdns_array (nm_ip4_address_get_address (addr), domains); add_ip4_to_rdns_array (address->address, domains);
} }
for (i = 0; i < nm_ip4_config_get_num_routes (ip4); i++) { for (i = 0; i < nm_ip4_config_get_num_routes (ip4); i++) {

8
src/dnsmasq-manager/nm-dnsmasq-manager.c
View File

@@ -249,7 +249,7 @@ create_dm_cmd_line (const char *iface,
const char *dm_binary; const char *dm_binary;
NMCmdLine *cmd; NMCmdLine *cmd;
GString *s; GString *s;
NMIP4Address *tmp; const NMPlatformIP4Address *tmp;
struct in_addr addr; struct in_addr addr;
char buf[INET_ADDRSTRLEN + 15]; char buf[INET_ADDRSTRLEN + 15];
char localaddr[INET_ADDRSTRLEN + 1]; char localaddr[INET_ADDRSTRLEN + 1];
@@ -294,7 +294,7 @@ create_dm_cmd_line (const char *iface,
nm_cmd_line_add_string (cmd, "--strict-order"); nm_cmd_line_add_string (cmd, "--strict-order");
s = g_string_new ("--listen-address="); s = g_string_new ("--listen-address=");
addr.s_addr = nm_ip4_address_get_address (tmp); addr.s_addr = tmp->address;
if (!inet_ntop (AF_INET, &addr, &localaddr[0], INET_ADDRSTRLEN)) { if (!inet_ntop (AF_INET, &addr, &localaddr[0], INET_ADDRSTRLEN)) {
char *err_msg = g_strdup_printf ("error converting IP4 address 0x%X", char *err_msg = g_strdup_printf ("error converting IP4 address 0x%X",
ntohl (addr.s_addr)); ntohl (addr.s_addr));
@@ -310,7 +310,7 @@ create_dm_cmd_line (const char *iface,
s = g_string_new ("--dhcp-range="); s = g_string_new ("--dhcp-range=");
/* Add start of address range */ /* Add start of address range */
addr.s_addr = nm_ip4_address_get_address (tmp) + htonl (9); addr.s_addr = tmp->address + htonl (9);
if (!inet_ntop (AF_INET, &addr, &buf[0], INET_ADDRSTRLEN)) { if (!inet_ntop (AF_INET, &addr, &buf[0], INET_ADDRSTRLEN)) {
char *err_msg = g_strdup_printf ("error converting IP4 address 0x%X", char *err_msg = g_strdup_printf ("error converting IP4 address 0x%X",
ntohl (addr.s_addr)); ntohl (addr.s_addr));
@@ -324,7 +324,7 @@ create_dm_cmd_line (const char *iface,
g_string_append_c (s, ','); g_string_append_c (s, ',');
/* Add end of address range */ /* Add end of address range */
addr.s_addr = nm_ip4_address_get_address (tmp) + htonl (99); addr.s_addr = tmp->address + htonl (99);
if (!inet_ntop (AF_INET, &addr, &buf[0], INET_ADDRSTRLEN)) { if (!inet_ntop (AF_INET, &addr, &buf[0], INET_ADDRSTRLEN)) {
char *err_msg = g_strdup_printf ("error converting IP4 address 0x%X", char *err_msg = g_strdup_printf ("error converting IP4 address 0x%X",
ntohl (addr.s_addr)); ntohl (addr.s_addr));

12
src/ip6-manager/nm-ip6-manager.c
View File

@@ -1472,8 +1472,7 @@ nm_ip6_manager_get_ip6_config (NMIP6Manager *manager, int ifindex)
NMIP6Config *config; NMIP6Config *config;
struct rtnl_addr *rtnladdr; struct rtnl_addr *rtnladdr;
struct nl_addr *nladdr; struct nl_addr *nladdr;
struct in6_addr *addr; NMPlatformIP6Address address;
NMIP6Address *ip6addr;
struct rtnl_route *rtnlroute; struct rtnl_route *rtnlroute;
struct rtnl_nexthop *nexthop; struct rtnl_nexthop *nexthop;
struct nl_addr *nldest, *nlgateway; struct nl_addr *nldest, *nlgateway;
@@ -1567,11 +1566,10 @@ nm_ip6_manager_get_ip6_config (NMIP6Manager *manager, int ifindex)
if (!nladdr || nl_addr_get_family (nladdr) != AF_INET6) if (!nladdr || nl_addr_get_family (nladdr) != AF_INET6)
continue; continue;
addr = nl_addr_get_binary_addr (nladdr); memset (&address, 0, sizeof (address));
ip6addr = nm_ip6_address_new (); address.address = *(struct in6_addr *) nl_addr_get_binary_addr (nladdr);
nm_ip6_address_set_prefix (ip6addr, rtnl_addr_get_prefixlen (rtnladdr)); address.plen = rtnl_addr_get_prefixlen (rtnladdr);
nm_ip6_address_set_address (ip6addr, addr); nm_ip6_config_add_address (config, &address);
nm_ip6_config_take_address (config, ip6addr);
} }
/* Add DNS servers */ /* Add DNS servers */

14
src/modem-manager/nm-modem-broadband.c
View File

@@ -631,10 +631,9 @@ static_stage3_done (NMModemBroadband *self)
NMIP4Config *config = NULL; NMIP4Config *config = NULL;
const gchar *address_string; const gchar *address_string;
guint32 address_network; guint32 address_network;
NMIP4Address *addr; NMPlatformIP4Address address;
const gchar **dns; const gchar **dns;
guint i; guint i;
guint prefix;
g_assert (self->priv->ipv4_config); g_assert (self->priv->ipv4_config);
@@ -653,12 +652,11 @@ static_stage3_done (NMModemBroadband *self)
} }
config = nm_ip4_config_new (); config = nm_ip4_config_new ();
addr = nm_ip4_address_new ();
nm_ip4_address_set_address (addr, address_network); memset (&address, 0, sizeof (address));
prefix = mm_bearer_ip_config_get_prefix (self->priv->ipv4_config); address.address = address_network;
if (prefix > 0) address.plen = mm_bearer_ip_config_get_prefix (self->priv->ipv4_config);
nm_ip4_address_set_prefix (addr, prefix); nm_ip4_config_add_address (config, &address);
nm_ip4_config_take_address (config, addr);
nm_log_info (LOGD_MB, " address %s/%d", nm_log_info (LOGD_MB, " address %s/%d",
mm_bearer_ip_config_get_address (self->priv->ipv4_config), mm_bearer_ip_config_get_address (self->priv->ipv4_config),

15
src/modem-manager/nm-modem-old.c
View File

@@ -608,24 +608,23 @@ static_stage3_done (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data)
if (dbus_g_proxy_end_call (proxy, call, &error, if (dbus_g_proxy_end_call (proxy, call, &error,
G_TYPE_VALUE_ARRAY, &ret_array, G_TYPE_VALUE_ARRAY, &ret_array,
G_TYPE_INVALID)) { G_TYPE_INVALID)) {
NMIP4Address *addr; NMPlatformIP4Address address;
int i; int i;
config = nm_ip4_config_new (); config = nm_ip4_config_new ();
memset (&address, 0, sizeof (address));
addr = nm_ip4_address_new ();
nm_log_info (LOGD_MB, "(%s): IPv4 static configuration:", nm_log_info (LOGD_MB, "(%s): IPv4 static configuration:",
nm_modem_get_uid (NM_MODEM (self))); nm_modem_get_uid (NM_MODEM (self)));
/* IP address */ /* IP address */
nm_ip4_address_set_address (addr, g_value_get_uint (g_value_array_get_nth (ret_array, 0))); address.address = g_value_get_uint (g_value_array_get_nth (ret_array, 0));
nm_ip4_address_set_prefix (addr, 32); address.plen = 32;
nm_ip4_config_take_address (config, addr); nm_ip4_config_add_address (config, &address);
nm_log_info (LOGD_MB, " address %s/%d", nm_log_info (LOGD_MB, " address %s/%d",
ip_address_to_string (nm_ip4_address_get_address (addr)), ip_address_to_string (address.address),
nm_ip4_address_get_prefix (addr)); address.plen);
/* DNS servers */ /* DNS servers */
for (i = 1; i < ret_array->n_values; i++) { for (i = 1; i < ret_array->n_values; i++) {

6
src/modem-manager/nm-modem.c
View File

@@ -333,10 +333,10 @@ nm_modem_ip4_pre_commit (NMModem *modem,
*/ */
if ( priv->ip_method == MM_MODEM_IP_METHOD_STATIC if ( priv->ip_method == MM_MODEM_IP_METHOD_STATIC
|| priv->ip_method == MM_MODEM_IP_METHOD_DHCP) { || priv->ip_method == MM_MODEM_IP_METHOD_DHCP) {
NMIP4Address *addr = nm_ip4_config_get_address (config, 0); const NMPlatformIP4Address *address = nm_ip4_config_get_address (config, 0);
g_assert (addr); g_assert (address);
if (nm_ip4_address_get_prefix (addr) == 32) if (address->plen == 32)
nm_platform_link_set_noarp (nm_device_get_ip_ifindex (device)); nm_platform_link_set_noarp (nm_device_get_ip_ifindex (device));
} }
} }

134
src/nm-ip4-config.c
View File

@@ -23,6 +23,7 @@
#include "nm-ip4-config.h" #include "nm-ip4-config.h"
#include "gsystem-local-alloc.h"
#include "nm-platform.h" #include "nm-platform.h"
#include "nm-utils.h" #include "nm-utils.h"
#include "nm-dbus-manager.h" #include "nm-dbus-manager.h"
@@ -39,7 +40,7 @@ typedef struct {
gboolean never_default; gboolean never_default;
guint32 gateway; guint32 gateway;
GSList *addresses; GArray *addresses;
GSList *routes; GSList *routes;
GArray *nameservers; GArray *nameservers;
GPtrArray *domains; GPtrArray *domains;
@@ -106,31 +107,22 @@ same_prefix (guint32 address1, guint32 address2, int plen)
NMIP4Config * NMIP4Config *
nm_ip4_config_capture (int ifindex) nm_ip4_config_capture (int ifindex)
{ {
NMIP4Config *config; NMIP4Config *config = nm_ip4_config_new ();
GArray *addrs_array, *routes_array; NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config);
NMPlatformIP4Address *addrs; GArray *routes_array;
NMPlatformIP4Route *routes; NMPlatformIP4Route *routes;
NMIP4Address *addr;
NMIP4Route *route; NMIP4Route *route;
int i; int i;
addrs_array = nm_platform_ip4_address_get_all (ifindex); g_array_unref (priv->addresses);
if (addrs_array->len == 0) { priv->addresses = nm_platform_ip4_address_get_all (ifindex);
g_array_unref (addrs_array);
/* Require at least one IP address. */
if (!priv->addresses->len) {
g_object_unref (config);
return NULL; return NULL;
} }
config = nm_ip4_config_new ();
addrs = (NMPlatformIP4Address *)addrs_array->data;
for (i = 0; i < addrs_array->len; i++) {
addr = nm_ip4_address_new ();
nm_ip4_address_set_address (addr, addrs[i].address);
nm_ip4_address_set_prefix (addr, addrs[i].plen);
nm_ip4_config_take_address (config, addr);
}
g_array_unref (addrs_array);
routes_array = nm_platform_ip4_route_get_all (ifindex); routes_array = nm_platform_ip4_route_get_all (ifindex);
routes = (NMPlatformIP4Route *)routes_array->data; routes = (NMPlatformIP4Route *)routes_array->data;
for (i = 0; i < routes_array->len; i++) { for (i = 0; i < routes_array->len; i++) {
@@ -155,6 +147,7 @@ nm_ip4_config_capture (int ifindex)
gboolean gboolean
nm_ip4_config_commit (NMIP4Config *config, int ifindex, int priority) nm_ip4_config_commit (NMIP4Config *config, int ifindex, int priority)
{ {
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config);
int mtu = nm_ip4_config_get_mtu (config); int mtu = nm_ip4_config_get_mtu (config);
int i; int i;
@@ -162,23 +155,7 @@ nm_ip4_config_commit (NMIP4Config *config, int ifindex, int priority)
g_return_val_if_fail (config != NULL, FALSE); g_return_val_if_fail (config != NULL, FALSE);
/* Addresses */ /* Addresses */
{ nm_platform_ip4_address_sync (ifindex, priv->addresses);
int count = nm_ip4_config_get_num_addresses (config);
NMIP4Address *config_address;
GArray *addresses = g_array_sized_new (FALSE, FALSE, sizeof (NMPlatformIP4Address), count);
NMPlatformIP4Address address;
for (i = 0; i < count; i++) {
config_address = nm_ip4_config_get_address (config, i);
memset (&address, 0, sizeof (address));
address.address = nm_ip4_address_get_address (config_address);
address.plen = nm_ip4_address_get_prefix (config_address);
g_array_append_val (addresses, address);
}
nm_platform_ip4_address_sync (ifindex, addresses);
g_array_unref (addresses);
}
/* Routes */ /* Routes */
{ {
@@ -250,8 +227,16 @@ nm_ip4_config_merge_setting (NMIP4Config *config, NMSettingIP4Config *setting)
} }
/* Addresses */ /* Addresses */
for (i = 0; i < naddresses; i++) for (i = 0; i < naddresses; i++) {
nm_ip4_config_add_address (config, nm_setting_ip4_config_get_address (setting, i)); NMIP4Address *s_addr = nm_setting_ip4_config_get_address (setting, i);
NMPlatformIP4Address address;
memset (&address, 0, sizeof (address));
address.address = nm_ip4_address_get_address (s_addr);
address.plen = nm_ip4_address_get_prefix (s_addr);
nm_ip4_config_add_address (config, &address);
}
/* Routes */ /* Routes */
if (nm_setting_ip4_config_get_ignore_auto_routes (setting)) if (nm_setting_ip4_config_get_ignore_auto_routes (setting))
@@ -280,11 +265,9 @@ nm_ip4_config_destination_is_direct (NMIP4Config *config, guint32 network, int p
int i; int i;
for (i = 0; i < naddresses; i++) { for (i = 0; i < naddresses; i++) {
NMIP4Address *item = nm_ip4_config_get_address (config, i); const NMPlatformIP4Address *item = nm_ip4_config_get_address (config, i);
guint32 item_address = nm_ip4_address_get_address (item);
int item_plen = nm_ip4_address_get_prefix (item);
if (item_plen <= plen && same_prefix (item_address, network, item_plen)) if (item->plen <= plen && same_prefix (item->address, network, item->plen))
return TRUE; return TRUE;
} }
@@ -332,43 +315,31 @@ nm_ip4_config_reset_addresses (NMIP4Config *config)
{ {
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config); NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config);
g_slist_free_full (priv->addresses, (GDestroyNotify) nm_ip4_address_unref); g_array_set_size (priv->addresses, 0);
priv->addresses = NULL;
} }
static gboolean static gboolean
addresses_are_duplicate (NMIP4Address *a, NMIP4Address *b) addresses_are_duplicate (const NMPlatformIP4Address *a, const NMPlatformIP4Address *b)
{ {
if (nm_ip4_address_get_address (a) != nm_ip4_address_get_address (b)) return a->address == b->address;
return FALSE;
return TRUE;
} }
void void
nm_ip4_config_add_address (NMIP4Config *config, NMIP4Address *new) nm_ip4_config_add_address (NMIP4Config *config, const NMPlatformIP4Address *new)
{ {
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config); NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config);
GSList *iter; int i;
for (iter = priv->addresses; iter; iter = g_slist_next (iter)) { for (i = 0; i < priv->addresses->len; i++ ) {
NMIP4Address *item = (NMIP4Address *) iter->data; NMPlatformIP4Address *item = &g_array_index (priv->addresses, NMPlatformIP4Address, i);
if (addresses_are_duplicate (item, new)) { if (addresses_are_duplicate (item, new)) {
nm_ip4_address_unref (item); memcpy (item, new, sizeof (*item));
iter->data = nm_ip4_address_dup (new);
return; return;
} }
} }
priv->addresses = g_slist_append (priv->addresses, nm_ip4_address_dup (new)); g_array_append_val (priv->addresses, *new);
}
void
nm_ip4_config_take_address (NMIP4Config *config, NMIP4Address *address)
{
nm_ip4_config_add_address (config, address);
nm_ip4_address_unref (address);
} }
guint guint
@@ -376,15 +347,15 @@ nm_ip4_config_get_num_addresses (NMIP4Config *config)
{ {
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config); NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config);
return g_slist_length (priv->addresses); return priv->addresses->len;
} }
NMIP4Address * const NMPlatformIP4Address *
nm_ip4_config_get_address (NMIP4Config *config, guint i) nm_ip4_config_get_address (NMIP4Config *config, guint i)
{ {
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config); NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config);
return (NMIP4Address *) g_slist_nth_data (priv->addresses, i); return &g_array_index (priv->addresses, NMPlatformIP4Address, i);
} }
/******************************************************************/ /******************************************************************/
@@ -740,10 +711,9 @@ nm_ip4_config_hash (NMIP4Config *config, GChecksum *sum, gboolean dns_only)
hash_u32 (sum, nm_ip4_config_get_gateway (config)); hash_u32 (sum, nm_ip4_config_get_gateway (config));
for (i = 0; i < nm_ip4_config_get_num_addresses (config); i++) { for (i = 0; i < nm_ip4_config_get_num_addresses (config); i++) {
NMIP4Address *a = nm_ip4_config_get_address (config, i); const NMPlatformIP4Address *address = nm_ip4_config_get_address (config, i);
hash_u32 (sum, address->address);
hash_u32 (sum, nm_ip4_address_get_address (a)); hash_u32 (sum, address->plen);
hash_u32 (sum, nm_ip4_address_get_prefix (a));
} }
for (i = 0; i < nm_ip4_config_get_num_routes (config); i++) { for (i = 0; i < nm_ip4_config_get_num_routes (config); i++) {
@@ -818,6 +788,7 @@ nm_ip4_config_init (NMIP4Config *config)
{ {
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config); NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config);
priv->addresses = g_array_new (FALSE, FALSE, sizeof (NMPlatformIP4Address));
priv->nameservers = g_array_new (FALSE, FALSE, sizeof (guint32)); priv->nameservers = g_array_new (FALSE, FALSE, sizeof (guint32));
priv->domains = g_ptr_array_new_with_free_func (g_free); priv->domains = g_ptr_array_new_with_free_func (g_free);
priv->searches = g_ptr_array_new_with_free_func (g_free); priv->searches = g_ptr_array_new_with_free_func (g_free);
@@ -830,7 +801,7 @@ finalize (GObject *object)
{ {
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (object); NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (object);
g_slist_free_full (priv->addresses, (GDestroyNotify) nm_ip4_address_unref); g_array_unref (priv->addresses);
g_slist_free_full (priv->routes, (GDestroyNotify) nm_ip4_route_unref); g_slist_free_full (priv->routes, (GDestroyNotify) nm_ip4_route_unref);
g_array_unref (priv->nameservers); g_array_unref (priv->nameservers);
g_ptr_array_unref (priv->domains); g_ptr_array_unref (priv->domains);
@@ -846,11 +817,30 @@ static void
get_property (GObject *object, guint prop_id, get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec) GValue *value, GParamSpec *pspec)
{ {
NMIP4Config *config = NM_IP4_CONFIG (object);
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (object); NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (object);
in_addr_t gateway = nm_ip4_config_get_gateway (config);
switch (prop_id) { switch (prop_id) {
case PROP_ADDRESSES: case PROP_ADDRESSES:
nm_utils_ip4_addresses_to_gvalue (priv->addresses, value); {
GPtrArray *addresses = g_ptr_array_new ();
int naddr = nm_ip4_config_get_num_addresses (config);
int i;
for (i = 0; i < naddr; i++) {
const NMPlatformIP4Address *address = nm_ip4_config_get_address (config, i);
GArray *array = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 3);
g_array_append_val (array, address->address);
g_array_append_val (array, address->plen);
g_array_append_val (array, gateway);
g_ptr_array_add (addresses, array);
}
g_value_take_boxed (value, addresses);
}
break; break;
case PROP_ROUTES: case PROP_ROUTES:
nm_utils_ip4_routes_to_gvalue (priv->routes, value); nm_utils_ip4_routes_to_gvalue (priv->routes, value);

8
src/nm-ip4-config.h
View File

@@ -23,7 +23,8 @@
#include <glib-object.h> #include <glib-object.h>
/* NMIP4Address and NMIP4Route types */ #include "nm-platform.h"
/* NMIP4Route type */
#include "nm-setting-ip4-config.h" #include "nm-setting-ip4-config.h"
#define NM_TYPE_IP4_CONFIG (nm_ip4_config_get_type ()) #define NM_TYPE_IP4_CONFIG (nm_ip4_config_get_type ())
@@ -72,10 +73,9 @@ guint32 nm_ip4_config_get_gateway (NMIP4Config *config);
/* Addresses */ /* Addresses */
void nm_ip4_config_reset_addresses (NMIP4Config *config); void nm_ip4_config_reset_addresses (NMIP4Config *config);
void nm_ip4_config_take_address (NMIP4Config *config, NMIP4Address *address); void nm_ip4_config_add_address (NMIP4Config *config, const NMPlatformIP4Address *address);
void nm_ip4_config_add_address (NMIP4Config *config, NMIP4Address *address);
guint nm_ip4_config_get_num_addresses (NMIP4Config *config); guint nm_ip4_config_get_num_addresses (NMIP4Config *config);
NMIP4Address *nm_ip4_config_get_address (NMIP4Config *config, guint i); const NMPlatformIP4Address *nm_ip4_config_get_address (NMIP4Config *config, guint i);
/* Routes */ /* Routes */
void nm_ip4_config_reset_routes (NMIP4Config *config); void nm_ip4_config_reset_routes (NMIP4Config *config);

157
src/nm-ip6-config.c
View File

@@ -23,6 +23,8 @@
#include "nm-ip6-config.h" #include "nm-ip6-config.h"
#include "nm-glib-compat.h"
#include "gsystem-local-alloc.h"
#include "nm-platform.h" #include "nm-platform.h"
#include "nm-utils.h" #include "nm-utils.h"
#include "nm-dbus-manager.h" #include "nm-dbus-manager.h"
@@ -38,7 +40,7 @@ typedef struct {
gboolean never_default; gboolean never_default;
struct in6_addr gateway; struct in6_addr gateway;
GSList *addresses; GArray *addresses;
GSList *routes; GSList *routes;
GArray *nameservers; GArray *nameservers;
GPtrArray *domains; GPtrArray *domains;
@@ -108,31 +110,21 @@ same_prefix (const struct in6_addr *address1, const struct in6_addr *address2, i
NMIP6Config * NMIP6Config *
nm_ip6_config_capture (int ifindex) nm_ip6_config_capture (int ifindex)
{ {
NMIP6Config *config; NMIP6Config *config = nm_ip6_config_new ();
GArray *addrs_array, *routes_array; NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config);
NMPlatformIP6Address *addrs; GArray *routes_array;
NMPlatformIP6Route *routes; NMPlatformIP6Route *routes;
NMIP6Address *addr;
NMIP6Route *route; NMIP6Route *route;
int i; int i;
addrs_array = nm_platform_ip6_address_get_all (ifindex); g_array_unref (priv->addresses);
if (addrs_array->len == 0) { priv->addresses = nm_platform_ip6_address_get_all (ifindex);
g_array_unref (addrs_array);
if (!priv->addresses->len) {
g_object_unref (config);
return NULL; return NULL;
} }
config = nm_ip6_config_new ();
addrs = (NMPlatformIP6Address *)addrs_array->data;
for (i = 0; i < addrs_array->len; i++) {
addr = nm_ip6_address_new ();
nm_ip6_address_set_address (addr, &addrs[i].address);
nm_ip6_address_set_prefix (addr, addrs[i].plen);
nm_ip6_config_take_address (config, addr);
}
g_array_unref (addrs_array);
routes_array = nm_platform_ip6_route_get_all (ifindex); routes_array = nm_platform_ip6_route_get_all (ifindex);
routes = (NMPlatformIP6Route *)routes_array->data; routes = (NMPlatformIP6Route *)routes_array->data;
for (i = 0; i < routes_array->len; i++) { for (i = 0; i < routes_array->len; i++) {
@@ -157,29 +149,14 @@ nm_ip6_config_capture (int ifindex)
gboolean gboolean
nm_ip6_config_commit (NMIP6Config *config, int ifindex, int priority) nm_ip6_config_commit (NMIP6Config *config, int ifindex, int priority)
{ {
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config);
int i; int i;
g_return_val_if_fail (ifindex > 0, FALSE); g_return_val_if_fail (ifindex > 0, FALSE);
g_return_val_if_fail (config != NULL, FALSE); g_return_val_if_fail (config != NULL, FALSE);
/* Addresses */ /* Addresses */
{ nm_platform_ip6_address_sync (ifindex, priv->addresses);
int count = nm_ip6_config_get_num_addresses (config);
NMIP6Address *config_address;
GArray *addresses = g_array_sized_new (FALSE, FALSE, sizeof (NMPlatformIP6Address), count);
NMPlatformIP6Address address;
for (i = 0; i < count; i++) {
config_address = nm_ip6_config_get_address (config, i);
memset (&address, 0, sizeof (address));
address.address = *nm_ip6_address_get_address (config_address);
address.plen = nm_ip6_address_get_prefix (config_address);
g_array_append_val (addresses, address);
}
nm_platform_ip6_address_sync (ifindex, addresses);
g_array_unref (addresses);
}
/* Routes */ /* Routes */
{ {
@@ -253,8 +230,16 @@ nm_ip6_config_merge_setting (NMIP6Config *config, NMSettingIP6Config *setting)
} }
/* Addresses */ /* Addresses */
for (i = 0; i < naddresses; i++) for (i = 0; i < naddresses; i++) {
nm_ip6_config_add_address (config, nm_setting_ip6_config_get_address (setting, i)); NMIP6Address *s_addr = nm_setting_ip6_config_get_address (setting, i);
NMPlatformIP6Address address;
memset (&address, 0, sizeof (address));
address.address = *nm_ip6_address_get_address (s_addr);
address.plen = nm_ip6_address_get_prefix (s_addr);
nm_ip6_config_add_address (config, &address);
}
/* Routes */ /* Routes */
if (nm_setting_ip6_config_get_ignore_auto_routes (setting)) if (nm_setting_ip6_config_get_ignore_auto_routes (setting))
@@ -319,16 +304,13 @@ nm_ip6_config_merge (NMIP6Config *dst, NMIP6Config *src)
gboolean gboolean
nm_ip6_config_destination_is_direct (NMIP6Config *config, const struct in6_addr *network, int plen) nm_ip6_config_destination_is_direct (NMIP6Config *config, const struct in6_addr *network, int plen)
{ {
int num; int num = nm_ip6_config_get_num_addresses (config);
int i; int i;
num = nm_ip6_config_get_num_addresses (config);
for (i = 0; i < num; i++) { for (i = 0; i < num; i++) {
NMIP6Address *item = nm_ip6_config_get_address (config, i); NMPlatformIP6Address *item = nm_ip6_config_get_address (config, i);
const struct in6_addr *item_address = nm_ip6_address_get_address (item);
guint32 item_plen = nm_ip6_address_get_prefix (item);
if (item_plen <= plen && same_prefix (item_address, network, item_plen)) if (item->plen <= plen && same_prefix (&item->address, network, item->plen))
return TRUE; return TRUE;
} }
@@ -379,43 +361,31 @@ nm_ip6_config_reset_addresses (NMIP6Config *config)
{ {
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config); NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config);
g_slist_free_full (priv->addresses, (GDestroyNotify) nm_ip6_address_unref); g_array_set_size (priv->nameservers, 0);
priv->addresses = NULL;
} }
static gboolean static gboolean
addresses_are_duplicate (NMIP6Address *a, NMIP6Address *b) addresses_are_duplicate (const NMPlatformIP6Address *a, const NMPlatformIP6Address *b)
{ {
if (nm_ip6_address_get_address (a) != nm_ip6_address_get_address (b)) return IN6_ARE_ADDR_EQUAL (&a->address, &b->address);
return FALSE;
return TRUE;
} }
void void
nm_ip6_config_add_address (NMIP6Config *config, NMIP6Address *new) nm_ip6_config_add_address (NMIP6Config *config, const NMPlatformIP6Address *new)
{ {
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config); NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config);
GSList *iter; int i;
for (iter = priv->addresses; iter; iter = g_slist_next (iter)) { for (i = 0; i < priv->addresses->len; i++ ) {
NMIP6Address *item = (NMIP6Address *) iter->data; NMPlatformIP6Address *item = &g_array_index (priv->addresses, NMPlatformIP6Address, i);
if (addresses_are_duplicate (item, new)) { if (addresses_are_duplicate (item, new)) {
nm_ip6_address_unref (item); memcpy (item, new, sizeof (*item));
iter->data = nm_ip6_address_dup (new);
return; return;
} }
} }
priv->addresses = g_slist_append (priv->addresses, nm_ip6_address_dup (new)); g_array_append_val (priv->addresses, *new);
}
void
nm_ip6_config_take_address (NMIP6Config *config, NMIP6Address *address)
{
nm_ip6_config_add_address (config, address);
nm_ip6_address_unref (address);
} }
guint guint
@@ -423,15 +393,15 @@ nm_ip6_config_get_num_addresses (NMIP6Config *config)
{ {
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config); NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config);
return g_slist_length (priv->addresses); return priv->addresses->len;
} }
NMIP6Address * NMPlatformIP6Address *
nm_ip6_config_get_address (NMIP6Config *config, guint i) nm_ip6_config_get_address (NMIP6Config *config, guint i)
{ {
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config); NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config);
return (NMIP6Address *) g_slist_nth_data (priv->addresses, i); return &g_array_index (priv->addresses, NMPlatformIP6Address, i);
} }
/******************************************************************/ /******************************************************************/
@@ -684,10 +654,10 @@ nm_ip6_config_hash (NMIP6Config *config, GChecksum *sum, gboolean dns_only)
hash_in6addr (sum, nm_ip6_config_get_gateway (config)); hash_in6addr (sum, nm_ip6_config_get_gateway (config));
for (i = 0; i < nm_ip6_config_get_num_addresses (config); i++) { for (i = 0; i < nm_ip6_config_get_num_addresses (config); i++) {
NMIP6Address *a = nm_ip6_config_get_address (config, i); NMPlatformIP6Address *address = nm_ip6_config_get_address (config, i);
hash_in6addr (sum, nm_ip6_address_get_address (a)); hash_in6addr (sum, &address->address);
hash_u32 (sum, nm_ip6_address_get_prefix (a)); hash_u32 (sum, address->plen);
} }
for (i = 0; i < nm_ip6_config_get_num_routes (config); i++) { for (i = 0; i < nm_ip6_config_get_num_routes (config); i++) {
@@ -752,6 +722,7 @@ nm_ip6_config_init (NMIP6Config *config)
{ {
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config); NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config);
priv->addresses = g_array_new (FALSE, TRUE, sizeof (NMPlatformIP6Address));
priv->nameservers = g_array_new (FALSE, TRUE, sizeof (struct in6_addr)); priv->nameservers = g_array_new (FALSE, TRUE, sizeof (struct in6_addr));
priv->domains = g_ptr_array_new_with_free_func (g_free); priv->domains = g_ptr_array_new_with_free_func (g_free);
priv->searches = g_ptr_array_new_with_free_func (g_free); priv->searches = g_ptr_array_new_with_free_func (g_free);
@@ -762,7 +733,7 @@ finalize (GObject *object)
{ {
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (object); NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (object);
g_slist_free_full (priv->addresses, (GDestroyNotify) nm_ip6_address_unref); g_array_unref (priv->addresses);
g_slist_free_full (priv->routes, (GDestroyNotify) nm_ip6_route_unref); g_slist_free_full (priv->routes, (GDestroyNotify) nm_ip6_route_unref);
g_array_unref (priv->nameservers); g_array_unref (priv->nameservers);
g_ptr_array_unref (priv->domains); g_ptr_array_unref (priv->domains);
@@ -796,11 +767,51 @@ static void
get_property (GObject *object, guint prop_id, get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec) GValue *value, GParamSpec *pspec)
{ {
NMIP6Config *config = NM_IP6_CONFIG (object);
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (object); NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (object);
switch (prop_id) { switch (prop_id) {
case PROP_ADDRESSES: case PROP_ADDRESSES:
nm_utils_ip6_addresses_to_gvalue (priv->addresses, value); {
GPtrArray *addresses = g_ptr_array_new ();
const struct in6_addr *gateway = nm_ip6_config_get_gateway (config);
int naddr = nm_ip6_config_get_num_addresses (config);
int i;
for (i = 0; i < naddr; i++) {
NMPlatformIP6Address *address = nm_ip6_config_get_address (config, i);
GValueArray *array = g_value_array_new (3);
GValue element = G_VALUE_INIT;
GByteArray *ba;
/* IP address */
g_value_init (&element, DBUS_TYPE_G_UCHAR_ARRAY);
ba = g_byte_array_new ();
g_byte_array_append (ba, (guint8 *) &address->address, 16);
g_value_take_boxed (&element, ba);
g_value_array_append (array, &element);
g_value_unset (&element);
/* Prefix */
g_value_init (&element, G_TYPE_UINT);
g_value_set_uint (&element, address->plen);
g_value_array_append (array, &element);
g_value_unset (&element);
/* Gateway */
g_value_init (&element, DBUS_TYPE_G_UCHAR_ARRAY);
ba = g_byte_array_new ();
g_byte_array_append (ba, (guint8 *) gateway, 16);
g_value_take_boxed (&element, ba);
g_value_array_append (array, &element);
g_value_unset (&element);
g_ptr_array_add (addresses, array);
}
g_value_take_boxed (value, addresses);
}
break; break;
case PROP_NAMESERVERS: case PROP_NAMESERVERS:
nameservers_to_gvalue (priv->nameservers, value); nameservers_to_gvalue (priv->nameservers, value);

9
src/nm-ip6-config.h
View File

@@ -23,8 +23,10 @@
#include <glib-object.h> #include <glib-object.h>
/* NMIP6Address and NMIP6Route types */ #include "nm-platform.h"
/* NMIP6Route type */
#include "nm-setting-ip6-config.h" #include "nm-setting-ip6-config.h"
#include "nm-platform.h"
#define NM_TYPE_IP6_CONFIG (nm_ip6_config_get_type ()) #define NM_TYPE_IP6_CONFIG (nm_ip6_config_get_type ())
#define NM_IP6_CONFIG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NM_TYPE_IP6_CONFIG, NMIP6Config)) #define NM_IP6_CONFIG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NM_TYPE_IP6_CONFIG, NMIP6Config))
@@ -72,10 +74,9 @@ const struct in6_addr *nm_ip6_config_get_gateway (NMIP6Config *config);
/* Addresses */ /* Addresses */
void nm_ip6_config_reset_addresses (NMIP6Config *config); void nm_ip6_config_reset_addresses (NMIP6Config *config);
void nm_ip6_config_take_address (NMIP6Config *config, NMIP6Address *address); void nm_ip6_config_add_address (NMIP6Config *config, const NMPlatformIP6Address *address);
void nm_ip6_config_add_address (NMIP6Config *config, NMIP6Address *address);
guint nm_ip6_config_get_num_addresses (NMIP6Config *config); guint nm_ip6_config_get_num_addresses (NMIP6Config *config);
NMIP6Address *nm_ip6_config_get_address (NMIP6Config *config, guint i); NMPlatformIP6Address *nm_ip6_config_get_address (NMIP6Config *config, guint i);
/* Routes */ /* Routes */
void nm_ip6_config_reset_routes (NMIP6Config *config); void nm_ip6_config_reset_routes (NMIP6Config *config);

12
src/nm-policy.c
View File

@@ -403,8 +403,7 @@ update_system_hostname (NMPolicy *policy, NMDevice *best4, NMDevice *best6)
*/ */
if (best4) { if (best4) {
NMIP4Config *ip4_config; NMIP4Config *ip4_config;
NMIP4Address *addr4; const NMPlatformIP4Address *addr4;
guint32 addrbytes;
ip4_config = nm_device_get_ip4_config (best4); ip4_config = nm_device_get_ip4_config (best4);
if ( !ip4_config if ( !ip4_config
@@ -418,13 +417,11 @@ update_system_hostname (NMPolicy *policy, NMDevice *best4, NMDevice *best6)
addr4 = nm_ip4_config_get_address (ip4_config, 0); addr4 = nm_ip4_config_get_address (ip4_config, 0);
g_assert (addr4); /* checked for > 1 address above */ g_assert (addr4); /* checked for > 1 address above */
addrbytes = nm_ip4_address_get_address (addr4); policy->lookup_addr = g_inet_address_new_from_bytes ((guint8 *) &addr4->address,
policy->lookup_addr = g_inet_address_new_from_bytes ((guint8 *)&addrbytes,
G_SOCKET_FAMILY_IPV4); G_SOCKET_FAMILY_IPV4);
} else { } else {
NMIP6Config *ip6_config; NMIP6Config *ip6_config;
NMIP6Address *addr6; NMPlatformIP6Address *addr6;
const struct in6_addr *addrbytes;
ip6_config = nm_device_get_ip6_config (best6); ip6_config = nm_device_get_ip6_config (best6);
if ( !ip6_config if ( !ip6_config
@@ -438,8 +435,7 @@ update_system_hostname (NMPolicy *policy, NMDevice *best4, NMDevice *best6)
addr6 = nm_ip6_config_get_address (ip6_config, 0); addr6 = nm_ip6_config_get_address (ip6_config, 0);
g_assert (addr6); /* checked for > 1 address above */ g_assert (addr6); /* checked for > 1 address above */
addrbytes = nm_ip6_address_get_address (addr6); policy->lookup_addr = g_inet_address_new_from_bytes ((guint8 *) &addr6->address,
policy->lookup_addr = g_inet_address_new_from_bytes ((guint8 *)&addrbytes,
G_SOCKET_FAMILY_IPV6); G_SOCKET_FAMILY_IPV6);
} }

17
src/ppp-manager/nm-ppp-manager.c
View File

@@ -508,7 +508,7 @@ impl_ppp_manager_set_ip4_config (NMPPPManager *manager,
NMConnection *connection; NMConnection *connection;
NMSettingPPP *s_ppp; NMSettingPPP *s_ppp;
NMIP4Config *config; NMIP4Config *config;
NMIP4Address *addr; NMPlatformIP4Address address;
GValue *val; GValue *val;
int i; int i;
@@ -517,28 +517,27 @@ impl_ppp_manager_set_ip4_config (NMPPPManager *manager,
remove_timeout_handler (manager); remove_timeout_handler (manager);
config = nm_ip4_config_new (); config = nm_ip4_config_new ();
addr = nm_ip4_address_new (); memset (&address, 0, sizeof (address));
nm_ip4_address_set_prefix (addr, 32); address.plen = 32;
val = (GValue *) g_hash_table_lookup (config_hash, NM_PPP_IP4_CONFIG_GATEWAY); val = (GValue *) g_hash_table_lookup (config_hash, NM_PPP_IP4_CONFIG_GATEWAY);
if (val) { if (val) {
nm_ip4_address_set_gateway (addr, g_value_get_uint (val)); nm_ip4_config_set_gateway (config, g_value_get_uint (val));
nm_ip4_config_set_ptp_address (config, g_value_get_uint (val)); nm_ip4_config_set_ptp_address (config, g_value_get_uint (val));
} }
val = (GValue *) g_hash_table_lookup (config_hash, NM_PPP_IP4_CONFIG_ADDRESS); val = (GValue *) g_hash_table_lookup (config_hash, NM_PPP_IP4_CONFIG_ADDRESS);
if (val) if (val)
nm_ip4_address_set_address (addr, g_value_get_uint (val)); address.address = g_value_get_uint (val);
val = (GValue *) g_hash_table_lookup (config_hash, NM_PPP_IP4_CONFIG_PREFIX); val = (GValue *) g_hash_table_lookup (config_hash, NM_PPP_IP4_CONFIG_PREFIX);
if (val) if (val)
nm_ip4_address_set_prefix (addr, g_value_get_uint (val)); address.plen = g_value_get_uint (val);
if (nm_ip4_address_get_address (addr) && nm_ip4_address_get_prefix (addr)) { if (address.address && address.plen) {
nm_ip4_config_take_address (config, addr); nm_ip4_config_add_address (config, &address);
} else { } else {
nm_log_err (LOGD_PPP, "invalid IPv4 address received!"); nm_log_err (LOGD_PPP, "invalid IPv4 address received!");
nm_ip4_address_unref (addr);
goto out; goto out;
} }

1
src/tests/Makefile.am
View File

@@ -3,6 +3,7 @@ INCLUDES = \
-I$(top_builddir)/include \ -I$(top_builddir)/include \
-I$(top_srcdir)/libnm-util \ -I$(top_srcdir)/libnm-util \
-I$(top_builddir)/libnm-util \ -I$(top_builddir)/libnm-util \
-I$(top_srcdir)/src/platform \
-I$(top_srcdir)/src/dhcp-manager \ -I$(top_srcdir)/src/dhcp-manager \
-I$(top_srcdir)/src \ -I$(top_srcdir)/src \
-I$(top_builddir)/src -I$(top_builddir)/src

34
src/tests/test-dhcp-options.c
View File

@@ -101,7 +101,7 @@ test_generic_options (const char *client)
{ {
GHashTable *options; GHashTable *options;
NMIP4Config *ip4_config; NMIP4Config *ip4_config;
NMIP4Address *addr; const NMPlatformIP4Address *address;
NMIP4Route *route; NMIP4Route *route;
struct in_addr tmp; struct in_addr tmp;
const char *expected_addr = "192.168.1.106"; const char *expected_addr = "192.168.1.106";
@@ -123,14 +123,14 @@ test_generic_options (const char *client)
/* IP4 address */ /* IP4 address */
ASSERT (nm_ip4_config_get_num_addresses (ip4_config) == 1, ASSERT (nm_ip4_config_get_num_addresses (ip4_config) == 1,
"dhcp-generic", "unexpected number of IP addresses"); "dhcp-generic", "unexpected number of IP addresses");
addr = nm_ip4_config_get_address (ip4_config, 0); address = nm_ip4_config_get_address (ip4_config, 0);
ASSERT (inet_pton (AF_INET, expected_addr, &tmp) > 0, ASSERT (inet_pton (AF_INET, expected_addr, &tmp) > 0,
"dhcp-generic", "couldn't convert expected IP address"); "dhcp-generic", "couldn't convert expected IP address");
ASSERT (nm_ip4_address_get_address (addr) == tmp.s_addr, ASSERT (address->address == tmp.s_addr,
"dhcp-generic", "unexpected IP address"); "dhcp-generic", "unexpected IP address");
ASSERT (nm_ip4_address_get_prefix (addr) == 24, ASSERT (address->plen == 24,
"dhcp-generic", "unexpected IP address prefix length"); "dhcp-generic", "unexpected IP address prefix length");
/* Gateway */ /* Gateway */
@@ -219,7 +219,7 @@ test_wins_options (const char *client)
{ {
GHashTable *options; GHashTable *options;
NMIP4Config *ip4_config; NMIP4Config *ip4_config;
NMIP4Address *addr; const NMPlatformIP4Address *address;
struct in_addr tmp; struct in_addr tmp;
const char *expected_wins1 = "63.12.199.5"; const char *expected_wins1 = "63.12.199.5";
const char *expected_wins2 = "150.4.88.120"; const char *expected_wins2 = "150.4.88.120";
@@ -234,7 +234,7 @@ test_wins_options (const char *client)
/* IP4 address */ /* IP4 address */
ASSERT (nm_ip4_config_get_num_addresses (ip4_config) == 1, ASSERT (nm_ip4_config_get_num_addresses (ip4_config) == 1,
"dhcp-wins", "unexpected number of IP addresses"); "dhcp-wins", "unexpected number of IP addresses");
addr = nm_ip4_config_get_address (ip4_config, 0); address = nm_ip4_config_get_address (ip4_config, 0);
ASSERT (nm_ip4_config_get_num_wins (ip4_config) == 2, ASSERT (nm_ip4_config_get_num_wins (ip4_config) == 2,
"dhcp-wins", "unexpected number of WINS servers"); "dhcp-wins", "unexpected number of WINS servers");
@@ -284,12 +284,10 @@ ip4_test_gateway (const char *test,
NMIP4Config *ip4_config, NMIP4Config *ip4_config,
const char *expected_gw) const char *expected_gw)
{ {
NMIP4Address *addr;
struct in_addr tmp; struct in_addr tmp;
ASSERT (nm_ip4_config_get_num_addresses (ip4_config) == 1, ASSERT (nm_ip4_config_get_num_addresses (ip4_config) == 1,
test, "unexpected number of IP addresses"); test, "unexpected number of IP addresses");
addr = nm_ip4_config_get_address (ip4_config, 0);
ASSERT (inet_pton (AF_INET, expected_gw, &tmp) > 0, ASSERT (inet_pton (AF_INET, expected_gw, &tmp) > 0,
test, "couldn't convert expected IP gateway"); test, "couldn't convert expected IP gateway");
ASSERT (nm_ip4_config_get_gateway (ip4_config) == tmp.s_addr, ASSERT (nm_ip4_config_get_gateway (ip4_config) == tmp.s_addr,
@@ -718,7 +716,7 @@ test_ip4_missing_prefix (const char *client, const char *ip, guint32 expected_pr
{ {
GHashTable *options; GHashTable *options;
NMIP4Config *ip4_config; NMIP4Config *ip4_config;
NMIP4Address *addr; const NMPlatformIP4Address *address;
options = fill_table (generic_options, NULL); options = fill_table (generic_options, NULL);
g_hash_table_insert (options, "new_ip_address", string_to_byte_array_gvalue (ip)); g_hash_table_insert (options, "new_ip_address", string_to_byte_array_gvalue (ip));
@@ -731,13 +729,13 @@ test_ip4_missing_prefix (const char *client, const char *ip, guint32 expected_pr
ASSERT (nm_ip4_config_get_num_addresses (ip4_config) == 1, ASSERT (nm_ip4_config_get_num_addresses (ip4_config) == 1,
"dhcp-ip4-missing-prefix", "unexpected number of IP4 addresses (not 1)"); "dhcp-ip4-missing-prefix", "unexpected number of IP4 addresses (not 1)");
addr = nm_ip4_config_get_address (ip4_config, 0); address = nm_ip4_config_get_address (ip4_config, 0);
ASSERT (addr != NULL, ASSERT (address,
"dhcp-ip4-missing-prefix", "missing IP4 address #1"); "dhcp-ip4-missing-prefix", "missing IP4 address #1");
ASSERT (nm_ip4_address_get_prefix (addr) == expected_prefix, ASSERT (address->plen == expected_prefix,
"dhcp-ip4-missing-prefix", "unexpected IP4 address prefix %d (expected %d)", "dhcp-ip4-missing-prefix", "unexpected IP4 address prefix %d (expected %d)",
nm_ip4_address_get_prefix (addr), expected_prefix); address->plen, expected_prefix);
g_hash_table_destroy (options); g_hash_table_destroy (options);
} }
@@ -747,7 +745,7 @@ test_ip4_prefix_classless (const char *client)
{ {
GHashTable *options; GHashTable *options;
NMIP4Config *ip4_config; NMIP4Config *ip4_config;
NMIP4Address *addr; const NMPlatformIP4Address *address;
/* Ensure that the missing-subnet-mask handler doesn't mangle classless /* Ensure that the missing-subnet-mask handler doesn't mangle classless
* subnet masks at all. The handler should trigger only if the server * subnet masks at all. The handler should trigger only if the server
@@ -765,13 +763,13 @@ test_ip4_prefix_classless (const char *client)
ASSERT (nm_ip4_config_get_num_addresses (ip4_config) == 1, ASSERT (nm_ip4_config_get_num_addresses (ip4_config) == 1,
"dhcp-ip4-prefix-classless", "unexpected number of IP4 addresses (not 1)"); "dhcp-ip4-prefix-classless", "unexpected number of IP4 addresses (not 1)");
addr = nm_ip4_config_get_address (ip4_config, 0); address = nm_ip4_config_get_address (ip4_config, 0);
ASSERT (addr != NULL, ASSERT (address,
"dhcp-ip4-prefix-classless", "missing IP4 address #1"); "dhcp-ip4-prefix-classless", "missing IP4 address #1");
ASSERT (nm_ip4_address_get_prefix (addr) == 22, ASSERT (address->plen == 22,
"dhcp-ip4-prefix-classless", "unexpected IP4 address prefix %d (expected 22)", "dhcp-ip4-prefix-classless", "unexpected IP4 address prefix %d (expected 22)",
nm_ip4_address_get_prefix (addr)); address->plen);
g_hash_table_destroy (options); g_hash_table_destroy (options);
} }

60
src/vpn-manager/nm-vpn-connection.c
View File

@@ -602,8 +602,8 @@ static void
print_vpn_config (NMVPNConnection *connection) print_vpn_config (NMVPNConnection *connection)
{ {
NMVPNConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (connection); NMVPNConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (connection);
NMIP4Address *addr; const NMPlatformIP4Address *address4;
NMIP6Address *addr6; const NMPlatformIP6Address *address6;
char *dns_domain = NULL; char *dns_domain = NULL;
guint32 num, i; guint32 num, i;
@@ -620,12 +620,12 @@ print_vpn_config (NMVPNConnection *connection)
if (priv->ip4_config) { if (priv->ip4_config) {
nm_log_info (LOGD_VPN, "IPv4 configuration:"); nm_log_info (LOGD_VPN, "IPv4 configuration:");
addr = nm_ip4_config_get_address (priv->ip4_config, 0); address4 = nm_ip4_config_get_address (priv->ip4_config, 0);
if (priv->ip4_internal_gw) if (priv->ip4_internal_gw)
nm_log_info (LOGD_VPN, " Internal Gateway: %s", ip_address_to_string (priv->ip4_internal_gw)); nm_log_info (LOGD_VPN, " Internal Gateway: %s", ip_address_to_string (priv->ip4_internal_gw));
nm_log_info (LOGD_VPN, " Internal Address: %s", ip_address_to_string (nm_ip4_address_get_address (addr))); nm_log_info (LOGD_VPN, " Internal Address: %s", ip_address_to_string (address4->address));
nm_log_info (LOGD_VPN, " Internal Prefix: %d", nm_ip4_address_get_prefix (addr)); nm_log_info (LOGD_VPN, " Internal Prefix: %d", address4->plen);
nm_log_info (LOGD_VPN, " Internal Point-to-Point Address: %s", nm_log_info (LOGD_VPN, " Internal Point-to-Point Address: %s",
ip_address_to_string (nm_ip4_config_get_ptp_address (priv->ip4_config))); ip_address_to_string (nm_ip4_config_get_ptp_address (priv->ip4_config)));
nm_log_info (LOGD_VPN, " Maximum Segment Size (MSS): %d", nm_ip4_config_get_mss (priv->ip4_config)); nm_log_info (LOGD_VPN, " Maximum Segment Size (MSS): %d", nm_ip4_config_get_mss (priv->ip4_config));
@@ -660,12 +660,12 @@ print_vpn_config (NMVPNConnection *connection)
if (priv->ip6_config) { if (priv->ip6_config) {
nm_log_info (LOGD_VPN, "IPv6 configuration:"); nm_log_info (LOGD_VPN, "IPv6 configuration:");
addr6 = nm_ip6_config_get_address (priv->ip6_config, 0); address6 = nm_ip6_config_get_address (priv->ip6_config, 0);
if (priv->ip6_internal_gw) if (priv->ip6_internal_gw)
nm_log_info (LOGD_VPN, " Internal Gateway: %s", ip6_address_to_string (priv->ip6_internal_gw)); nm_log_info (LOGD_VPN, " Internal Gateway: %s", ip6_address_to_string (priv->ip6_internal_gw));
nm_log_info (LOGD_VPN, " Internal Address: %s", ip6_address_to_string (nm_ip6_address_get_address (addr6))); nm_log_info (LOGD_VPN, " Internal Address: %s", ip6_address_to_string (&address6->address));
nm_log_info (LOGD_VPN, " Internal Prefix: %d", nm_ip6_address_get_prefix (addr6)); nm_log_info (LOGD_VPN, " Internal Prefix: %d", address6->plen);
nm_log_info (LOGD_VPN, " Internal Point-to-Point Address: %s", nm_log_info (LOGD_VPN, " Internal Point-to-Point Address: %s",
ip6_address_to_string (nm_ip6_config_get_ptp_address (priv->ip6_config))); ip6_address_to_string (nm_ip6_config_get_ptp_address (priv->ip6_config)));
nm_log_info (LOGD_VPN, " Maximum Segment Size (MSS): %d", nm_ip6_config_get_mss (priv->ip6_config)); nm_log_info (LOGD_VPN, " Maximum Segment Size (MSS): %d", nm_ip6_config_get_mss (priv->ip6_config));
@@ -877,8 +877,7 @@ nm_vpn_connection_ip4_config_get (DBusGProxy *proxy,
{ {
NMVPNConnection *connection = NM_VPN_CONNECTION (user_data); NMVPNConnection *connection = NM_VPN_CONNECTION (user_data);
NMVPNConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (connection); NMVPNConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (connection);
NMSettingIP4Config *s_ip4; NMPlatformIP4Address address;
NMIP4Address *addr;
NMIP4Config *config; NMIP4Config *config;
GValue *val; GValue *val;
int i; int i;
@@ -908,10 +907,10 @@ nm_vpn_connection_ip4_config_get (DBusGProxy *proxy,
config = nm_ip4_config_new (); config = nm_ip4_config_new ();
addr = nm_ip4_address_new (); memset (&address, 0, sizeof (address));
nm_ip4_address_set_prefix (addr, 24); /* default to class C */ address.plen = 24;
if (priv->ip4_external_gw) if (priv->ip4_external_gw)
nm_ip4_address_set_gateway (addr, priv->ip4_external_gw); nm_ip4_config_set_gateway (config, priv->ip4_external_gw);
/* Internal address of the VPN subnet's gateway */ /* Internal address of the VPN subnet's gateway */
val = (GValue *) g_hash_table_lookup (config_hash, NM_VPN_PLUGIN_IP4_CONFIG_INT_GATEWAY); val = (GValue *) g_hash_table_lookup (config_hash, NM_VPN_PLUGIN_IP4_CONFIG_INT_GATEWAY);
@@ -920,7 +919,7 @@ nm_vpn_connection_ip4_config_get (DBusGProxy *proxy,
val = (GValue *) g_hash_table_lookup (config_hash, NM_VPN_PLUGIN_IP4_CONFIG_ADDRESS); val = (GValue *) g_hash_table_lookup (config_hash, NM_VPN_PLUGIN_IP4_CONFIG_ADDRESS);
if (val) if (val)
nm_ip4_address_set_address (addr, g_value_get_uint (val)); address.address = g_value_get_uint (val);
val = (GValue *) g_hash_table_lookup (config_hash, NM_VPN_PLUGIN_IP4_CONFIG_PTP); val = (GValue *) g_hash_table_lookup (config_hash, NM_VPN_PLUGIN_IP4_CONFIG_PTP);
if (val) if (val)
@@ -928,13 +927,12 @@ nm_vpn_connection_ip4_config_get (DBusGProxy *proxy,
val = (GValue *) g_hash_table_lookup (config_hash, NM_VPN_PLUGIN_IP4_CONFIG_PREFIX); val = (GValue *) g_hash_table_lookup (config_hash, NM_VPN_PLUGIN_IP4_CONFIG_PREFIX);
if (val) if (val)
nm_ip4_address_set_prefix (addr, g_value_get_uint (val)); address.plen = g_value_get_uint (val);
if (nm_ip4_address_get_address (addr) && nm_ip4_address_get_prefix (addr)) { if (address.address && address.plen) {
nm_ip4_config_take_address (config, addr); nm_ip4_config_add_address (config, &address);
} else { } else {
nm_log_err (LOGD_VPN, "invalid IP4 config received!"); nm_log_err (LOGD_VPN, "invalid IP4 config received!");
nm_ip4_address_unref (addr);
g_object_unref (config); g_object_unref (config);
nm_vpn_connection_config_maybe_complete (connection, FALSE); nm_vpn_connection_config_maybe_complete (connection, FALSE);
return; return;
@@ -1009,8 +1007,7 @@ nm_vpn_connection_ip4_config_get (DBusGProxy *proxy,
nm_ip4_config_set_never_default (config, g_value_get_boolean (val)); nm_ip4_config_set_never_default (config, g_value_get_boolean (val));
/* Merge in user overrides from the NMConnection's IPv4 setting */ /* Merge in user overrides from the NMConnection's IPv4 setting */
s_ip4 = nm_connection_get_setting_ip4_config (priv->connection); nm_ip4_config_merge_setting (config, nm_connection_get_setting_ip4_config (priv->connection));
nm_ip4_config_merge_setting (config, s_ip4);
priv->ip4_config = config; priv->ip4_config = config;
nm_vpn_connection_config_maybe_complete (connection, TRUE); nm_vpn_connection_config_maybe_complete (connection, TRUE);
@@ -1023,8 +1020,7 @@ nm_vpn_connection_ip6_config_get (DBusGProxy *proxy,
{ {
NMVPNConnection *connection = NM_VPN_CONNECTION (user_data); NMVPNConnection *connection = NM_VPN_CONNECTION (user_data);
NMVPNConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (connection); NMVPNConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (connection);
NMSettingIP6Config *s_ip6; NMPlatformIP6Address address;
NMIP6Address *addr;
NMIP6Config *config; NMIP6Config *config;
GValue *val; GValue *val;
int i; int i;
@@ -1040,10 +1036,10 @@ nm_vpn_connection_ip6_config_get (DBusGProxy *proxy,
config = nm_ip6_config_new (); config = nm_ip6_config_new ();
addr = nm_ip6_address_new (); memset (&address, 0, sizeof (address));
nm_ip6_address_set_prefix (addr, 128); /* default to class C */ address.plen = 128;
if (priv->ip6_external_gw) if (priv->ip6_external_gw)
nm_ip6_address_set_gateway (addr, priv->ip6_external_gw); nm_ip6_config_set_gateway (config, priv->ip6_external_gw);
/* Internal address of the VPN subnet's gateway */ /* Internal address of the VPN subnet's gateway */
val = (GValue *) g_hash_table_lookup (config_hash, NM_VPN_PLUGIN_IP6_CONFIG_INT_GATEWAY); val = (GValue *) g_hash_table_lookup (config_hash, NM_VPN_PLUGIN_IP6_CONFIG_INT_GATEWAY);
@@ -1059,7 +1055,7 @@ nm_vpn_connection_ip6_config_get (DBusGProxy *proxy,
GByteArray *ba = g_value_get_boxed (val); GByteArray *ba = g_value_get_boxed (val);
if (ba->len == sizeof (struct in6_addr)) if (ba->len == sizeof (struct in6_addr))
nm_ip6_address_set_address (addr, (struct in6_addr *)ba->data); address.address = *(struct in6_addr *) ba->data;
} }
val = (GValue *) g_hash_table_lookup (config_hash, NM_VPN_PLUGIN_IP6_CONFIG_PTP); val = (GValue *) g_hash_table_lookup (config_hash, NM_VPN_PLUGIN_IP6_CONFIG_PTP);
@@ -1072,13 +1068,12 @@ nm_vpn_connection_ip6_config_get (DBusGProxy *proxy,
val = (GValue *) g_hash_table_lookup (config_hash, NM_VPN_PLUGIN_IP6_CONFIG_PREFIX); val = (GValue *) g_hash_table_lookup (config_hash, NM_VPN_PLUGIN_IP6_CONFIG_PREFIX);
if (val) if (val)
nm_ip6_address_set_prefix (addr, g_value_get_uint (val)); address.plen = g_value_get_uint (val);
if (nm_ip6_address_get_address (addr) && nm_ip6_address_get_prefix (addr)) { if (IN6_IS_ADDR_UNSPECIFIED (&address.address) && address.plen)
nm_ip6_config_take_address (config, addr); nm_ip6_config_add_address (config, &address);
} else { else {
nm_log_err (LOGD_VPN, "invalid IP6 config received!"); nm_log_err (LOGD_VPN, "invalid IP6 config received!");
nm_ip6_address_unref (addr);
g_object_unref (config); g_object_unref (config);
nm_vpn_connection_config_maybe_complete (connection, FALSE); nm_vpn_connection_config_maybe_complete (connection, FALSE);
} }
@@ -1146,8 +1141,7 @@ nm_vpn_connection_ip6_config_get (DBusGProxy *proxy,
nm_ip6_config_set_never_default (config, g_value_get_boolean (val)); nm_ip6_config_set_never_default (config, g_value_get_boolean (val));
/* Merge in user overrides from the NMConnection's IPv6 setting */ /* Merge in user overrides from the NMConnection's IPv6 setting */
s_ip6 = nm_connection_get_setting_ip6_config (priv->connection); nm_ip6_config_merge_setting (config, nm_connection_get_setting_ip6_config (priv->connection));
nm_ip6_config_merge_setting (config, s_ip6);
priv->ip6_config = config; priv->ip6_config = config;
nm_vpn_connection_config_maybe_complete (connection, TRUE); nm_vpn_connection_config_maybe_complete (connection, TRUE);