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)
{
NMIP4Config *config = NULL;
NMIP4Address *addr;
NMPlatformIP4Address address;
NMIP4Route *route;
config = nm_ip4_config_new ();
g_assert (config);
addr = nm_ip4_address_new ();
nm_ip4_address_set_address (addr, (guint32) lla.s_addr);
nm_ip4_address_set_prefix (addr, 16);
nm_ip4_config_take_address (config, addr);
memset (&address, 0, sizeof (address));
address.address = lla.s_addr;
address.plen = 16;
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 */
route = nm_ip4_route_new ();
@@ -2382,7 +2382,7 @@ static NMIP4Config *
shared4_new_config (NMDevice *self, NMDeviceStateReason *reason)
{
NMIP4Config *config = NULL;
NMIP4Address *addr;
NMPlatformIP4Address address;
guint32 tmp_addr;
g_return_val_if_fail (self != NULL, NULL);
@@ -2397,10 +2397,10 @@ shared4_new_config (NMDevice *self, NMDeviceStateReason *reason)
}
config = nm_ip4_config_new ();
addr = nm_ip4_address_new ();
nm_ip4_address_set_address (addr, tmp_addr);
nm_ip4_address_set_prefix (addr, 24);
nm_ip4_config_take_address (config, addr);
memset (&address, 0, sizeof (address));
address.address = tmp_addr;
address.plen = 24;
nm_ip4_config_add_address (config, &address);
/* Remove the address lock when the object gets disposed */
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_mask[INET_ADDRSTRLEN + 1];
guint32 netmask, network;
NMIP4Address *ip4_addr;
const NMPlatformIP4Address *ip4_addr;
const char *ip_iface;
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);
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;
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)))
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)))
return FALSE;
@@ -5998,11 +5998,11 @@ ip4_match_config (NMDevice *self, NMConnection *connection)
/* Find at least one lease's address on the device */
for (iter = leases; iter; iter = g_slist_next (iter)) {
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),
nm_ip4_address_get_address (addr),
nm_ip4_address_get_prefix (addr))) {
if (address && nm_platform_ip4_address_exists (nm_device_get_ip_ifindex (self),
address->address,
address->plen)) {
found = TRUE; /* Yay, device has same address as a lease */
break;
}

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

@@ -1136,9 +1136,9 @@ ip4_options_to_config (NMDHCPClient *self)
NMDHCPClientPrivate *priv;
NMIP4Config *ip4_config = NULL;
struct in_addr tmp_addr;
NMIP4Address *addr = NULL;
NMPlatformIP4Address address;
char *str = NULL;
guint32 gwaddr = 0, prefix = 0;
guint32 gwaddr = 0, plen = 0;
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);
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");
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);
} else
goto error;
str = g_hash_table_lookup (priv->options, "new_subnet_mask");
if (str && (inet_pton (AF_INET, str, &tmp_addr) > 0)) {
prefix = nm_utils_ip4_netmask_to_prefix (tmp_addr.s_addr);
nm_log_info (LOGD_DHCP4, " prefix %d (%s)", prefix, str);
plen = nm_utils_ip4_netmask_to_prefix (tmp_addr.s_addr);
nm_log_info (LOGD_DHCP4, " plen %d (%s)", plen, str);
} else {
/* Get default netmask for the IP according to appropriate class. */
prefix = nm_utils_ip4_get_default_prefix (nm_ip4_address_get_address (addr));
nm_log_info (LOGD_DHCP4, " prefix %d (default)", prefix);
plen = nm_utils_ip4_get_default_prefix (address.address);
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
* the 'static_routes' option.
@@ -1200,8 +1200,7 @@ ip4_options_to_config (NMDHCPClient *self)
}
}
nm_ip4_config_take_address (ip4_config, addr);
addr = NULL;
nm_ip4_config_add_address (ip4_config, &address);
str = g_hash_table_lookup (priv->options, "new_host_name");
if (str)
@@ -1290,8 +1289,6 @@ ip4_options_to_config (NMDHCPClient *self)
return ip4_config;
error:
if (addr)
nm_ip4_address_unref (addr);
g_object_unref (ip4_config);
return NULL;
}
@@ -1333,7 +1330,7 @@ ip6_options_to_config (NMDHCPClient *self)
NMDHCPClientPrivate *priv;
NMIP6Config *ip6_config = NULL;
struct in6_addr tmp_addr;
NMIP6Address *addr = NULL;
NMPlatformIP6Address address;
char *str = NULL;
GHashTableIter iter;
gpointer key, value;
@@ -1359,14 +1356,12 @@ ip6_options_to_config (NMDHCPClient *self)
goto error;
}
addr = nm_ip6_address_new ();
g_assert (addr);
nm_ip6_address_set_address (addr, &tmp_addr);
/* DHCPv6 IA_NA assignments are single address only */
nm_ip6_address_set_prefix (addr, 128);
nm_log_info (LOGD_DHCP6, " address %s/128", str);
memset (&address, 0, sizeof (address));
address.address = tmp_addr;
address.plen = 128;
nm_log_info (LOGD_DHCP6, " address %s", str);
nm_ip6_config_take_address (ip6_config, addr);
nm_ip6_config_add_address (ip6_config, &address);
} else if (priv->info_only == FALSE) {
/* No address in Managed mode is a hard 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)) {
NMIP4Config *ip4;
NMIP4Address *addr;
NMPlatformIP4Address address;
const char *data;
struct in_addr tmp;
guint32 prefix;
guint32 plen;
struct tm expire;
hash = iter->data;
@@ -295,14 +295,14 @@ nm_dhcp_dhclient_get_lease_config (const char *iface, const char *uuid, gboolean
continue;
ip4 = nm_ip4_config_new ();
addr = nm_ip4_address_new ();
memset (&address, 0, sizeof (address));
/* IP4 address */
if (!inet_pton (AF_INET, data, &tmp)) {
nm_log_warn (LOGD_DHCP, "couldn't parse DHCP lease file IP4 address '%s'", data);
goto error;
}
nm_ip4_address_set_address (addr, tmp.s_addr);
address.address = tmp.s_addr;
/* Netmask */
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);
goto error;
}
prefix = nm_utils_ip4_netmask_to_prefix (tmp.s_addr);
plen = nm_utils_ip4_netmask_to_prefix (tmp.s_addr);
} else {
/* 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 */
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_take_address (ip4, addr);
nm_ip4_config_add_address (ip4, &address);
leases = g_slist_append (leases, ip4);
continue;
error:
nm_ip4_address_unref (addr);
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++) {
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++) {

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;
NMCmdLine *cmd;
GString *s;
NMIP4Address *tmp;
const NMPlatformIP4Address *tmp;
struct in_addr addr;
char buf[INET_ADDRSTRLEN + 15];
char localaddr[INET_ADDRSTRLEN + 1];
@@ -294,7 +294,7 @@ create_dm_cmd_line (const char *iface,
nm_cmd_line_add_string (cmd, "--strict-order");
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)) {
char *err_msg = g_strdup_printf ("error converting IP4 address 0x%X",
ntohl (addr.s_addr));
@@ -310,7 +310,7 @@ create_dm_cmd_line (const char *iface,
s = g_string_new ("--dhcp-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)) {
char *err_msg = g_strdup_printf ("error converting IP4 address 0x%X",
ntohl (addr.s_addr));
@@ -324,7 +324,7 @@ create_dm_cmd_line (const char *iface,
g_string_append_c (s, ',');
/* 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)) {
char *err_msg = g_strdup_printf ("error converting IP4 address 0x%X",
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;
struct rtnl_addr *rtnladdr;
struct nl_addr *nladdr;
struct in6_addr *addr;
NMIP6Address *ip6addr;
NMPlatformIP6Address address;
struct rtnl_route *rtnlroute;
struct rtnl_nexthop *nexthop;
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)
continue;
addr = nl_addr_get_binary_addr (nladdr);
ip6addr = nm_ip6_address_new ();
nm_ip6_address_set_prefix (ip6addr, rtnl_addr_get_prefixlen (rtnladdr));
nm_ip6_address_set_address (ip6addr, addr);
nm_ip6_config_take_address (config, ip6addr);
memset (&address, 0, sizeof (address));
address.address = *(struct in6_addr *) nl_addr_get_binary_addr (nladdr);
address.plen = rtnl_addr_get_prefixlen (rtnladdr);
nm_ip6_config_add_address (config, &address);
}
/* 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;
const gchar *address_string;
guint32 address_network;
NMIP4Address *addr;
NMPlatformIP4Address address;
const gchar **dns;
guint i;
guint prefix;
g_assert (self->priv->ipv4_config);
@@ -653,12 +652,11 @@ static_stage3_done (NMModemBroadband *self)
}
config = nm_ip4_config_new ();
addr = nm_ip4_address_new ();
nm_ip4_address_set_address (addr, address_network);
prefix = mm_bearer_ip_config_get_prefix (self->priv->ipv4_config);
if (prefix > 0)
nm_ip4_address_set_prefix (addr, prefix);
nm_ip4_config_take_address (config, addr);
memset (&address, 0, sizeof (address));
address.address = address_network;
address.plen = mm_bearer_ip_config_get_prefix (self->priv->ipv4_config);
nm_ip4_config_add_address (config, &address);
nm_log_info (LOGD_MB, " address %s/%d",
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,
G_TYPE_VALUE_ARRAY, &ret_array,
G_TYPE_INVALID)) {
NMIP4Address *addr;
NMPlatformIP4Address address;
int i;
config = nm_ip4_config_new ();
addr = nm_ip4_address_new ();
memset (&address, 0, sizeof (address));
nm_log_info (LOGD_MB, "(%s): IPv4 static configuration:",
nm_modem_get_uid (NM_MODEM (self)));
/* IP address */
nm_ip4_address_set_address (addr, g_value_get_uint (g_value_array_get_nth (ret_array, 0)));
nm_ip4_address_set_prefix (addr, 32);
nm_ip4_config_take_address (config, addr);
address.address = g_value_get_uint (g_value_array_get_nth (ret_array, 0));
address.plen = 32;
nm_ip4_config_add_address (config, &address);
nm_log_info (LOGD_MB, " address %s/%d",
ip_address_to_string (nm_ip4_address_get_address (addr)),
nm_ip4_address_get_prefix (addr));
ip_address_to_string (address.address),
address.plen);
/* DNS servers */
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
|| 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);
if (nm_ip4_address_get_prefix (addr) == 32)
g_assert (address);
if (address->plen == 32)
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 "gsystem-local-alloc.h"
#include "nm-platform.h"
#include "nm-utils.h"
#include "nm-dbus-manager.h"
@@ -39,7 +40,7 @@ typedef struct {
gboolean never_default;
guint32 gateway;
GSList *addresses;
GArray *addresses;
GSList *routes;
GArray *nameservers;
GPtrArray *domains;
@@ -106,31 +107,22 @@ same_prefix (guint32 address1, guint32 address2, int plen)
NMIP4Config *
nm_ip4_config_capture (int ifindex)
{
NMIP4Config *config;
GArray *addrs_array, *routes_array;
NMPlatformIP4Address *addrs;
NMIP4Config *config = nm_ip4_config_new ();
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config);
GArray *routes_array;
NMPlatformIP4Route *routes;
NMIP4Address *addr;
NMIP4Route *route;
int i;
addrs_array = nm_platform_ip4_address_get_all (ifindex);
if (addrs_array->len == 0) {
g_array_unref (addrs_array);
g_array_unref (priv->addresses);
priv->addresses = nm_platform_ip4_address_get_all (ifindex);
/* Require at least one IP address. */
if (!priv->addresses->len) {
g_object_unref (config);
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 = (NMPlatformIP4Route *)routes_array->data;
for (i = 0; i < routes_array->len; i++) {
@@ -155,6 +147,7 @@ nm_ip4_config_capture (int ifindex)
gboolean
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 i;
@@ -162,23 +155,7 @@ nm_ip4_config_commit (NMIP4Config *config, int ifindex, int priority)
g_return_val_if_fail (config != NULL, FALSE);
/* 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);
}
nm_platform_ip4_address_sync (ifindex, priv->addresses);
/* Routes */
{
@@ -250,8 +227,16 @@ nm_ip4_config_merge_setting (NMIP4Config *config, NMSettingIP4Config *setting)
}
/* Addresses */
for (i = 0; i < naddresses; i++)
nm_ip4_config_add_address (config, nm_setting_ip4_config_get_address (setting, i));
for (i = 0; i < naddresses; 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 */
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;
for (i = 0; i < naddresses; i++) {
NMIP4Address *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);
const NMPlatformIP4Address *item = nm_ip4_config_get_address (config, i);
if (item_plen <= plen && same_prefix (item_address, network, item_plen))
if (item->plen <= plen && same_prefix (item->address, network, item->plen))
return TRUE;
}
@@ -332,43 +315,31 @@ nm_ip4_config_reset_addresses (NMIP4Config *config)
{
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config);
g_slist_free_full (priv->addresses, (GDestroyNotify) nm_ip4_address_unref);
priv->addresses = NULL;
g_array_set_size (priv->addresses, 0);
}
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 FALSE;
return TRUE;
return a->address == b->address;
}
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);
GSList *iter;
int i;
for (iter = priv->addresses; iter; iter = g_slist_next (iter)) {
NMIP4Address *item = (NMIP4Address *) iter->data;
for (i = 0; i < priv->addresses->len; i++ ) {
NMPlatformIP4Address *item = &g_array_index (priv->addresses, NMPlatformIP4Address, i);
if (addresses_are_duplicate (item, new)) {
nm_ip4_address_unref (item);
iter->data = nm_ip4_address_dup (new);
memcpy (item, new, sizeof (*item));
return;
}
}
priv->addresses = g_slist_append (priv->addresses, nm_ip4_address_dup (new));
}
void
nm_ip4_config_take_address (NMIP4Config *config, NMIP4Address *address)
{
nm_ip4_config_add_address (config, address);
nm_ip4_address_unref (address);
g_array_append_val (priv->addresses, *new);
}
guint
@@ -376,15 +347,15 @@ nm_ip4_config_get_num_addresses (NMIP4Config *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)
{
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));
for (i = 0; i < nm_ip4_config_get_num_addresses (config); i++) {
NMIP4Address *a = nm_ip4_config_get_address (config, i);
hash_u32 (sum, nm_ip4_address_get_address (a));
hash_u32 (sum, nm_ip4_address_get_prefix (a));
const NMPlatformIP4Address *address = nm_ip4_config_get_address (config, i);
hash_u32 (sum, address->address);
hash_u32 (sum, address->plen);
}
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);
priv->addresses = g_array_new (FALSE, FALSE, sizeof (NMPlatformIP4Address));
priv->nameservers = g_array_new (FALSE, FALSE, sizeof (guint32));
priv->domains = 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);
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_array_unref (priv->nameservers);
g_ptr_array_unref (priv->domains);
@@ -846,11 +817,30 @@ static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMIP4Config *config = NM_IP4_CONFIG (object);
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (object);
in_addr_t gateway = nm_ip4_config_get_gateway (config);
switch (prop_id) {
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;
case PROP_ROUTES:
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>
/* NMIP4Address and NMIP4Route types */
#include "nm-platform.h"
/* NMIP4Route type */
#include "nm-setting-ip4-config.h"
#define NM_TYPE_IP4_CONFIG (nm_ip4_config_get_type ())
@@ -72,10 +73,9 @@ guint32 nm_ip4_config_get_gateway (NMIP4Config *config);
/* Addresses */
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, NMIP4Address *address);
void nm_ip4_config_add_address (NMIP4Config *config, const NMPlatformIP4Address *address);
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 */
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-glib-compat.h"
#include "gsystem-local-alloc.h"
#include "nm-platform.h"
#include "nm-utils.h"
#include "nm-dbus-manager.h"
@@ -38,7 +40,7 @@ typedef struct {
gboolean never_default;
struct in6_addr gateway;
GSList *addresses;
GArray *addresses;
GSList *routes;
GArray *nameservers;
GPtrArray *domains;
@@ -108,31 +110,21 @@ same_prefix (const struct in6_addr *address1, const struct in6_addr *address2, i
NMIP6Config *
nm_ip6_config_capture (int ifindex)
{
NMIP6Config *config;
GArray *addrs_array, *routes_array;
NMPlatformIP6Address *addrs;
NMIP6Config *config = nm_ip6_config_new ();
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config);
GArray *routes_array;
NMPlatformIP6Route *routes;
NMIP6Address *addr;
NMIP6Route *route;
int i;
addrs_array = nm_platform_ip6_address_get_all (ifindex);
if (addrs_array->len == 0) {
g_array_unref (addrs_array);
g_array_unref (priv->addresses);
priv->addresses = nm_platform_ip6_address_get_all (ifindex);
if (!priv->addresses->len) {
g_object_unref (config);
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 = (NMPlatformIP6Route *)routes_array->data;
for (i = 0; i < routes_array->len; i++) {
@@ -157,29 +149,14 @@ nm_ip6_config_capture (int ifindex)
gboolean
nm_ip6_config_commit (NMIP6Config *config, int ifindex, int priority)
{
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config);
int i;
g_return_val_if_fail (ifindex > 0, FALSE);
g_return_val_if_fail (config != NULL, FALSE);
/* 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);
}
nm_platform_ip6_address_sync (ifindex, priv->addresses);
/* Routes */
{
@@ -253,8 +230,16 @@ nm_ip6_config_merge_setting (NMIP6Config *config, NMSettingIP6Config *setting)
}
/* Addresses */
for (i = 0; i < naddresses; i++)
nm_ip6_config_add_address (config, nm_setting_ip6_config_get_address (setting, i));
for (i = 0; i < naddresses; 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 */
if (nm_setting_ip6_config_get_ignore_auto_routes (setting))
@@ -319,16 +304,13 @@ nm_ip6_config_merge (NMIP6Config *dst, NMIP6Config *src)
gboolean
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;
num = nm_ip6_config_get_num_addresses (config);
for (i = 0; i < num; i++) {
NMIP6Address *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);
NMPlatformIP6Address *item = nm_ip6_config_get_address (config, i);
if (item_plen <= plen && same_prefix (item_address, network, item_plen))
if (item->plen <= plen && same_prefix (&item->address, network, item->plen))
return TRUE;
}
@@ -379,43 +361,31 @@ nm_ip6_config_reset_addresses (NMIP6Config *config)
{
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config);
g_slist_free_full (priv->addresses, (GDestroyNotify) nm_ip6_address_unref);
priv->addresses = NULL;
g_array_set_size (priv->nameservers, 0);
}
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 FALSE;
return TRUE;
return IN6_ARE_ADDR_EQUAL (&a->address, &b->address);
}
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);
GSList *iter;
int i;
for (iter = priv->addresses; iter; iter = g_slist_next (iter)) {
NMIP6Address *item = (NMIP6Address *) iter->data;
for (i = 0; i < priv->addresses->len; i++ ) {
NMPlatformIP6Address *item = &g_array_index (priv->addresses, NMPlatformIP6Address, i);
if (addresses_are_duplicate (item, new)) {
nm_ip6_address_unref (item);
iter->data = nm_ip6_address_dup (new);
memcpy (item, new, sizeof (*item));
return;
}
}
priv->addresses = g_slist_append (priv->addresses, nm_ip6_address_dup (new));
}
void
nm_ip6_config_take_address (NMIP6Config *config, NMIP6Address *address)
{
nm_ip6_config_add_address (config, address);
nm_ip6_address_unref (address);
g_array_append_val (priv->addresses, *new);
}
guint
@@ -423,15 +393,15 @@ nm_ip6_config_get_num_addresses (NMIP6Config *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)
{
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));
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_u32 (sum, nm_ip6_address_get_prefix (a));
hash_in6addr (sum, &address->address);
hash_u32 (sum, address->plen);
}
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);
priv->addresses = g_array_new (FALSE, TRUE, sizeof (NMPlatformIP6Address));
priv->nameservers = g_array_new (FALSE, TRUE, sizeof (struct in6_addr));
priv->domains = 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);
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_array_unref (priv->nameservers);
g_ptr_array_unref (priv->domains);
@@ -796,11 +767,51 @@ static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMIP6Config *config = NM_IP6_CONFIG (object);
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (object);
switch (prop_id) {
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;
case PROP_NAMESERVERS:
nameservers_to_gvalue (priv->nameservers, value);

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

@@ -23,8 +23,10 @@
#include <glib-object.h>
/* NMIP6Address and NMIP6Route types */
#include "nm-platform.h"
/* NMIP6Route type */
#include "nm-setting-ip6-config.h"
#include "nm-platform.h"
#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))
@@ -72,10 +74,9 @@ const struct in6_addr *nm_ip6_config_get_gateway (NMIP6Config *config);
/* Addresses */
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, NMIP6Address *address);
void nm_ip6_config_add_address (NMIP6Config *config, const NMPlatformIP6Address *address);
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 */
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) {
NMIP4Config *ip4_config;
NMIP4Address *addr4;
guint32 addrbytes;
const NMPlatformIP4Address *addr4;
ip4_config = nm_device_get_ip4_config (best4);
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);
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 *)&addrbytes,
policy->lookup_addr = g_inet_address_new_from_bytes ((guint8 *) &addr4->address,
G_SOCKET_FAMILY_IPV4);
} else {
NMIP6Config *ip6_config;
NMIP6Address *addr6;
const struct in6_addr *addrbytes;
NMPlatformIP6Address *addr6;
ip6_config = nm_device_get_ip6_config (best6);
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);
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 *)&addrbytes,
policy->lookup_addr = g_inet_address_new_from_bytes ((guint8 *) &addr6->address,
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;
NMSettingPPP *s_ppp;
NMIP4Config *config;
NMIP4Address *addr;
NMPlatformIP4Address address;
GValue *val;
int i;
@@ -517,28 +517,27 @@ impl_ppp_manager_set_ip4_config (NMPPPManager *manager,
remove_timeout_handler (manager);
config = nm_ip4_config_new ();
addr = nm_ip4_address_new ();
nm_ip4_address_set_prefix (addr, 32);
memset (&address, 0, sizeof (address));
address.plen = 32;
val = (GValue *) g_hash_table_lookup (config_hash, NM_PPP_IP4_CONFIG_GATEWAY);
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));
}
val = (GValue *) g_hash_table_lookup (config_hash, NM_PPP_IP4_CONFIG_ADDRESS);
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);
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)) {
nm_ip4_config_take_address (config, addr);
if (address.address && address.plen) {
nm_ip4_config_add_address (config, &address);
} else {
nm_log_err (LOGD_PPP, "invalid IPv4 address received!");
nm_ip4_address_unref (addr);
goto out;
}

1
src/tests/Makefile.am
View File

@@ -3,6 +3,7 @@ INCLUDES = \
-I$(top_builddir)/include \
-I$(top_srcdir)/libnm-util \
-I$(top_builddir)/libnm-util \
-I$(top_srcdir)/src/platform \
-I$(top_srcdir)/src/dhcp-manager \
-I$(top_srcdir)/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;
NMIP4Config *ip4_config;
NMIP4Address *addr;
const NMPlatformIP4Address *address;
NMIP4Route *route;
struct in_addr tmp;
const char *expected_addr = "192.168.1.106";
@@ -123,14 +123,14 @@ test_generic_options (const char *client)
/* IP4 address */
ASSERT (nm_ip4_config_get_num_addresses (ip4_config) == 1,
"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,
"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");
ASSERT (nm_ip4_address_get_prefix (addr) == 24,
ASSERT (address->plen == 24,
"dhcp-generic", "unexpected IP address prefix length");
/* Gateway */
@@ -219,7 +219,7 @@ test_wins_options (const char *client)
{
GHashTable *options;
NMIP4Config *ip4_config;
NMIP4Address *addr;
const NMPlatformIP4Address *address;
struct in_addr tmp;
const char *expected_wins1 = "63.12.199.5";
const char *expected_wins2 = "150.4.88.120";
@@ -234,7 +234,7 @@ test_wins_options (const char *client)
/* IP4 address */
ASSERT (nm_ip4_config_get_num_addresses (ip4_config) == 1,
"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,
"dhcp-wins", "unexpected number of WINS servers");
@@ -284,12 +284,10 @@ ip4_test_gateway (const char *test,
NMIP4Config *ip4_config,
const char *expected_gw)
{
NMIP4Address *addr;
struct in_addr tmp;
ASSERT (nm_ip4_config_get_num_addresses (ip4_config) == 1,
test, "unexpected number of IP addresses");
addr = nm_ip4_config_get_address (ip4_config, 0);
ASSERT (inet_pton (AF_INET, expected_gw, &tmp) > 0,
test, "couldn't convert expected IP gateway");
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;
NMIP4Config *ip4_config;
NMIP4Address *addr;
const NMPlatformIP4Address *address;
options = fill_table (generic_options, NULL);
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,
"dhcp-ip4-missing-prefix", "unexpected number of IP4 addresses (not 1)");
addr = nm_ip4_config_get_address (ip4_config, 0);
ASSERT (addr != NULL,
address = nm_ip4_config_get_address (ip4_config, 0);
ASSERT (address,
"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)",
nm_ip4_address_get_prefix (addr), expected_prefix);
address->plen, expected_prefix);
g_hash_table_destroy (options);
}
@@ -747,7 +745,7 @@ test_ip4_prefix_classless (const char *client)
{
GHashTable *options;
NMIP4Config *ip4_config;
NMIP4Address *addr;
const NMPlatformIP4Address *address;
/* Ensure that the missing-subnet-mask handler doesn't mangle classless
* 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,
"dhcp-ip4-prefix-classless", "unexpected number of IP4 addresses (not 1)");
addr = nm_ip4_config_get_address (ip4_config, 0);
ASSERT (addr != NULL,
address = nm_ip4_config_get_address (ip4_config, 0);
ASSERT (address,
"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)",
nm_ip4_address_get_prefix (addr));
address->plen);
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)
{
NMVPNConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (connection);
NMIP4Address *addr;
NMIP6Address *addr6;
const NMPlatformIP4Address *address4;
const NMPlatformIP6Address *address6;
char *dns_domain = NULL;
guint32 num, i;
@@ -620,12 +620,12 @@ print_vpn_config (NMVPNConnection *connection)
if (priv->ip4_config) {
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)
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 Prefix: %d", nm_ip4_address_get_prefix (addr));
nm_log_info (LOGD_VPN, " Internal Address: %s", ip_address_to_string (address4->address));
nm_log_info (LOGD_VPN, " Internal Prefix: %d", address4->plen);
nm_log_info (LOGD_VPN, " Internal Point-to-Point Address: %s",
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));
@@ -660,12 +660,12 @@ print_vpn_config (NMVPNConnection *connection)
if (priv->ip6_config) {
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)
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 Prefix: %d", nm_ip6_address_get_prefix (addr6));
nm_log_info (LOGD_VPN, " Internal Address: %s", ip6_address_to_string (&address6->address));
nm_log_info (LOGD_VPN, " Internal Prefix: %d", address6->plen);
nm_log_info (LOGD_VPN, " Internal Point-to-Point Address: %s",
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));
@@ -877,8 +877,7 @@ nm_vpn_connection_ip4_config_get (DBusGProxy *proxy,
{
NMVPNConnection *connection = NM_VPN_CONNECTION (user_data);
NMVPNConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (connection);
NMSettingIP4Config *s_ip4;
NMIP4Address *addr;
NMPlatformIP4Address address;
NMIP4Config *config;
GValue *val;
int i;
@@ -908,10 +907,10 @@ nm_vpn_connection_ip4_config_get (DBusGProxy *proxy,
config = nm_ip4_config_new ();
addr = nm_ip4_address_new ();
nm_ip4_address_set_prefix (addr, 24); /* default to class C */
memset (&address, 0, sizeof (address));
address.plen = 24;
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 */
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);
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);
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);
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)) {
nm_ip4_config_take_address (config, addr);
if (address.address && address.plen) {
nm_ip4_config_add_address (config, &address);
} else {
nm_log_err (LOGD_VPN, "invalid IP4 config received!");
nm_ip4_address_unref (addr);
g_object_unref (config);
nm_vpn_connection_config_maybe_complete (connection, FALSE);
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));
/* 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, s_ip4);
nm_ip4_config_merge_setting (config, nm_connection_get_setting_ip4_config (priv->connection));
priv->ip4_config = config;
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);
NMVPNConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (connection);
NMSettingIP6Config *s_ip6;
NMIP6Address *addr;
NMPlatformIP6Address address;
NMIP6Config *config;
GValue *val;
int i;
@@ -1040,10 +1036,10 @@ nm_vpn_connection_ip6_config_get (DBusGProxy *proxy,
config = nm_ip6_config_new ();
addr = nm_ip6_address_new ();
nm_ip6_address_set_prefix (addr, 128); /* default to class C */
memset (&address, 0, sizeof (address));
address.plen = 128;
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 */
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);
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);
@@ -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);
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)) {
nm_ip6_config_take_address (config, addr);
} else {
if (IN6_IS_ADDR_UNSPECIFIED (&address.address) && address.plen)
nm_ip6_config_add_address (config, &address);
else {
nm_log_err (LOGD_VPN, "invalid IP6 config received!");
nm_ip6_address_unref (addr);
g_object_unref (config);
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));
/* 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, s_ip6);
nm_ip6_config_merge_setting (config, nm_connection_get_setting_ip6_config (priv->connection));
priv->ip6_config = config;
nm_vpn_connection_config_maybe_complete (connection, TRUE);