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

core: track addresses for NMIP4Config/NMIP6Config via NMDedupMultiIndex

Browse Source 
Reasons:

 - it adds an O(1) lookup index for accessing NMIPxConfig's addresses.
   Hence, operations like merge/intersect have now runtime O(n) instead
   of O(n^2).
   Arguably, we expect low numbers of addresses in general. For low
   numbers, the O(n^2) doesn't matter and quite likely in those cases
   the previous implementation was just fine -- maybe even faster.
   But the simple case works fine either way. It's important to scale
   well in the exceptional case.
 - the tracked objects can be shared between the various NMPI4Config,
   NMIP6Config instances with NMPlatform and everybody else.
 - the NMPObject can be treated generically, meaning it enables code to
   handle both IPv4 and IPv6, or addresses and routes. See for example
   _nm_ip_config_add_obj().
 - I want core to evolve to somewhere where we don't keep copies of
   NMPlatformIP4Address, et al. instances. Instead they shall all be
   shared. I hope this will reduce memory consumption (although tracking a
   reference consumes some memory too). Also, it shortcuts nmp_object_equal()
   when comparing the same object. Calling nmp_object_equal() on the
   identical objects would be a common case after the hash function
   pre-evaluates equality.
This commit is contained in:
Thomas Haller
2017-07-07 23:34:41 +02:00
parent 74816a2237
commit 22edeb5b69
21 changed files with 1192 additions and 844 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
shared/nm-utils/nm-dedup-multi.c
View File

@@ -927,21 +927,60 @@ nm_dedup_multi_obj_clone (const NMDedupMultiObj *obj)
return o;
}
gconstpointer *
nm_dedup_multi_objs_to_array_head (const NMDedupMultiHeadEntry *head_entry,
NMDedupMultiFcnSelectPredicate predicate,
gpointer user_data,
guint *out_len)
{
gconstpointer *result;
CList *iter;
guint i;
if (!head_entry) {
NM_SET_OUT (out_len, 0);
return NULL;
}
result = g_new (gconstpointer, head_entry->len + 1);
i = 0;
c_list_for_each (iter, &head_entry->lst_entries_head) {
const NMDedupMultiObj *obj = c_list_entry (iter, NMDedupMultiEntry, lst_entries)->obj;
if ( !predicate
|| predicate (obj, user_data)) {
nm_assert (i < head_entry->len);
result[i++] = obj;
}
}
if (i == 0) {
g_free (result);
NM_SET_OUT (out_len, 0);
return NULL;
}
nm_assert (i <= head_entry->len);
NM_SET_OUT (out_len, i);
result[i++] = NULL;
return result;
}
GPtrArray *
nm_dedup_multi_objs_to_ptr_array_head (const NMDedupMultiHeadEntry *head_entry,
NMDedupMultiFcnSelectPredicate predicate,
gpointer user_data)
{
GPtrArray *result;
NMDedupMultiIter iter;
CList *iter;
if (!head_entry)
return NULL;
result = g_ptr_array_new_full (head_entry->len,
(GDestroyNotify) nm_dedup_multi_obj_unref);
nm_dedup_multi_iter_for_each (&iter, head_entry) {
const NMDedupMultiObj *obj = iter.current->obj;
c_list_for_each (iter, &head_entry->lst_entries_head) {
const NMDedupMultiObj *obj = c_list_entry (iter, NMDedupMultiEntry, lst_entries)->obj;
if ( !predicate
|| predicate (obj, user_data))

19
shared/nm-utils/nm-dedup-multi.h
View File

@@ -23,7 +23,7 @@
#define __NM_DEDUP_MULTI_H__
#include "nm-obj.h"
#include "c-list.h"
#include "c-list-util.h"
/*****************************************************************************/
@@ -370,10 +370,27 @@ nm_dedup_multi_iter_rewind (NMDedupMultiIter *iter)
typedef gboolean (*NMDedupMultiFcnSelectPredicate) (/* const NMDedupMultiObj * */ gconstpointer obj,
gpointer user_data);
gconstpointer *nm_dedup_multi_objs_to_array_head (const NMDedupMultiHeadEntry *head_entry,
NMDedupMultiFcnSelectPredicate predicate,
gpointer user_data,
guint *out_len);
GPtrArray *nm_dedup_multi_objs_to_ptr_array_head (const NMDedupMultiHeadEntry *head_entry,
NMDedupMultiFcnSelectPredicate predicate,
gpointer user_data);
static inline void
nm_dedup_multi_head_entry_sort (const NMDedupMultiHeadEntry *head_entry,
CListSortCmp cmp,
gconstpointer user_data)
{
if (head_entry) {
/* the head entry can be sorted directly without messing up the
* index to which it belongs. Of course, this does mess up any
* NMDedupMultiIter instances. */
c_list_sort ((CList *) &head_entry->lst_entries_head, cmp, user_data);
}
}
/*****************************************************************************/
#endif /* __NM_DEDUP_MULTI_H__ */

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

@@ -2454,16 +2454,19 @@ ndisc_set_router_config (NMNDisc *ndisc, NMDevice *self)
gint32 now;
GArray *addresses, *dns_servers, *dns_domains;
guint len, i;
const NMDedupMultiHeadEntry *head_entry;
NMDedupMultiIter ipconf_iter;
if (nm_ndisc_get_node_type (ndisc) != NM_NDISC_NODE_TYPE_ROUTER)
return;
now = nm_utils_get_monotonic_timestamp_s ();
len = nm_ip6_config_get_num_addresses (priv->ip6_config);
addresses = g_array_sized_new (FALSE, TRUE, sizeof (NMNDiscAddress), len);
for (i = 0; i < len; i++) {
const NMPlatformIP6Address *addr = nm_ip6_config_get_address (priv->ip6_config, i);
head_entry = nm_ip6_config_lookup_addresses (priv->ip6_config);
addresses = g_array_sized_new (FALSE, TRUE, sizeof (NMNDiscAddress),
head_entry ? head_entry->len : 0);
nm_dedup_multi_iter_for_each (&ipconf_iter, head_entry) {
const NMPlatformIP6Address *addr = NMP_OBJECT_CAST_IP6_ADDRESS (ipconf_iter.current->obj);
NMNDiscAddress *ndisc_addr;
if (IN6_IS_ADDR_LINKLOCAL (&addr->address))
@@ -5095,17 +5098,17 @@ arping_manager_probe_terminated (NMArpingManager *arping_manager, ArpingData *da
{
NMDevice *self;
NMDevicePrivate *priv;
NMDedupMultiIter ipconf_iter;
const NMPlatformIP4Address *address;
gboolean result, success = TRUE;
int i, j;
int i;
g_assert (data);
self = data->device;
priv = NM_DEVICE_GET_PRIVATE (self);
for (i = 0; data->configs && data->configs[i]; i++) {
for (j = 0; j < nm_ip4_config_get_num_addresses (data->configs[i]); j++) {
address = nm_ip4_config_get_address (data->configs[i], j);
nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, data->configs[i], &address) {
result = nm_arping_manager_check_address (arping_manager, address->address);
success &= result;
@@ -5139,13 +5142,14 @@ ipv4_dad_start (NMDevice *self, NMIP4Config **configs, ArpingCallback cb)
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
NMArpingManager *arping_manager;
const NMPlatformIP4Address *address;
NMDedupMultiIter ipconf_iter;
ArpingData *data;
guint timeout;
gboolean ret, addr_found;
const guint8 *hw_addr;
size_t hw_addr_len = 0;
GError *error = NULL;
guint i, j;
guint i;
g_return_if_fail (NM_IS_DEVICE (self));
g_return_if_fail (configs);
@@ -5191,10 +5195,8 @@ ipv4_dad_start (NMDevice *self, NMIP4Config **configs, ArpingCallback cb)
data->device = self;
for (i = 0; configs[i]; i++) {
for (j = 0; j < nm_ip4_config_get_num_addresses (configs[i]); j++) {
address = nm_ip4_config_get_address (configs[i], j);
nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, configs[i], &address)
nm_arping_manager_add_address (arping_manager, address->address);
}
}
g_signal_connect_data (arping_manager, NM_ARPING_MANAGER_PROBE_TERMINATED,
@@ -6618,7 +6620,6 @@ dhcp6_state_changed (NMDhcpClient *client,
{
NMDevice *self = NM_DEVICE (user_data);
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
guint i;
g_return_if_fail (nm_dhcp_client_get_ipv6 (client) == TRUE);
g_return_if_fail (!ip6_config || NM_IS_IP6_CONFIG (ip6_config));
@@ -6635,10 +6636,11 @@ dhcp6_state_changed (NMDhcpClient *client,
&& event_id
&& priv->dhcp6.event_id
&& !strcmp (event_id, priv->dhcp6.event_id)) {
for (i = 0; i < nm_ip6_config_get_num_addresses (ip6_config); i++) {
nm_ip6_config_add_address (priv->dhcp6.ip6_config,
nm_ip6_config_get_address (ip6_config, i));
}
NMDedupMultiIter ipconf_iter;
const NMPlatformIP6Address *a;
nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, ip6_config, &a)
nm_ip6_config_add_address (priv->dhcp6.ip6_config, a);
} else {
g_clear_object (&priv->dhcp6.ip6_config);
g_clear_pointer (&priv->dhcp6.event_id, g_free);
@@ -6978,7 +6980,6 @@ check_and_add_ipv6ll_addr (NMDevice *self)
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
int ip_ifindex = nm_device_get_ip_ifindex (self);
struct in6_addr lladdr;
guint i, n;
NMConnection *connection;
NMSettingIP6Config *s_ip6 = NULL;
GError *error = NULL;
@@ -6987,11 +6988,10 @@ check_and_add_ipv6ll_addr (NMDevice *self)
return;
if (priv->ip6_config) {
n = nm_ip6_config_get_num_addresses (priv->ip6_config);
for (i = 0; i < n; i++) {
const NMPlatformIP6Address *addr;
NMDedupMultiIter ipconf_iter;
const NMPlatformIP6Address *addr;
addr = nm_ip6_config_get_address (priv->ip6_config, i);
nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, priv->ip6_config, &addr) {
if ( IN6_IS_ADDR_LINKLOCAL (&addr->address)
&& !(addr->n_ifa_flags & IFA_F_DADFAILED)) {
/* Already have an LL address, nothing to do */
@@ -8292,15 +8292,15 @@ start_sharing (NMDevice *self, NMIP4Config *config)
char str_addr[INET_ADDRSTRLEN + 1];
char str_mask[INET_ADDRSTRLEN + 1];
guint32 netmask, network;
const NMPlatformIP4Address *ip4_addr;
const NMPlatformIP4Address *ip4_addr = NULL;
const char *ip_iface;
g_return_val_if_fail (config != NULL, FALSE);
ip_iface = nm_device_get_ip_iface (self);
ip4_addr = nm_ip4_config_get_address (config, 0);
if (!ip4_addr || !ip4_addr->address)
ip4_addr = nm_ip4_config_get_first_address (config);
if (ip4_addr || !ip4_addr->address)
return FALSE;
netmask = nm_utils_ip4_prefix_to_netmask (ip4_addr->plen);
@@ -8513,7 +8513,8 @@ dad6_get_pending_addresses (NMDevice *self)
priv->wwan_ip6_config };
const NMPlatformIP6Address *addr, *pl_addr;
NMIP6Config *dad6_config = NULL;
guint i, j, num;
NMDedupMultiIter ipconf_iter;
guint i;
int ifindex;
ifindex = nm_device_get_ip_ifindex (self);
@@ -8524,9 +8525,8 @@ dad6_get_pending_addresses (NMDevice *self)
*/
for (i = 0; i < G_N_ELEMENTS (confs); i++) {
if (confs[i]) {
num = nm_ip6_config_get_num_addresses (confs[i]);
for (j = 0; j < num; j++) {
addr = nm_ip6_config_get_address (confs[i], j);
nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, confs[i], &addr) {
pl_addr = nm_platform_ip6_address_get (nm_device_get_platform (self),
ifindex,
addr->address);
@@ -8738,16 +8738,15 @@ static void
_update_ip4_address (NMDevice *self)
{
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
guint32 addr;
const NMPlatformIP4Address *address;
g_return_if_fail (NM_IS_DEVICE (self));
if ( priv->ip4_config
&& ip_config_valid (priv->state)
&& nm_ip4_config_get_num_addresses (priv->ip4_config)) {
addr = nm_ip4_config_get_address (priv->ip4_config, 0)->address;
if (addr != priv->ip4_address) {
priv->ip4_address = addr;
&& (address = nm_ip4_config_get_first_address (priv->ip4_config))) {
if (address->address != priv->ip4_address) {
priv->ip4_address = address->address;
_notify (self, PROP_IP4_ADDRESS);
}
}
@@ -10598,7 +10597,7 @@ find_ip4_lease_config (NMDevice *self,
nm_device_get_ip4_route_metric (self));
for (liter = leases; liter && !found; liter = liter->next) {
NMIP4Config *lease_config = liter->data;
const NMPlatformIP4Address *address = nm_ip4_config_get_address (lease_config, 0);
const NMPlatformIP4Address *address = nm_ip4_config_get_first_address (lease_config);
guint32 gateway = nm_ip4_config_get_gateway (lease_config);
g_assert (address);
@@ -10624,23 +10623,24 @@ capture_lease_config (NMDevice *self,
NMSettingsConnection *const*connections;
guint i;
gboolean dhcp_used = FALSE;
NMDedupMultiIter ipconf_iter;
/* Ensure at least one address on the device has a non-infinite lifetime,
* otherwise DHCP cannot possibly be active on the device right now.
*/
if (ext_ip4_config && out_ip4_config) {
for (i = 0; i < nm_ip4_config_get_num_addresses (ext_ip4_config); i++) {
const NMPlatformIP4Address *addr = nm_ip4_config_get_address (ext_ip4_config, i);
const NMPlatformIP4Address *addr;
nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, ext_ip4_config, &addr) {
if (addr->lifetime != NM_PLATFORM_LIFETIME_PERMANENT) {
dhcp_used = TRUE;
break;
}
}
} else if (ext_ip6_config && out_ip6_config) {
for (i = 0; i < nm_ip6_config_get_num_addresses (ext_ip6_config); i++) {
const NMPlatformIP6Address *addr = nm_ip6_config_get_address (ext_ip6_config, i);
const NMPlatformIP6Address *addr;
nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, ext_ip6_config, &addr) {
if (addr->lifetime != NM_PLATFORM_LIFETIME_PERMANENT) {
dhcp_used = TRUE;
break;
@@ -12227,15 +12227,13 @@ static char *
find_dhcp4_address (NMDevice *self)
{
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
guint i, n;
const NMPlatformIP4Address *a;
NMDedupMultiIter ipconf_iter;
if (!priv->ip4_config)
return NULL;
n = nm_ip4_config_get_num_addresses (priv->ip4_config);
for (i = 0; i < n; i++) {
const NMPlatformIP4Address *a = nm_ip4_config_get_address (priv->ip4_config, i);
nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, priv->ip4_config, &a) {
if (a->addr_source == NM_IP_CONFIG_SOURCE_DHCP)
return g_strdup (nm_utils_inet4_ntop (a->address, NULL));
}

11
src/devices/wwan/nm-modem.c
View File

@@ -682,7 +682,7 @@ nm_modem_ip4_pre_commit (NMModem *modem,
*/
if ( priv->ip4_method == NM_MODEM_IP_METHOD_STATIC
|| priv->ip4_method == NM_MODEM_IP_METHOD_AUTO) {
const NMPlatformIP4Address *address = nm_ip4_config_get_address (config, 0);
const NMPlatformIP4Address *address = nm_ip4_config_get_first_address (config);
g_assert (address);
if (address->plen == 32)
@@ -698,7 +698,8 @@ nm_modem_emit_ip6_config_result (NMModem *self,
GError *error)
{
NMModemPrivate *priv = NM_MODEM_GET_PRIVATE (self);
guint i, num;
NMDedupMultiIter ipconf_iter;
const NMPlatformIP6Address *addr;
gboolean do_slaac = TRUE;
if (error) {
@@ -710,11 +711,7 @@ nm_modem_emit_ip6_config_result (NMModem *self,
/* If the IPv6 configuration only included a Link-Local address, then
* we have to run SLAAC to get the full IPv6 configuration.
*/
num = nm_ip6_config_get_num_addresses (config);
g_assert (num > 0);
for (i = 0; i < num; i++) {
const NMPlatformIP6Address * addr = nm_ip6_config_get_address (config, i);
nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, config, &addr) {
if (IN6_IS_ADDR_LINKLOCAL (&addr->address)) {
if (!priv->iid.id)
priv->iid.id = ((guint64 *)(&addr->address.s6_addr))[1];

12
src/dhcp/tests/test-dhcp-dhclient.c
View File

@@ -37,6 +37,8 @@
#define DEBUG 1
static const int IFINDEX = 5;
static void
test_config (const char *orig,
const char *expected,
@@ -910,7 +912,7 @@ test_read_lease_ip4_config_basic (void)
/* Date from before the least expiration */
now = g_date_time_new_utc (2013, 11, 1, 19, 55, 32);
leases = nm_dhcp_dhclient_read_lease_ip_configs (multi_idx, "wlan0", -1, contents, FALSE, now);
leases = nm_dhcp_dhclient_read_lease_ip_configs (multi_idx, "wlan0", IFINDEX, contents, FALSE, now);
g_assert_cmpint (g_slist_length (leases), ==, 2);
/* IP4Config #1 */
@@ -920,7 +922,7 @@ test_read_lease_ip4_config_basic (void)
/* Address */
g_assert_cmpint (nm_ip4_config_get_num_addresses (config), ==, 1);
expected_addr = nmtst_inet4_from_string ("192.168.1.180");
addr = nm_ip4_config_get_address (config, 0);
addr = _nmtst_nm_ip4_config_get_address (config, 0);
g_assert_cmpint (addr->address, ==, expected_addr);
g_assert_cmpint (addr->peer_address, ==, expected_addr);
g_assert_cmpint (addr->plen, ==, 24);
@@ -943,7 +945,7 @@ test_read_lease_ip4_config_basic (void)
/* Address */
g_assert_cmpint (nm_ip4_config_get_num_addresses (config), ==, 1);
expected_addr = nmtst_inet4_from_string ("10.77.52.141");
addr = nm_ip4_config_get_address (config, 0);
addr = _nmtst_nm_ip4_config_get_address (config, 0);
g_assert_cmpint (addr->address, ==, expected_addr);
g_assert_cmpint (addr->peer_address, ==, expected_addr);
g_assert_cmpint (addr->plen, ==, 8);
@@ -985,7 +987,7 @@ test_read_lease_ip4_config_expired (void)
/* Date from *after* the lease expiration */
now = g_date_time_new_utc (2013, 12, 1, 19, 55, 32);
leases = nm_dhcp_dhclient_read_lease_ip_configs (multi_idx, "wlan0", -1, contents, FALSE, now);
leases = nm_dhcp_dhclient_read_lease_ip_configs (multi_idx, "wlan0", IFINDEX, contents, FALSE, now);
g_assert (leases == NULL);
g_date_time_unref (now);
@@ -1008,7 +1010,7 @@ test_read_lease_ip4_config_expect_failure (gconstpointer user_data)
/* Date from before the least expiration */
now = g_date_time_new_utc (2013, 11, 1, 1, 1, 1);
leases = nm_dhcp_dhclient_read_lease_ip_configs (multi_idx, "wlan0", -1, contents, FALSE, now);
leases = nm_dhcp_dhclient_read_lease_ip_configs (multi_idx, "wlan0", IFINDEX, contents, FALSE, now);
g_assert (leases == NULL);
g_date_time_unref (now);

8
src/dhcp/tests/test-dhcp-utils.c
View File

@@ -105,7 +105,7 @@ test_generic_options (void)
/* IP4 address */
g_assert_cmpint (nm_ip4_config_get_num_addresses (ip4_config), ==, 1);
address = nm_ip4_config_get_address (ip4_config, 0);
address = _nmtst_nm_ip4_config_get_address (ip4_config, 0);
g_assert (inet_pton (AF_INET, expected_addr, &tmp) > 0);
g_assert (address->address == tmp);
g_assert (address->peer_address == tmp);
@@ -175,7 +175,7 @@ test_wins_options (void)
/* IP4 address */
g_assert_cmpint (nm_ip4_config_get_num_addresses (ip4_config), ==, 1);
address = nm_ip4_config_get_address (ip4_config, 0);
address = _nmtst_nm_ip4_config_get_address (ip4_config, 0);
g_assert (address);
g_assert_cmpint (nm_ip4_config_get_num_wins (ip4_config), ==, 2);
g_assert (inet_pton (AF_INET, expected_wins1, &tmp) > 0);
@@ -624,7 +624,7 @@ test_ip4_missing_prefix (const char *ip, guint32 expected_prefix)
ip4_config = _ip4_config_from_options (1, "eth0", options, 0);
g_assert_cmpint (nm_ip4_config_get_num_addresses (ip4_config), ==, 1);
address = nm_ip4_config_get_address (ip4_config, 0);
address = _nmtst_nm_ip4_config_get_address (ip4_config, 0);
g_assert (address);
g_assert_cmpint (address->plen, ==, expected_prefix);
@@ -668,7 +668,7 @@ test_ip4_prefix_classless (void)
ip4_config = _ip4_config_from_options (1, "eth0", options, 0);
g_assert_cmpint (nm_ip4_config_get_num_addresses (ip4_config), ==, 1);
address = nm_ip4_config_get_address (ip4_config, 0);
address = _nmtst_nm_ip4_config_get_address (ip4_config, 0);
g_assert (address);
g_assert_cmpint (address->plen, ==, 22);

18
src/dns/nm-dns-dnsmasq.c
View File

@@ -80,21 +80,18 @@ get_ip4_rdns_domains (NMIP4Config *ip4)
{
char **strv;
GPtrArray *domains = NULL;
guint i;
NMDedupMultiIter ipconf_iter;
const NMPlatformIP4Address *address;
const NMPlatformIP4Route *route;
g_return_val_if_fail (ip4 != NULL, NULL);
domains = g_ptr_array_sized_new (5);
for (i = 0; i < nm_ip4_config_get_num_addresses (ip4); i++) {
const NMPlatformIP4Address *address = nm_ip4_config_get_address (ip4, i);
nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, ip4, &address)
nm_utils_get_reverse_dns_domains_ip4 (address->address, address->plen, domains);
}
nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, ip4, &route)
nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, ip4, &route)
nm_utils_get_reverse_dns_domains_ip4 (route->network, route->plen, domains);
/* Terminating NULL so we can use g_strfreev() to free it */
@@ -111,21 +108,18 @@ get_ip6_rdns_domains (NMIP6Config *ip6)
{
char **strv;
GPtrArray *domains = NULL;
guint i;
NMDedupMultiIter ipconf_iter;
const NMPlatformIP6Address *address;
const NMPlatformIP6Route *route;
g_return_val_if_fail (ip6 != NULL, NULL);
domains = g_ptr_array_sized_new (5);
for (i = 0; i < nm_ip6_config_get_num_addresses (ip6); i++) {
const NMPlatformIP6Address *address = nm_ip6_config_get_address (ip6, i);
nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, ip6, &address)
nm_utils_get_reverse_dns_domains_ip6 (&address->address, address->plen, domains);
}
nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, ip6, &route)
nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, ip6, &route)
nm_utils_get_reverse_dns_domains_ip6 (&route->network, route->plen, domains);
/* Terminating NULL so we can use g_strfreev() to free it */

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

@@ -162,7 +162,7 @@ create_dm_cmd_line (const char *iface,
const NMPlatformIP4Address *listen_address;
guint i, n;
listen_address = nm_ip4_config_get_address (ip4_config, 0);
listen_address = nm_ip4_config_get_first_address (ip4_config);
g_return_val_if_fail (listen_address, NULL);
dm_binary = nm_utils_find_helper ("dnsmasq", DNSMASQ_PATH, error);

27
src/nm-dispatcher.c
View File

@@ -114,6 +114,7 @@ dump_ip4_to_props (NMIP4Config *ip4, GVariantBuilder *builder)
{
GVariantBuilder int_builder;
NMDedupMultiIter ipconf_iter;
gboolean first;
guint n, i;
const NMPlatformIP4Address *addr;
const NMPlatformIP4Route *route;
@@ -121,15 +122,15 @@ dump_ip4_to_props (NMIP4Config *ip4, GVariantBuilder *builder)
/* Addresses */
g_variant_builder_init (&int_builder, G_VARIANT_TYPE ("aau"));
n = nm_ip4_config_get_num_addresses (ip4);
for (i = 0; i < n; i++) {
addr = nm_ip4_config_get_address (ip4, i);
first = TRUE;
nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, ip4, &addr) {
array[0] = addr->address;
array[1] = addr->plen;
array[2] = (i == 0) ? nm_ip4_config_get_gateway (ip4) : 0;
array[2] = first ? nm_ip4_config_get_gateway (ip4) : 0;
g_variant_builder_add (&int_builder, "@au",
g_variant_new_fixed_array (G_VARIANT_TYPE_UINT32,
array, 3, sizeof (guint32)));
first = FALSE;
}
g_variant_builder_add (builder, "{sv}",
"addresses",
@@ -164,7 +165,7 @@ dump_ip4_to_props (NMIP4Config *ip4, GVariantBuilder *builder)
/* Static routes */
g_variant_builder_init (&int_builder, G_VARIANT_TYPE ("aau"));
nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, ip4, &route) {
nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, ip4, &route) {
array[0] = route->network;
array[1] = route->plen;
array[2] = route->gateway;
@@ -184,24 +185,26 @@ dump_ip6_to_props (NMIP6Config *ip6, GVariantBuilder *builder)
GVariantBuilder int_builder;
NMDedupMultiIter ipconf_iter;
guint n, i;
gboolean first;
const NMPlatformIP6Address *addr;
const struct in6_addr *gw_bytes;
const NMPlatformIP6Route *route;
GVariant *ip, *gw;
/* Addresses */
g_variant_builder_init (&int_builder, G_VARIANT_TYPE ("a(ayuay)"));
n = nm_ip6_config_get_num_addresses (ip6);
for (i = 0; i < n; i++) {
addr = nm_ip6_config_get_address (ip6, i);
gw_bytes = nm_ip6_config_get_gateway (ip6);
first = TRUE;
nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, ip6, &addr) {
ip = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
&addr->address,
sizeof (struct in6_addr), 1);
gw = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
(i == 0 && gw_bytes) ? gw_bytes : &in6addr_any,
first
? (nm_ip6_config_get_gateway (ip6) ?: &in6addr_any)
: &in6addr_any,
sizeof (struct in6_addr), 1);
g_variant_builder_add (&int_builder, "(@ayu@ay)", ip, addr->plen, gw);
first = FALSE;
}
g_variant_builder_add (builder, "{sv}",
"addresses",
@@ -231,7 +234,7 @@ dump_ip6_to_props (NMIP6Config *ip6, GVariantBuilder *builder)
/* Static routes */
g_variant_builder_init (&int_builder, G_VARIANT_TYPE ("a(ayuayu)"));
nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, ip6, &route) {
nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, ip6, &route) {
ip = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
&route->network,
sizeof (struct in6_addr), 1);

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

File diff suppressed because it is too large Load Diff

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

@@ -25,6 +25,7 @@
#include "nm-setting-ip4-config.h"
#include "nm-utils/nm-dedup-multi.h"
#include "platform/nmp-object.h"
/*****************************************************************************/
@@ -35,19 +36,64 @@ typedef struct {
void nm_ip_config_dedup_multi_idx_type_init (NMIPConfigDedupMultiIdxType *idx_type, NMPObjectType obj_type);
void nm_ip4_config_iter_ip4_route_init (NMDedupMultiIter *iter, const NMIP4Config *self);
gboolean nm_ip4_config_iter_ip4_route_next (NMDedupMultiIter *iter, const NMPlatformIP4Route **out_route);
/*****************************************************************************/
#define nm_ip4_config_iter_ip4_route_for_each(iter, self, route) \
for (nm_ip4_config_iter_ip4_route_init ((iter), (self)); \
nm_ip4_config_iter_ip4_route_next ((iter), (route)); \
)
void nm_ip_config_iter_ip4_address_init (NMDedupMultiIter *iter, const NMIP4Config *self);
void nm_ip_config_iter_ip4_route_init (NMDedupMultiIter *iter, const NMIP4Config *self);
static inline gboolean
nm_ip_config_iter_ip4_address_next (NMDedupMultiIter *ipconf_iter, const NMPlatformIP4Address **out_address)
{
gboolean has_next;
g_return_val_if_fail (out_address, FALSE);
has_next = nm_dedup_multi_iter_next (ipconf_iter);
if (has_next)
*out_address = NMP_OBJECT_CAST_IP4_ADDRESS (ipconf_iter->current->obj);
return has_next;
}
static inline gboolean
nm_ip_config_iter_ip4_route_next (NMDedupMultiIter *ipconf_iter, const NMPlatformIP4Route **out_route)
{
gboolean has_next;
g_return_val_if_fail (out_route, FALSE);
has_next = nm_dedup_multi_iter_next (ipconf_iter);
if (has_next)
*out_route = NMP_OBJECT_CAST_IP4_ROUTE (ipconf_iter->current->obj);
return has_next;
}
#define nm_ip_config_iter_ip4_address_for_each(iter, self, address) \
for (*(address) = NULL, nm_ip_config_iter_ip4_address_init ((iter), (self)); \
nm_ip_config_iter_ip4_address_next ((iter), (address)); \
)
#define nm_ip_config_iter_ip4_route_for_each(iter, self, route) \
for (*(route) = NULL, nm_ip_config_iter_ip4_route_init ((iter), (self)); \
nm_ip_config_iter_ip4_route_next ((iter), (route)); \
)
/*****************************************************************************/
gboolean nm_ip_config_obj_id_equal_ip4_address (const NMPlatformIP4Address *a,
const NMPlatformIP4Address *b);
gboolean nm_ip_config_obj_id_equal_ip6_address (const NMPlatformIP6Address *a,
const NMPlatformIP6Address *b);
gboolean nm_ip_config_obj_id_equal_ip4_route (const NMPlatformIP4Route *r_a,
const NMPlatformIP4Route *r_b);
gboolean nm_ip_config_obj_id_equal_ip6_route (const NMPlatformIP6Route *r_a,
const NMPlatformIP6Route *r_b);
gboolean _nm_ip_config_add_obj (NMDedupMultiIndex *multi_idx,
NMIPConfigDedupMultiIdxType *idx_type,
int ifindex,
const NMPObject *obj_new,
const NMPlatformObject *pl_new);
/*****************************************************************************/
#define NM_TYPE_IP4_CONFIG (nm_ip4_config_get_type ())
@@ -110,13 +156,16 @@ gboolean nm_ip4_config_has_gateway (const NMIP4Config *self);
guint32 nm_ip4_config_get_gateway (const NMIP4Config *self);
gint64 nm_ip4_config_get_route_metric (const NMIP4Config *self);
const NMDedupMultiHeadEntry *nm_ip4_config_lookup_addresses (const NMIP4Config *self);
void nm_ip4_config_reset_addresses (NMIP4Config *self);
void nm_ip4_config_add_address (NMIP4Config *self, const NMPlatformIP4Address *address);
void nm_ip4_config_del_address (NMIP4Config *self, guint i);
void _nmtst_nm_ip4_config_del_address (NMIP4Config *self, guint i);
guint nm_ip4_config_get_num_addresses (const NMIP4Config *self);
const NMPlatformIP4Address *nm_ip4_config_get_address (const NMIP4Config *self, guint i);
const NMPlatformIP4Address *nm_ip4_config_get_first_address (const NMIP4Config *self);
const NMPlatformIP4Address *_nmtst_nm_ip4_config_get_address (const NMIP4Config *self, guint i);
gboolean nm_ip4_config_address_exists (const NMIP4Config *self, const NMPlatformIP4Address *address);
const NMDedupMultiHeadEntry *nm_ip4_config_lookup_routes (const NMIP4Config *self);
void nm_ip4_config_reset_routes (NMIP4Config *self);
void nm_ip4_config_add_route (NMIP4Config *self, const NMPlatformIP4Route *route);
void _nmtst_nm_ip4_config_del_route (NMIP4Config *self, guint i);

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

File diff suppressed because it is too large Load Diff

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

@@ -27,15 +27,47 @@
#include "nm-setting-ip6-config.h"
#include "nm-utils/nm-dedup-multi.h"
#include "platform/nmp-object.h"
/*****************************************************************************/
void nm_ip6_config_iter_ip6_route_init (NMDedupMultiIter *iter, const NMIP6Config *self);
gboolean nm_ip6_config_iter_ip6_route_next (NMDedupMultiIter *iter, const NMPlatformIP6Route **out_route);
void nm_ip_config_iter_ip6_address_init (NMDedupMultiIter *iter, const NMIP6Config *self);
void nm_ip_config_iter_ip6_route_init (NMDedupMultiIter *iter, const NMIP6Config *self);
#define nm_ip6_config_iter_ip6_route_for_each(iter, self, route) \
for (nm_ip6_config_iter_ip6_route_init ((iter), (self)); \
nm_ip6_config_iter_ip6_route_next ((iter), (route)); \
static inline gboolean
nm_ip_config_iter_ip6_address_next (NMDedupMultiIter *ipconf_iter, const NMPlatformIP6Address **out_address)
{
gboolean has_next;
g_return_val_if_fail (out_address, FALSE);
has_next = nm_dedup_multi_iter_next (ipconf_iter);
if (has_next)
*out_address = NMP_OBJECT_CAST_IP6_ADDRESS (ipconf_iter->current->obj);
return has_next;
}
static inline gboolean
nm_ip_config_iter_ip6_route_next (NMDedupMultiIter *ipconf_iter, const NMPlatformIP6Route **out_route)
{
gboolean has_next;
g_return_val_if_fail (out_route, FALSE);
has_next = nm_dedup_multi_iter_next (ipconf_iter);
if (has_next)
*out_route = NMP_OBJECT_CAST_IP6_ROUTE (ipconf_iter->current->obj);
return has_next;
}
#define nm_ip_config_iter_ip6_address_for_each(iter, self, address) \
for (*(address) = NULL, nm_ip_config_iter_ip6_address_init ((iter), (self)); \
nm_ip_config_iter_ip6_address_next ((iter), (address)); \
)
#define nm_ip_config_iter_ip6_route_for_each(iter, self, route) \
for (*(route) = NULL, nm_ip_config_iter_ip6_route_init ((iter), (self)); \
nm_ip_config_iter_ip6_route_next ((iter), (route)); \
)
/*****************************************************************************/
@@ -102,17 +134,22 @@ void nm_ip6_config_set_gateway (NMIP6Config *self, const struct in6_addr *);
const struct in6_addr *nm_ip6_config_get_gateway (const NMIP6Config *self);
gint64 nm_ip6_config_get_route_metric (const NMIP6Config *self);
const NMDedupMultiHeadEntry *nm_ip6_config_lookup_addresses (const NMIP6Config *self);
void nm_ip6_config_reset_addresses (NMIP6Config *self);
void nm_ip6_config_add_address (NMIP6Config *self, const NMPlatformIP6Address *address);
void nm_ip6_config_del_address (NMIP6Config *self, guint i);
void _nmtst_nm_ip6_config_del_address (NMIP6Config *self, guint i);
guint nm_ip6_config_get_num_addresses (const NMIP6Config *self);
const NMPlatformIP6Address *nm_ip6_config_get_address (const NMIP6Config *self, guint i);
const NMPlatformIP6Address *nm_ip6_config_get_first_address (const NMIP6Config *self);
const NMPlatformIP6Address *_nmtst_nm_ip6_config_get_address (const NMIP6Config *self, guint i);
const NMPlatformIP6Address *nm_ip6_config_get_address_first_nontentative (const NMIP6Config *self, gboolean linklocal);
gboolean nm_ip6_config_address_exists (const NMIP6Config *self, const NMPlatformIP6Address *address);
gboolean nm_ip6_config_addresses_sort (NMIP6Config *self);
const NMPlatformIP6Address *nm_ip6_config_lookup_address (const NMIP6Config *self,
const struct in6_addr *addr);
gboolean _nmtst_nm_ip6_config_addresses_sort (NMIP6Config *self);
gboolean nm_ip6_config_has_any_dad_pending (const NMIP6Config *self,
const NMIP6Config *candidates);
const NMDedupMultiHeadEntry *nm_ip6_config_lookup_routes (const NMIP6Config *self);
void nm_ip6_config_reset_routes (NMIP6Config *self);
void nm_ip6_config_add_route (NMIP6Config *self, const NMPlatformIP6Route *route);
void _nmtst_ip6_config_del_route (NMIP6Config *self, guint i);

13
src/nm-pacrunner-manager.c
View File

@@ -170,6 +170,7 @@ get_ip4_domains (GPtrArray *domains, NMIP4Config *ip4)
{
NMDedupMultiIter ipconf_iter;
char *cidr;
const NMPlatformIP4Address *address;
const NMPlatformIP4Route *routes;
guint i;
@@ -182,16 +183,15 @@ get_ip4_domains (GPtrArray *domains, NMIP4Config *ip4)
g_ptr_array_add (domains, g_strdup (nm_ip4_config_get_domain (ip4, i)));
/* Add addresses and routes in CIDR form */
for (i = 0; i < nm_ip4_config_get_num_addresses (ip4); i++) {
const NMPlatformIP4Address *address = nm_ip4_config_get_address (ip4, i);
nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, ip4, &address) {
cidr = g_strdup_printf ("%s/%u",
nm_utils_inet4_ntop (address->address, NULL),
address->plen);
g_ptr_array_add (domains, cidr);
}
nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, ip4, &routes) {
nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, ip4, &routes) {
cidr = g_strdup_printf ("%s/%u",
nm_utils_inet4_ntop (routes->network, NULL),
routes->plen);
@@ -204,6 +204,7 @@ get_ip6_domains (GPtrArray *domains, NMIP6Config *ip6)
{
NMDedupMultiIter ipconf_iter;
char *cidr;
const NMPlatformIP6Address *address;
const NMPlatformIP6Route *routes;
guint i;
@@ -216,16 +217,14 @@ get_ip6_domains (GPtrArray *domains, NMIP6Config *ip6)
g_ptr_array_add (domains, g_strdup (nm_ip6_config_get_domain (ip6, i)));
/* Add addresses and routes in CIDR form */
for (i = 0; i < nm_ip6_config_get_num_addresses (ip6); i++) {
const NMPlatformIP6Address *address = nm_ip6_config_get_address (ip6, i);
nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, ip6, &address) {
cidr = g_strdup_printf ("%s/%u",
nm_utils_inet6_ntop (&address->address, NULL),
address->plen);
g_ptr_array_add (domains, cidr);
}
nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, ip6, &routes) {
nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, ip6, &routes) {
cidr = g_strdup_printf ("%s/%u",
nm_utils_inet6_ntop (&routes->network, NULL),
routes->plen);

14
src/nm-policy.c
View File

@@ -605,6 +605,8 @@ update_system_hostname (NMPolicy *self, NMDevice *best4, NMDevice *best6, const
NMIP4Config *ip4_config;
NMIP6Config *ip6_config;
gboolean external_hostname = FALSE;
const NMPlatformIP4Address *addr4;
const NMPlatformIP6Address *addr6;
g_return_if_fail (self != NULL);
@@ -746,17 +748,13 @@ update_system_hostname (NMPolicy *self, NMDevice *best4, NMDevice *best6, const
ip4_config = best4 ? nm_device_get_ip4_config (best4) : NULL;
ip6_config = best6 ? nm_device_get_ip6_config (best6) : NULL;
if (ip4_config && nm_ip4_config_get_num_addresses (ip4_config) > 0) {
const NMPlatformIP4Address *addr4;
addr4 = nm_ip4_config_get_address (ip4_config, 0);
if ( ip4_config
&& (addr4 = nm_ip4_config_get_first_address (ip4_config))) {
g_clear_object (&priv->lookup.addr);
priv->lookup.addr = g_inet_address_new_from_bytes ((guint8 *) &addr4->address,
G_SOCKET_FAMILY_IPV4);
} else if (ip6_config && nm_ip6_config_get_num_addresses (ip6_config) > 0) {
const NMPlatformIP6Address *addr6;
addr6 = nm_ip6_config_get_address (ip6_config, 0);
} else if ( ip6_config
&& (addr6 = nm_ip6_config_get_first_address (ip6_config))) {
g_clear_object (&priv->lookup.addr);
priv->lookup.addr = g_inet_address_new_from_bytes ((guint8 *) &addr6->address,
G_SOCKET_FAMILY_IPV6);

1
src/nm-types.h
View File

@@ -110,6 +110,7 @@ NM_IS_IP_CONFIG_SOURCE_RTPROT (NMIPConfigSource source)
/* platform */
typedef struct _NMPlatform NMPlatform;
typedef struct _NMPlatformObject NMPlatformObject;
typedef struct _NMPlatformIP4Address NMPlatformIP4Address;
typedef struct _NMPlatformIP4Route NMPlatformIP4Route;
typedef struct _NMPlatformIP6Address NMPlatformIP6Address;

4
src/platform/nm-platform.h
View File

@@ -173,9 +173,9 @@ typedef enum {
NM_PLATFORM_SIGNAL_REMOVED,
} NMPlatformSignalChangeType;
typedef struct {
struct _NMPlatformObject {
__NMPlatformObject_COMMON;
} NMPlatformObject;
};
#define __NMPlatformIPAddress_COMMON \

25
src/platform/nmp-object.h
View File

@@ -345,6 +345,22 @@ NMP_OBJECT_GET_TYPE (const NMPObject *obj)
_obj ? &_NM_CONSTCAST (NMPObject, _obj)->link : NULL; \
})
#define NMP_OBJECT_CAST_IP_ADDRESS(obj) \
({ \
typeof (obj) _obj = (obj); \
\
nm_assert (!_obj || NM_IN_SET (NMP_OBJECT_GET_TYPE (_obj), NMP_OBJECT_TYPE_IP4_ADDRESS, NMP_OBJECT_TYPE_IP6_ADDRESS)); \
_obj ? &_NM_CONSTCAST (NMPObject, _obj)->ip_address : NULL; \
})
#define NMP_OBJECT_CAST_IPX_ADDRESS(obj) \
({ \
typeof (obj) _obj = (obj); \
\
nm_assert (!_obj || NM_IN_SET (NMP_OBJECT_GET_TYPE (_obj), NMP_OBJECT_TYPE_IP4_ADDRESS, NMP_OBJECT_TYPE_IP6_ADDRESS)); \
_obj ? &_NM_CONSTCAST (NMPObject, _obj)->ipx_address : NULL; \
})
#define NMP_OBJECT_CAST_IP4_ADDRESS(obj) \
({ \
typeof (obj) _obj = (obj); \
@@ -419,6 +435,15 @@ NMPObject *nmp_object_new (NMPObjectType obj_type, const NMPlatformObject *plob)
NMPObject *nmp_object_new_link (int ifindex);
const NMPObject *nmp_object_stackinit (NMPObject *obj, NMPObjectType obj_type, const NMPlatformObject *plobj);
static inline NMPObject *
nmp_object_stackinit_obj (NMPObject *obj, const NMPObject *src)
{
return obj == src
? obj
: (NMPObject *) nmp_object_stackinit (obj, NMP_OBJECT_GET_TYPE (src), &src->object);
}
const NMPObject *nmp_object_stackinit_id (NMPObject *obj, const NMPObject *src);
const NMPObject *nmp_object_stackinit_id_link (NMPObject *obj, int ifindex);
const NMPObject *nmp_object_stackinit_id_ip4_address (NMPObject *obj, int ifindex, guint32 address, guint8 plen, guint32 peer_address);

12
src/tests/test-ip4-config.c
View File

@@ -112,7 +112,7 @@ test_subtract (void)
/* ensure what's left is what we expect */
g_assert_cmpuint (nm_ip4_config_get_num_addresses (dst), ==, 1);
test_addr = nm_ip4_config_get_address (dst, 0);
test_addr = _nmtst_nm_ip4_config_get_address (dst, 0);
g_assert (test_addr != NULL);
g_assert_cmpuint (test_addr->address, ==, nmtst_inet4_from_string (expected_addr));
g_assert_cmpuint (test_addr->peer_address, ==, test_addr->address);
@@ -196,27 +196,27 @@ test_add_address_with_source (void)
addr.addr_source = NM_IP_CONFIG_SOURCE_USER;
nm_ip4_config_add_address (a, &addr);
test_addr = nm_ip4_config_get_address (a, 0);
test_addr = _nmtst_nm_ip4_config_get_address (a, 0);
g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_USER);
addr.addr_source = NM_IP_CONFIG_SOURCE_VPN;
nm_ip4_config_add_address (a, &addr);
test_addr = nm_ip4_config_get_address (a, 0);
test_addr = _nmtst_nm_ip4_config_get_address (a, 0);
g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_USER);
/* Test that a lower priority address source is overwritten */
nm_ip4_config_del_address (a, 0);
_nmtst_nm_ip4_config_del_address (a, 0);
addr.addr_source = NM_IP_CONFIG_SOURCE_KERNEL;
nm_ip4_config_add_address (a, &addr);
test_addr = nm_ip4_config_get_address (a, 0);
test_addr = _nmtst_nm_ip4_config_get_address (a, 0);
g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_KERNEL);
addr.addr_source = NM_IP_CONFIG_SOURCE_USER;
nm_ip4_config_add_address (a, &addr);
test_addr = nm_ip4_config_get_address (a, 0);
test_addr = _nmtst_nm_ip4_config_get_address (a, 0);
g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_USER);
g_object_unref (a);

20
src/tests/test-ip6-config.c
View File

@@ -88,7 +88,7 @@ test_subtract (void)
/* ensure what's left is what we expect */
g_assert_cmpuint (nm_ip6_config_get_num_addresses (dst), ==, 1);
test_addr = nm_ip6_config_get_address (dst, 0);
test_addr = _nmtst_nm_ip6_config_get_address (dst, 0);
g_assert (test_addr != NULL);
tmp = *nmtst_inet6_from_string (expected_addr);
g_assert (memcmp (&test_addr->address, &tmp, sizeof (tmp)) == 0);
@@ -167,27 +167,27 @@ test_add_address_with_source (void)
addr.addr_source = NM_IP_CONFIG_SOURCE_USER;
nm_ip6_config_add_address (a, &addr);
test_addr = nm_ip6_config_get_address (a, 0);
test_addr = _nmtst_nm_ip6_config_get_address (a, 0);
g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_USER);
addr.addr_source = NM_IP_CONFIG_SOURCE_VPN;
nm_ip6_config_add_address (a, &addr);
test_addr = nm_ip6_config_get_address (a, 0);
test_addr = _nmtst_nm_ip6_config_get_address (a, 0);
g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_USER);
/* Test that a lower priority address source is overwritten */
nm_ip6_config_del_address (a, 0);
_nmtst_nm_ip6_config_del_address (a, 0);
addr.addr_source = NM_IP_CONFIG_SOURCE_KERNEL;
nm_ip6_config_add_address (a, &addr);
test_addr = nm_ip6_config_get_address (a, 0);
test_addr = _nmtst_nm_ip6_config_get_address (a, 0);
g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_KERNEL);
addr.addr_source = NM_IP_CONFIG_SOURCE_USER;
nm_ip6_config_add_address (a, &addr);
test_addr = nm_ip6_config_get_address (a, 0);
test_addr = _nmtst_nm_ip6_config_get_address (a, 0);
g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_USER);
g_object_unref (a);
@@ -256,18 +256,18 @@ test_nm_ip6_config_addresses_sort_check (NMIP6Config *config, NMSettingIP6Config
int j = g_rand_int_range (nmtst_get_rand (), i, addr_count);
NMTST_SWAP (idx[i], idx[j]);
nm_ip6_config_add_address (copy, nm_ip6_config_get_address (config, idx[i]));
nm_ip6_config_add_address (copy, _nmtst_nm_ip6_config_get_address (config, idx[i]));
}
/* reorder them again */
nm_ip6_config_addresses_sort (copy);
_nmtst_nm_ip6_config_addresses_sort (copy);
/* check equality using nm_ip6_config_equal() */
if (!nm_ip6_config_equal (copy, config)) {
g_message ("%s", "SORTING yields unexpected output:");
for (i = 0; i < addr_count; i++) {
g_message (" >> [%d] = %s", i, nm_platform_ip6_address_to_string (nm_ip6_config_get_address (config, i), NULL, 0));
g_message (" << [%d] = %s", i, nm_platform_ip6_address_to_string (nm_ip6_config_get_address (copy, i), NULL, 0));
g_message (" >> [%d] = %s", i, nm_platform_ip6_address_to_string (_nmtst_nm_ip6_config_get_address (config, i), NULL, 0));
g_message (" << [%d] = %s", i, nm_platform_ip6_address_to_string (_nmtst_nm_ip6_config_get_address (copy, i), NULL, 0));
}
g_assert_not_reached ();
}

14
src/vpn/nm-vpn-connection.c
View File

@@ -959,7 +959,8 @@ print_vpn_config (NMVpnConnection *self)
_LOGI ("Data: IPv4 configuration:");
address4 = nm_ip4_config_get_address (priv->ip4_config, 0);
address4 = nm_ip4_config_get_first_address (priv->ip4_config);
nm_assert (address4);
if (priv->ip4_internal_gw)
_LOGI ("Data: Internal Gateway: %s", nm_utils_inet4_ntop (priv->ip4_internal_gw, NULL));
@@ -968,7 +969,7 @@ print_vpn_config (NMVpnConnection *self)
_LOGI ("Data: Internal Point-to-Point Address: %s", nm_utils_inet4_ntop (address4->peer_address, NULL));
_LOGI ("Data: Maximum Segment Size (MSS): %d", nm_ip4_config_get_mss (priv->ip4_config));
nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, priv->ip4_config, &route) {
nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, priv->ip4_config, &route) {
_LOGI ("Data: Static Route: %s/%d Next Hop: %s",
nm_utils_inet4_ntop (route->network, NULL),
route->plen,
@@ -996,7 +997,8 @@ print_vpn_config (NMVpnConnection *self)
_LOGI ("Data: IPv6 configuration:");
address6 = nm_ip6_config_get_address (priv->ip6_config, 0);
address6 = nm_ip6_config_get_first_address (priv->ip6_config);
nm_assert (address6);
if (priv->ip6_internal_gw)
_LOGI ("Data: Internal Gateway: %s", nm_utils_inet6_ntop (priv->ip6_internal_gw, NULL));
@@ -1005,7 +1007,7 @@ print_vpn_config (NMVpnConnection *self)
_LOGI ("Data: Internal Point-to-Point Address: %s", nm_utils_inet6_ntop (&address6->peer_address, NULL));
_LOGI ("Data: Maximum Segment Size (MSS): %d", nm_ip6_config_get_mss (priv->ip6_config));
nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, priv->ip6_config, &route) {
nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, priv->ip6_config, &route) {
_LOGI ("Data: Static Route: %s/%d Next Hop: %s",
nm_utils_inet6_ntop (&route->network, NULL),
route->plen,
@@ -1506,7 +1508,7 @@ nm_vpn_connection_ip4_config_get (NMVpnConnection *self, GVariant *dict)
NMDedupMultiIter ipconf_iter;
const NMPlatformIP4Route *route;
nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, priv->ip4_config, &route)
nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, priv->ip4_config, &route)
nm_ip4_config_add_route (config, route);
}
} else if (g_variant_lookup (dict, NM_VPN_PLUGIN_IP4_CONFIG_ROUTES, "aau", &iter)) {
@@ -1670,7 +1672,7 @@ nm_vpn_connection_ip6_config_get (NMVpnConnection *self, GVariant *dict)
NMDedupMultiIter ipconf_iter;
const NMPlatformIP6Route *route;
nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, priv->ip6_config, &route)
nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, priv->ip6_config, &route)
nm_ip6_config_add_route (config, route);
}
} else if (g_variant_lookup (dict, NM_VPN_PLUGIN_IP6_CONFIG_ROUTES, "a(ayuayu)", &iter)) {