Commit e8824f6a authored by Thomas Haller's avatar Thomas Haller

policy: add manager for default routes and support multiple default routes

Up to now, NMPolicy would iterate over all devices to find the "best"
device and assign the default route to that device.

A better approach is to add a default route to *all* devices that
are never-default=no. The relative priority is choosen according to
the route metrics.

If two devices receive the same metric, we want to prefer the device
that activates first. That way, the default route sticks to the same
device until a better device activates or the device deactivates.
Hence, the order of activation is imporant in this case (as it is
already now).

Also, if several devices have identical metrics, increment their
metrics so that every metric is unique.
This makes the routing deterministic according to what we choose as best
device.

A special case is assumed devices. In this case we cannot adjust the metric
in face of equal metrics.

Add a new singleton class NMDefaultRouteManager that has a list of all
devices and their default routes. The manager will order the devices by
their priority and configure the routes using platform.

Also update the metric for VPN connections. Later we will track VPN
routes also via NMDefaultRouteManager. For now, fix the VPN metric because
otherwise VPNs would always get metric 1024 (which is usually much larger then the
device metrics).

https://bugzilla.gnome.org/show_bug.cgi?id=735512Signed-off-by: Thomas Haller's avatarThomas Haller <thaller@redhat.com>
parent cc9fad61
......@@ -281,6 +281,8 @@ nm_sources = \
nm-dbus-manager.h \
nm-dcb.c \
nm-dcb.h \
nm-default-route-manager.c \
nm-default-route-manager.h \
nm-dhcp4-config.c \
nm-dhcp4-config.h \
nm-dhcp6-config.c \
......
......@@ -68,6 +68,7 @@
#include "nm-config.h"
#include "nm-dns-manager.h"
#include "nm-core-internal.h"
#include "nm-default-route-manager.h"
#include "nm-device-logging.h"
_LOG_DECLARE_SELF (NMDevice);
......@@ -237,6 +238,12 @@ typedef struct {
NMIP4Config * dev_ip4_config; /* Config from DHCP, PPP, LLv4, etc */
NMIP4Config * ext_ip4_config; /* Stuff added outside NM */
NMIP4Config * wwan_ip4_config; /* WWAN configuration */
struct {
gboolean v4_has;
NMPlatformIP4Route v4;
gboolean v6_has;
NMPlatformIP6Route v6;
} default_route;
/* DHCPv4 tracking */
NMDhcpClient * dhcp4_client;
......@@ -713,6 +720,30 @@ nm_device_get_ip6_route_metric (NMDevice *self)
return route_metric >= 0 ? route_metric : nm_device_get_priority (self);
}
const NMPlatformIP4Route *
nm_device_get_ip4_default_route (NMDevice *self)
{
NMDevicePrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE (self), NULL);
priv = NM_DEVICE_GET_PRIVATE (self);
return priv->default_route.v4_has ? &priv->default_route.v4 : NULL;
}
const NMPlatformIP6Route *
nm_device_get_ip6_default_route (NMDevice *self)
{
NMDevicePrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE (self), NULL);
priv = NM_DEVICE_GET_PRIVATE (self);
return priv->default_route.v6_has ? &priv->default_route.v6 : NULL;
}
const char *
nm_device_get_type_desc (NMDevice *self)
{
......@@ -2636,6 +2667,52 @@ aipd_start (NMDevice *self, NMDeviceStateReason *reason)
return NM_ACT_STAGE_RETURN_POSTPONE;
}
/*********************************************/
static gboolean
_device_get_default_route_from_platform (NMDevice *self, int addr_family, NMPlatformIPRoute *out_route)
{
gboolean success = FALSE;
int ifindex = nm_device_get_ip_ifindex (self);
GArray *routes;
if (addr_family == AF_INET)
routes = nm_platform_ip4_route_get_all (ifindex, NM_PLATFORM_GET_ROUTE_MODE_ONLY_DEFAULT);
else
routes = nm_platform_ip6_route_get_all (ifindex, NM_PLATFORM_GET_ROUTE_MODE_ONLY_DEFAULT);
if (routes) {
guint route_metric = G_MAXUINT32, m;
const NMPlatformIPRoute *route = NULL, *r;
guint i;
/* if there are several default routes, find the one with the best metric */
for (i = 0; i < routes->len; i++) {
if (addr_family == AF_INET) {
r = (const NMPlatformIPRoute *) &g_array_index (routes, NMPlatformIP4Route, i);
m = r->metric;
} else {
r = (const NMPlatformIPRoute *) &g_array_index (routes, NMPlatformIP6Route, i);
m = nm_utils_ip6_route_metric_normalize (r->metric);
}
if (!route || m < route_metric) {
route = r;
route_metric = m;
}
}
if (route) {
if (addr_family == AF_INET)
*((NMPlatformIP4Route *) out_route) = *((NMPlatformIP4Route *) route);
else
*((NMPlatformIP6Route *) out_route) = *((NMPlatformIP6Route *) route);
success = TRUE;
}
g_array_free (routes, TRUE);
}
return success;
}
/*********************************************/
/* DHCPv4 stuff */
......@@ -2701,11 +2778,58 @@ ip4_config_merge_and_apply (NMDevice *self,
* be redundant, so don't bother.
*/
connection = nm_device_get_connection (self);
if ( connection
&& !nm_settings_connection_get_nm_generated_assumed (NM_SETTINGS_CONNECTION (connection))) {
nm_ip4_config_merge_setting (composite,
nm_connection_get_setting_ip4_config (connection),
nm_device_get_ip4_route_metric (self));
priv->default_route.v4_has = FALSE;
if (connection) {
gboolean assumed = nm_device_uses_assumed_connection (self);
if (!nm_settings_connection_get_nm_generated_assumed (NM_SETTINGS_CONNECTION (connection))) {
nm_ip4_config_merge_setting (composite,
nm_connection_get_setting_ip4_config (connection),
nm_device_get_ip4_route_metric (self));
}
/* Add the default route.
*
* We keep track of the default route of a device in a private field.
* NMDevice needs to know the default route at this point, because the gateway
* might require a direct route (see below).
*
* But also, we don't want to add the default route to priv->ip4_config,
* because the default route from the setting might not be the same that
* NMDefaultRouteManager eventually configures (because the it might
* tweak the effective metric).
*/
if (nm_default_route_manager_ip4_connection_has_default_route (nm_default_route_manager_get (), connection)) {
guint32 gateway = 0;
NMPlatformIP4Route *route = &priv->default_route.v4;
if (assumed)
priv->default_route.v4_has = _device_get_default_route_from_platform (self, AF_INET, (NMPlatformIPRoute *) route);
else {
gateway = nm_ip4_config_get_gateway (composite);
if ( gateway
|| nm_device_get_device_type (self) == NM_DEVICE_TYPE_MODEM) {
memset (route, 0, sizeof (*route));
route->source = NM_IP_CONFIG_SOURCE_USER;
route->gateway = gateway;
route->metric = nm_device_get_ip4_route_metric (self);
route->mss = nm_ip4_config_get_mss (composite);
priv->default_route.v4_has = TRUE;
if ( gateway
&& !nm_ip4_config_get_subnet_for_host (composite, gateway)
&& !nm_ip4_config_get_direct_route_for_host (composite, gateway)) {
/* add a direct route to the gateway */
NMPlatformIP4Route r = *route;
r.network = gateway;
r.plen = 32;
r.gateway = 0;
nm_ip4_config_add_route (composite, &r);
}
}
}
}
}
/* Allow setting MTU etc */
......@@ -3202,11 +3326,58 @@ ip6_config_merge_and_apply (NMDevice *self,
* be redundant, so don't bother.
*/
connection = nm_device_get_connection (self);
if ( connection
&& !nm_settings_connection_get_nm_generated_assumed (NM_SETTINGS_CONNECTION (connection))) {
nm_ip6_config_merge_setting (composite,
nm_connection_get_setting_ip6_config (connection),
nm_device_get_ip6_route_metric (self));
priv->default_route.v6_has = FALSE;
if (connection) {
gboolean assumed = nm_device_uses_assumed_connection (self);
if (!nm_settings_connection_get_nm_generated_assumed (NM_SETTINGS_CONNECTION (connection))) {
nm_ip6_config_merge_setting (composite,
nm_connection_get_setting_ip6_config (connection),
nm_device_get_ip6_route_metric (self));
}
/* Add the default route.
*
* We keep track of the default route of a device in a private field.
* NMDevice needs to know the default route at this point, because the gateway
* might require a direct route (see below).
*
* But also, we don't want to add the default route to priv->ip4_config,
* because the default route from the setting might not be the same that
* NMDefaultRouteManager eventually configures (because the it might
* tweak the effective metric).
*/
if (nm_default_route_manager_ip6_connection_has_default_route (nm_default_route_manager_get (), connection)) {
const struct in6_addr *gateway = NULL;
NMPlatformIP6Route *route = &priv->default_route.v6;
if (assumed)
priv->default_route.v6_has = _device_get_default_route_from_platform (self, AF_INET, (NMPlatformIPRoute *) route);
else {
gateway = nm_ip6_config_get_gateway (composite);
if ( gateway
|| nm_device_get_device_type (self) == NM_DEVICE_TYPE_MODEM) {
memset (route, 0, sizeof (*route));
route->source = NM_IP_CONFIG_SOURCE_USER;
route->gateway = gateway ? *gateway : in6addr_any;
route->metric = nm_device_get_ip6_route_metric (self);
route->mss = nm_ip6_config_get_mss (composite);
priv->default_route.v6_has = TRUE;
if ( gateway
&& !nm_ip6_config_get_subnet_for_host (composite, gateway)
&& !nm_ip6_config_get_direct_route_for_host (composite, gateway)) {
/* add a direct route to the gateway */
NMPlatformIP6Route r = *route;
r.network = *gateway;
r.plen = 128;
r.gateway = in6addr_any;
nm_ip6_config_add_route (composite, &r);
}
}
}
}
}
nm_ip6_config_addresses_sort (composite,
......@@ -5405,6 +5576,8 @@ nm_device_set_ip4_config (NMDevice *self,
g_clear_object (&priv->dev_ip4_config);
}
nm_default_route_manager_ip4_update_default_route (nm_default_route_manager_get (), self);
if (has_changes) {
_update_ip4_address (self);
......@@ -5526,6 +5699,8 @@ nm_device_set_ip6_config (NMDevice *self,
nm_ip6_config_get_dbus_path (old_config));
}
nm_default_route_manager_ip6_update_default_route (nm_default_route_manager_get (), self);
if (has_changes) {
if (old_config != priv->ip6_config)
g_object_notify (G_OBJECT (self), NM_DEVICE_IP6_CONFIG);
......@@ -6720,6 +6895,12 @@ _cleanup_generic_post (NMDevice *self, gboolean deconfigure)
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
NMDeviceStateReason ignored = NM_DEVICE_STATE_REASON_NONE;
priv->default_route.v4_has = FALSE;
priv->default_route.v6_has = FALSE;
nm_default_route_manager_ip4_remove_default_route (nm_default_route_manager_get (), self);
nm_default_route_manager_ip6_remove_default_route (nm_default_route_manager_get (), self);
/* Clean up IP configs; this does not actually deconfigure the
* interface; the caller must flush routes and addresses explicitly.
*/
......
......@@ -362,6 +362,9 @@ gboolean nm_device_owns_iface (NMDevice *device, const char *iface);
NMConnection *nm_device_new_default_connection (NMDevice *self);
const NMPlatformIP4Route *nm_device_get_ip4_default_route (NMDevice *self);
const NMPlatformIP6Route *nm_device_get_ip6_default_route (NMDevice *self);
G_END_DECLS
/* For testing only */
......
This diff is collapsed.
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* NetworkManager -- Network link manager
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Copyright (C) 2014 Red Hat, Inc.
*/
#include <glib-object.h>
#include "nm-connection.h"
#include "nm-types.h"
#ifndef __NETWORKMANAGER_DEFAULT_ROUTE_MANAGER_H__
#define __NETWORKMANAGER_DEFAULT_ROUTE_MANAGER_H__
#define NM_TYPE_DEFAULT_ROUTE_MANAGER (nm_default_route_manager_get_type ())
#define NM_DEFAULT_ROUTE_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NM_TYPE_DEFAULT_ROUTE_MANAGER, NMDefaultRouteManager))
#define NM_DEFAULT_ROUTE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), NM_TYPE_DEFAULT_ROUTE_MANAGER, NMDefaultRouteManagerClass))
#define NM_IS_DEFAULT_ROUTE_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NM_TYPE_DEFAULT_ROUTE_MANAGER))
#define NM_IS_DEFAULT_ROUTE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), NM_TYPE_DEFAULT_ROUTE_MANAGER))
#define NM_DEFAULT_ROUTE_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NM_TYPE_DEFAULT_ROUTE_MANAGER, NMDefaultRouteManagerClass))
struct _NMDefaultRouteManager {
GObject parent;
};
typedef struct {
GObjectClass parent;
} NMDefaultRouteManagerClass;
GType nm_default_route_manager_get_type (void);
NMDefaultRouteManager *nm_default_route_manager_get (void);
void nm_default_route_manager_ip4_update_default_route (NMDefaultRouteManager *manager, gpointer source);
void nm_default_route_manager_ip6_update_default_route (NMDefaultRouteManager *manager, gpointer source);
void nm_default_route_manager_ip4_remove_default_route (NMDefaultRouteManager *manager, gpointer source);
void nm_default_route_manager_ip6_remove_default_route (NMDefaultRouteManager *manager, gpointer source);
gint64 nm_default_route_manager_ip4_get_effective_metric (NMDefaultRouteManager *manager, NMDevice *device);
gint64 nm_default_route_manager_ip6_get_effective_metric (NMDefaultRouteManager *manager, NMDevice *device);
gboolean nm_default_route_manager_ip4_connection_has_default_route (NMDefaultRouteManager *manager, NMConnection *connection);
gboolean nm_default_route_manager_ip6_connection_has_default_route (NMDefaultRouteManager *manager, NMConnection *connection);
#endif /* NM_DEFAULT_ROUTE_MANAGER_H */
......@@ -1844,8 +1844,14 @@ get_property (GObject *object, guint prop_id,
for (i = 0; i < nroutes; i++) {
const NMPlatformIP4Route *route = nm_ip4_config_get_route (config, i);
GArray *array = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 4);
GArray *array;
/* legacy versions of nm_ip4_route_set_prefix() in libnm-util assert that the
* plen is positive. Skip the default routes not to break older clients. */
if (NM_PLATFORM_IP_ROUTE_IS_DEFAULT (route))
continue;
array = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 4);
g_array_append_val (array, route->network);
g_array_append_val (array, route->plen);
g_array_append_val (array, route->gateway);
......
......@@ -1743,12 +1743,18 @@ get_property (GObject *object, guint prop_id,
int i;
for (i = 0; i < nroutes; i++) {
GValueArray *array;
const NMPlatformIP6Route *route = nm_ip6_config_get_route (config, i);
GValueArray *array = g_value_array_new (4);
GByteArray *ba;
GValue element = G_VALUE_INIT;
/* legacy versions of nm_ip6_route_set_prefix() in libnm-util assert that the
* plen is positive. Skip the default routes not to break older clients. */
if (NM_PLATFORM_IP_ROUTE_IS_DEFAULT (route))
continue;
array = g_value_array_new (4);
g_value_init (&element, DBUS_TYPE_G_UCHAR_ARRAY);
ba = g_byte_array_new ();
g_byte_array_append (ba, (guint8 *) &route->network, sizeof (route->network));
......
......@@ -32,6 +32,7 @@
#include "nm-activation-request.h"
#include "nm-logging.h"
#include "nm-device.h"
#include "nm-default-route-manager.h"
#include "nm-dbus-manager.h"
#include "nm-setting-ip4-config.h"
#include "nm-setting-connection.h"
......@@ -102,17 +103,12 @@ get_best_ip4_device (NMPolicy *self, gboolean fully_activated)
NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
const GSList *iter;
NMDevice *best = NULL;
int best_prio = G_MAXINT;
guint32 best_prio = G_MAXUINT32;
for (iter = nm_manager_get_devices (priv->manager); iter; iter = g_slist_next (iter)) {
NMDevice *dev = NM_DEVICE (iter->data);
NMDeviceType devtype = nm_device_get_device_type (dev);
NMDeviceState state = nm_device_get_state (dev);
NMActRequest *req;
NMConnection *connection;
NMSettingIPConfig *s_ip4;
int prio;
const char *method = NULL;
guint32 prio;
if ( state <= NM_DEVICE_STATE_DISCONNECTED
|| state >= NM_DEVICE_STATE_DEACTIVATING)
......@@ -121,40 +117,19 @@ get_best_ip4_device (NMPolicy *self, gboolean fully_activated)
if (fully_activated && state < NM_DEVICE_STATE_SECONDARIES)
continue;
req = nm_device_get_act_request (dev);
g_assert (req);
connection = nm_act_request_get_connection (req);
g_assert (connection);
method = nm_utils_get_ip_config_method (connection, NM_TYPE_SETTING_IP4_CONFIG);
/* If IPv4 is disabled or link-local-only, it can't be the default */
if ( !strcmp (method, NM_SETTING_IP4_CONFIG_METHOD_DISABLED)
|| !strcmp (method, NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL))
continue;
/* 'never-default' devices can't ever be the default */
s_ip4 = nm_connection_get_setting_ip4_config (connection);
g_assert (s_ip4);
if (nm_setting_ip_config_get_never_default (s_ip4))
if (!nm_default_route_manager_ip4_connection_has_default_route (nm_default_route_manager_get (),
nm_device_get_connection (dev)))
continue;
if (fully_activated) {
NMIP4Config *ip4_config;
gint64 effective_metric = nm_default_route_manager_ip4_get_effective_metric (nm_default_route_manager_get (), dev);
ip4_config = nm_device_get_ip4_config (dev);
if (!ip4_config)
if (effective_metric == -1)
continue;
prio = (guint32) effective_metric;
} else
prio = nm_device_get_ip6_route_metric (dev);
/* Make sure the device has a gateway */
if (!nm_ip4_config_get_gateway (ip4_config) && (devtype != NM_DEVICE_TYPE_MODEM))
continue;
/* 'never-default' devices can't ever be the default */
if (nm_ip4_config_get_never_default (ip4_config))
continue;
}
prio = nm_device_get_priority (dev);
if ( prio < best_prio
|| (priv->default_device4 == dev && prio == best_prio)
|| !best) {
......@@ -186,17 +161,12 @@ get_best_ip6_device (NMPolicy *self, gboolean fully_activated)
NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
const GSList *iter;
NMDevice *best = NULL;
int best_prio = G_MAXINT;
guint32 best_prio = G_MAXUINT32;
for (iter = nm_manager_get_devices (priv->manager); iter; iter = g_slist_next (iter)) {
NMDevice *dev = NM_DEVICE (iter->data);
NMDeviceType devtype = nm_device_get_device_type (dev);
NMDeviceState state = nm_device_get_state (dev);
NMActRequest *req;
NMConnection *connection;
NMSettingIPConfig *s_ip6;
int prio;
const char *method = NULL;
guint32 prio;
if ( state <= NM_DEVICE_STATE_DISCONNECTED
|| state >= NM_DEVICE_STATE_DEACTIVATING)
......@@ -205,36 +175,20 @@ get_best_ip6_device (NMPolicy *self, gboolean fully_activated)
if (fully_activated && state < NM_DEVICE_STATE_SECONDARIES)
continue;
req = nm_device_get_act_request (dev);
g_assert (req);
connection = nm_act_request_get_connection (req);
g_assert (connection);
method = nm_utils_get_ip_config_method (connection, NM_TYPE_SETTING_IP6_CONFIG);
if ( !strcmp (method, NM_SETTING_IP6_CONFIG_METHOD_IGNORE)
|| !strcmp (method, NM_SETTING_IP6_CONFIG_METHOD_LINK_LOCAL))
continue;
s_ip6 = nm_connection_get_setting_ip6_config (connection);
g_assert (s_ip6);
if (nm_setting_ip_config_get_never_default (s_ip6))
if (!nm_default_route_manager_ip6_connection_has_default_route (nm_default_route_manager_get (),
nm_device_get_connection (dev)))
continue;
if (fully_activated) {
NMIP6Config *ip6_config;
ip6_config = nm_device_get_ip6_config (dev);
if (!ip6_config)
continue;
gint64 effective_metric = nm_default_route_manager_ip6_get_effective_metric (nm_default_route_manager_get (), dev);
if (!nm_ip6_config_get_gateway (ip6_config) && (devtype != NM_DEVICE_TYPE_MODEM))
if (effective_metric == -1)
continue;
prio = (guint32) effective_metric;
} else
prio = nm_device_get_ip6_route_metric (dev);
prio = nm_utils_ip6_route_metric_normalize (prio);
if (nm_ip6_config_get_never_default (ip6_config))
continue;
}
prio = nm_device_get_priority (dev);
if ( prio < best_prio
|| (priv->default_device6 == dev && prio == best_prio)
|| !best) {
......@@ -668,6 +622,7 @@ update_ip4_routing (NMPolicy *policy, gboolean force_update)
if (vpn) {
in_addr_t int_gw = nm_vpn_connection_get_ip4_internal_gateway (vpn);
int mss = nm_ip4_config_get_mss (ip4_config);
guint32 route_metric = nm_vpn_connection_get_ip4_route_metric (vpn);
/* If no VPN interface, use the parent interface */
if (ip_ifindex <= 0)
......@@ -675,39 +630,22 @@ update_ip4_routing (NMPolicy *policy, gboolean force_update)
if (!nm_platform_ip4_route_add (ip_ifindex, NM_IP_CONFIG_SOURCE_VPN,
0, 0, int_gw,
NM_PLATFORM_ROUTE_METRIC_DEFAULT, mss)) {
route_metric, mss)) {
if (int_gw) {
(void) nm_platform_ip4_route_add (ip_ifindex, NM_IP_CONFIG_SOURCE_VPN,
int_gw, 32, 0,
NM_PLATFORM_ROUTE_METRIC_DEFAULT, mss);
route_metric, mss);
if (!nm_platform_ip4_route_add (ip_ifindex, NM_IP_CONFIG_SOURCE_VPN,
0, 0, int_gw,
NM_PLATFORM_ROUTE_METRIC_DEFAULT, mss))
route_metric, mss))
nm_log_err (LOGD_IP4 | LOGD_VPN, "Failed to set IPv4 default route via VPN.");
} else
nm_log_err (LOGD_IP4 | LOGD_VPN, "Failed to set IPv4 default route via VPN.");
}
default_device = nm_active_connection_get_device (NM_ACTIVE_CONNECTION (vpn));
} else {
int mss = nm_ip4_config_get_mss (ip4_config);
g_assert (ip_iface);
if (!nm_platform_ip4_route_add (ip_ifindex, NM_IP_CONFIG_SOURCE_USER,
0, 0, gw_addr,
NM_PLATFORM_ROUTE_METRIC_DEFAULT, mss)) {
(void) nm_platform_ip4_route_add (ip_ifindex, NM_IP_CONFIG_SOURCE_USER,
gw_addr, 32, 0,
NM_PLATFORM_ROUTE_METRIC_DEFAULT, mss);
if (!nm_platform_ip4_route_add (ip_ifindex, NM_IP_CONFIG_SOURCE_USER,
0, 0, gw_addr,
NM_PLATFORM_ROUTE_METRIC_DEFAULT, mss)) {
nm_log_err (LOGD_IP4, "Failed to set default route.");
}
}
} else
default_device = best;
}
update_default_ac (policy, best_ac, nm_active_connection_set_default);
......@@ -875,6 +813,7 @@ update_ip6_routing (NMPolicy *policy, gboolean force_update)
if (vpn) {
const struct in6_addr *int_gw = nm_vpn_connection_get_ip6_internal_gateway (vpn);
int mss = nm_ip6_config_get_mss (ip6_config);
guint32 route_metric = nm_vpn_connection_get_ip6_route_metric (vpn);
if (!int_gw)
int_gw = &in6addr_any;
......@@ -885,37 +824,22 @@ update_ip6_routing (NMPolicy *policy, gboolean force_update)
if (!nm_platform_ip6_route_add (ip_ifindex, NM_IP_CONFIG_SOURCE_VPN,
in6addr_any, 0, *int_gw,
NM_PLATFORM_ROUTE_METRIC_DEFAULT, mss)) {
route_metric, mss)) {
if (!IN6_IS_ADDR_UNSPECIFIED (int_gw)) {
(void) nm_platform_ip6_route_add (ip_ifindex, NM_IP_CONFIG_SOURCE_VPN,
*int_gw, 128, in6addr_any,
NM_PLATFORM_ROUTE_METRIC_DEFAULT, mss);
route_metric, mss);
if (!nm_platform_ip6_route_add (ip_ifindex, NM_IP_CONFIG_SOURCE_VPN,
in6addr_any, 0, *int_gw,
NM_PLATFORM_ROUTE_METRIC_DEFAULT, mss))
route_metric, mss))
nm_log_err (LOGD_IP6 | LOGD_VPN, "Failed to set IPv6 default route via VPN.");
} else
nm_log_err (LOGD_IP6 | LOGD_VPN, "Failed to set IPv6 default route via VPN.");
}
default_device6 = nm_active_connection_get_device (NM_ACTIVE_CONNECTION (vpn));
} else {
int mss = nm_ip6_config_get_mss (ip6_config);
if (!nm_platform_ip6_route_add (ip_ifindex, NM_IP_CONFIG_SOURCE_USER,
in6addr_any, 0, *gw_addr,
NM_PLATFORM_ROUTE_METRIC_DEFAULT, mss)) {
(void) nm_platform_ip6_route_add (ip_ifindex, NM_IP_CONFIG_SOURCE_USER,
*gw_addr, 128, in6addr_any,
NM_PLATFORM_ROUTE_METRIC_DEFAULT, mss);
if (!nm_platform_ip6_route_add (ip_ifindex, NM_IP_CONFIG_SOURCE_USER,
in6addr_any, 0, *gw_addr,
NM_PLATFORM_ROUTE_METRIC_DEFAULT, mss))
nm_log_err (LOGD_IP6, "Failed to set default route.");
}
} else
default_device6 = best;
}
update_default_ac (policy, best_ac, nm_active_connection_set_default6);
......
......@@ -29,6 +29,7 @@ typedef struct _NMAuthSubject NMAuthSubject;
typedef struct _NMConnectionProvider NMConnectionProvider;
typedef struct _NMConnectivity NMConnectivity;
typedef struct _NMDBusManager NMDBusManager;
typedef struct _NMDefaultRouteManager NMDefaultRouteManager;
typedef struct _NMDevice NMDevice;
typedef struct _NMDhcp4Config NMDhcp4Config;
typedef struct _NMDhcp6Config NMDhcp6Config;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment