diff options
Diffstat (limited to 'src/core/ndisc')
| -rw-r--r-- | src/core/ndisc/nm-fake-ndisc.c | 415 | ||||
| -rw-r--r-- | src/core/ndisc/nm-fake-ndisc.h | 64 | ||||
| -rw-r--r-- | src/core/ndisc/nm-lndp-ndisc.c | 826 | ||||
| -rw-r--r-- | src/core/ndisc/nm-lndp-ndisc.h | 46 | ||||
| -rw-r--r-- | src/core/ndisc/nm-ndisc-private.h | 68 | ||||
| -rw-r--r-- | src/core/ndisc/nm-ndisc.c | 1830 | ||||
| -rw-r--r-- | src/core/ndisc/nm-ndisc.h | 278 | ||||
| -rw-r--r-- | src/core/ndisc/tests/meson.build | 26 | ||||
| -rw-r--r-- | src/core/ndisc/tests/test-ndisc-fake.c | 657 | ||||
| -rw-r--r-- | src/core/ndisc/tests/test-ndisc-linux.c | 85 |
10 files changed, 4295 insertions, 0 deletions
diff --git a/src/core/ndisc/nm-fake-ndisc.c b/src/core/ndisc/nm-fake-ndisc.c new file mode 100644 index 00000000..ffe07ab6 --- /dev/null +++ b/src/core/ndisc/nm-fake-ndisc.c @@ -0,0 +1,415 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2013 Red Hat, Inc. + */ + +#include "src/core/nm-default-daemon.h" + +#include "nm-fake-ndisc.h" + +#include <arpa/inet.h> + +#include "nm-ndisc-private.h" + +#define _NMLOG_PREFIX_NAME "ndisc-fake" + +/*****************************************************************************/ + +typedef struct { + guint id; + guint when; + + NMNDiscDHCPLevel dhcp_level; + GArray * gateways; + GArray * prefixes; + GArray * dns_servers; + GArray * dns_domains; + int hop_limit; + guint32 mtu; +} FakeRa; + +typedef struct { + struct in6_addr network; + struct in6_addr gateway; + gint64 expiry_msec; + gint64 expiry_preferred_msec; + int plen; + NMIcmpv6RouterPref preference; +} FakePrefix; + +/*****************************************************************************/ + +enum { + RS_SENT, + LAST_SIGNAL, +}; +static guint signals[LAST_SIGNAL] = {0}; + +typedef struct { + guint receive_ra_id; + GSList *ras; +} NMFakeNDiscPrivate; + +struct _NMFakeRNDisc { + NMNDisc parent; + NMFakeNDiscPrivate _priv; +}; + +struct _NMFakeRNDiscClass { + NMNDiscClass parent; +}; + +G_DEFINE_TYPE(NMFakeNDisc, nm_fake_ndisc, NM_TYPE_NDISC) + +#define NM_FAKE_NDISC_GET_PRIVATE(self) \ + _NM_GET_PRIVATE(self, NMFakeNDisc, NM_IS_FAKE_NDISC, NMNDisc) + +/*****************************************************************************/ + +static void +fake_ra_free(gpointer data) +{ + FakeRa *ra = data; + + g_array_free(ra->gateways, TRUE); + g_array_free(ra->prefixes, TRUE); + g_array_free(ra->dns_servers, TRUE); + g_array_free(ra->dns_domains, TRUE); + g_free(ra); +} + +static void +ra_dns_domain_free(gpointer data) +{ + g_free(((NMNDiscDNSDomain *) (data))->domain); +} + +static FakeRa * +find_ra(GSList *ras, guint id) +{ + GSList *iter; + + for (iter = ras; iter; iter = iter->next) { + if (((FakeRa *) iter->data)->id == id) + return iter->data; + } + return NULL; +} + +guint +nm_fake_ndisc_add_ra(NMFakeNDisc * self, + guint seconds_after_previous, + NMNDiscDHCPLevel dhcp_level, + int hop_limit, + guint32 mtu) +{ + NMFakeNDiscPrivate *priv = NM_FAKE_NDISC_GET_PRIVATE(self); + static guint counter = 1; + FakeRa * ra; + + ra = g_malloc0(sizeof(*ra)); + ra->id = counter++; + ra->when = seconds_after_previous; + ra->dhcp_level = dhcp_level; + ra->hop_limit = hop_limit; + ra->mtu = mtu; + ra->gateways = g_array_new(FALSE, FALSE, sizeof(NMNDiscGateway)); + ra->prefixes = g_array_new(FALSE, FALSE, sizeof(FakePrefix)); + ra->dns_servers = g_array_new(FALSE, FALSE, sizeof(NMNDiscDNSServer)); + ra->dns_domains = g_array_new(FALSE, FALSE, sizeof(NMNDiscDNSDomain)); + g_array_set_clear_func(ra->dns_domains, ra_dns_domain_free); + + priv->ras = g_slist_append(priv->ras, ra); + return ra->id; +} + +void +nm_fake_ndisc_add_gateway(NMFakeNDisc * self, + guint ra_id, + const char * addr, + gint64 expiry_msec, + NMIcmpv6RouterPref preference) +{ + NMFakeNDiscPrivate *priv = NM_FAKE_NDISC_GET_PRIVATE(self); + FakeRa * ra = find_ra(priv->ras, ra_id); + NMNDiscGateway * gw; + + g_assert(ra); + + gw = nm_g_array_append_new(ra->gateways, NMNDiscGateway); + if (inet_pton(AF_INET6, addr, &gw->address) != 1) + g_assert_not_reached(); + gw->expiry_msec = expiry_msec; + gw->preference = preference; +} + +void +nm_fake_ndisc_add_prefix(NMFakeNDisc * self, + guint ra_id, + const char * network, + guint plen, + const char * gateway, + gint64 expiry_msec, + gint64 expiry_preferred_msec, + NMIcmpv6RouterPref preference) +{ + NMFakeNDiscPrivate *priv = NM_FAKE_NDISC_GET_PRIVATE(self); + FakeRa * ra = find_ra(priv->ras, ra_id); + FakePrefix * prefix; + + g_assert(ra); + + prefix = nm_g_array_append_new(ra->prefixes, FakePrefix); + *prefix = (FakePrefix){ + .plen = plen, + .expiry_msec = expiry_msec, + .expiry_preferred_msec = expiry_preferred_msec, + .preference = preference, + }; + if (inet_pton(AF_INET6, network, &prefix->network) != 1) + g_assert_not_reached(); + if (inet_pton(AF_INET6, gateway, &prefix->gateway) != 1) + g_assert_not_reached(); +} + +void +nm_fake_ndisc_add_dns_server(NMFakeNDisc *self, + guint ra_id, + const char * address, + gint64 expiry_msec) +{ + NMFakeNDiscPrivate *priv = NM_FAKE_NDISC_GET_PRIVATE(self); + FakeRa * ra = find_ra(priv->ras, ra_id); + NMNDiscDNSServer * dns; + + g_assert(ra); + + dns = nm_g_array_append_new(ra->dns_servers, NMNDiscDNSServer); + + dns->expiry_msec = expiry_msec; + if (inet_pton(AF_INET6, address, &dns->address) != 1) + g_assert_not_reached(); +} + +void +nm_fake_ndisc_add_dns_domain(NMFakeNDisc *self, guint ra_id, const char *domain, gint64 expiry_msec) +{ + NMFakeNDiscPrivate *priv = NM_FAKE_NDISC_GET_PRIVATE(self); + FakeRa * ra = find_ra(priv->ras, ra_id); + NMNDiscDNSDomain * dns; + + g_assert(ra); + + dns = nm_g_array_append_new(ra->dns_domains, NMNDiscDNSDomain); + + dns->domain = g_strdup(domain); + dns->expiry_msec = expiry_msec; +} + +gboolean +nm_fake_ndisc_done(NMFakeNDisc *self) +{ + return !NM_FAKE_NDISC_GET_PRIVATE(self)->ras; +} + +/*****************************************************************************/ + +static gboolean +send_rs(NMNDisc *ndisc, GError **error) +{ + _LOGT("send_rs()"); + g_signal_emit(ndisc, signals[RS_SENT], 0); + return TRUE; +} + +static gboolean +receive_ra(gpointer user_data) +{ + NMFakeNDisc * self = user_data; + NMFakeNDiscPrivate * priv = NM_FAKE_NDISC_GET_PRIVATE(self); + NMNDisc * ndisc = NM_NDISC(self); + NMNDiscDataInternal *rdata = ndisc->rdata; + FakeRa * ra = priv->ras->data; + NMNDiscConfigMap changed = 0; + const gint64 now_msec = nm_utils_get_monotonic_timestamp_msec(); + guint i; + NMNDiscDHCPLevel dhcp_level; + + priv->receive_ra_id = 0; + + /* preserve the "most managed" level on updates. */ + dhcp_level = MAX(rdata->public.dhcp_level, ra->dhcp_level); + + if (rdata->public.dhcp_level != dhcp_level) { + rdata->public.dhcp_level = dhcp_level; + changed |= NM_NDISC_CONFIG_DHCP_LEVEL; + } + + for (i = 0; i < ra->gateways->len; i++) { + const NMNDiscGateway *item = &g_array_index(ra->gateways, NMNDiscGateway, i); + + if (nm_ndisc_add_gateway(ndisc, item, now_msec)) + changed |= NM_NDISC_CONFIG_GATEWAYS; + } + + for (i = 0; i < ra->prefixes->len; i++) { + FakePrefix * item = &g_array_index(ra->prefixes, FakePrefix, i); + const NMNDiscRoute route = { + .network = item->network, + .plen = item->plen, + .gateway = item->gateway, + .expiry_msec = item->expiry_msec, + .preference = item->preference, + }; + + g_assert(route.plen > 0 && route.plen <= 128); + + if (nm_ndisc_add_route(ndisc, &route, now_msec)) + changed |= NM_NDISC_CONFIG_ROUTES; + + if (item->plen == 64) { + const NMNDiscAddress address = { + .address = item->network, + .expiry_msec = item->expiry_msec, + .expiry_preferred_msec = item->expiry_preferred_msec, + .dad_counter = 0, + }; + + if (nm_ndisc_complete_and_add_address(ndisc, &address, now_msec)) + changed |= NM_NDISC_CONFIG_ADDRESSES; + } + } + + for (i = 0; i < ra->dns_servers->len; i++) { + const NMNDiscDNSServer *item = &g_array_index(ra->dns_servers, NMNDiscDNSServer, i); + + if (nm_ndisc_add_dns_server(ndisc, item, now_msec)) + changed |= NM_NDISC_CONFIG_DNS_SERVERS; + } + + for (i = 0; i < ra->dns_domains->len; i++) { + const NMNDiscDNSDomain *item = &g_array_index(ra->dns_domains, NMNDiscDNSDomain, i); + + if (nm_ndisc_add_dns_domain(ndisc, item, now_msec)) + changed |= NM_NDISC_CONFIG_DNS_DOMAINS; + } + + if (rdata->public.mtu != ra->mtu) { + rdata->public.mtu = ra->mtu; + changed |= NM_NDISC_CONFIG_MTU; + } + + if (rdata->public.hop_limit != ra->hop_limit) { + rdata->public.hop_limit = ra->hop_limit; + changed |= NM_NDISC_CONFIG_HOP_LIMIT; + } + + priv->ras = g_slist_remove(priv->ras, priv->ras->data); + fake_ra_free(ra); + + nm_ndisc_ra_received(NM_NDISC(self), now_msec, changed); + + /* Schedule next RA */ + if (priv->ras) { + ra = priv->ras->data; + priv->receive_ra_id = g_timeout_add_seconds(ra->when, receive_ra, self); + } + + return G_SOURCE_REMOVE; +} + +static void +start(NMNDisc *ndisc) +{ + NMFakeNDiscPrivate *priv = NM_FAKE_NDISC_GET_PRIVATE(ndisc); + FakeRa * ra; + + /* Queue up the first fake RA */ + g_assert(priv->ras); + ra = priv->ras->data; + + g_assert(!priv->receive_ra_id); + priv->receive_ra_id = g_timeout_add_seconds(ra->when, receive_ra, ndisc); +} + +static void +stop(NMNDisc *ndisc) +{ + NMFakeNDiscPrivate *priv = NM_FAKE_NDISC_GET_PRIVATE(ndisc); + + nm_clear_g_source(&priv->receive_ra_id); +} + +void +nm_fake_ndisc_emit_new_ras(NMFakeNDisc *self) +{ + if (!NM_FAKE_NDISC_GET_PRIVATE(self)->receive_ra_id) + start(NM_NDISC(self)); +} + +/*****************************************************************************/ + +static void +nm_fake_ndisc_init(NMFakeNDisc *fake_ndisc) +{} + +NMNDisc * +nm_fake_ndisc_new(int ifindex, const char *ifname) +{ + return g_object_new(NM_TYPE_FAKE_NDISC, + NM_NDISC_IFINDEX, + ifindex, + NM_NDISC_IFNAME, + ifname, + NM_NDISC_NODE_TYPE, + (int) NM_NDISC_NODE_TYPE_HOST, + NM_NDISC_STABLE_TYPE, + (int) NM_UTILS_STABLE_TYPE_UUID, + NM_NDISC_NETWORK_ID, + "fake", + NM_NDISC_MAX_ADDRESSES, + NM_NDISC_MAX_ADDRESSES_DEFAULT, + NM_NDISC_ROUTER_SOLICITATIONS, + NM_NDISC_ROUTER_SOLICITATIONS_DEFAULT, + NM_NDISC_ROUTER_SOLICITATION_INTERVAL, + NM_NDISC_RFC4861_RTR_SOLICITATION_INTERVAL, + NM_NDISC_RA_TIMEOUT, + 30u, + NULL); +} + +static void +dispose(GObject *object) +{ + NMFakeNDiscPrivate *priv = NM_FAKE_NDISC_GET_PRIVATE(object); + + nm_clear_g_source(&priv->receive_ra_id); + + g_slist_free_full(priv->ras, fake_ra_free); + priv->ras = NULL; + + G_OBJECT_CLASS(nm_fake_ndisc_parent_class)->dispose(object); +} + +static void +nm_fake_ndisc_class_init(NMFakeNDiscClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS(klass); + NMNDiscClass *ndisc_class = NM_NDISC_CLASS(klass); + + object_class->dispose = dispose; + + ndisc_class->start = start; + ndisc_class->stop = stop; + ndisc_class->send_rs = send_rs; + + signals[RS_SENT] = g_signal_new(NM_FAKE_NDISC_RS_SENT, + G_OBJECT_CLASS_TYPE(klass), + G_SIGNAL_RUN_FIRST, + 0, + NULL, + NULL, + NULL, + G_TYPE_NONE, + 0); +} diff --git a/src/core/ndisc/nm-fake-ndisc.h b/src/core/ndisc/nm-fake-ndisc.h new file mode 100644 index 00000000..677f15fc --- /dev/null +++ b/src/core/ndisc/nm-fake-ndisc.h @@ -0,0 +1,64 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2013 Red Hat, Inc. + */ + +#ifndef __NETWORKMANAGER_FAKE_NDISC_H__ +#define __NETWORKMANAGER_FAKE_NDISC_H__ + +#include "nm-ndisc.h" + +#define NM_TYPE_FAKE_NDISC (nm_fake_ndisc_get_type()) +#define NM_FAKE_NDISC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_FAKE_NDISC, NMFakeNDisc)) +#define NM_FAKE_NDISC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_FAKE_NDISC, NMFakeNDiscClass)) +#define NM_IS_FAKE_NDISC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_FAKE_NDISC)) +#define NM_IS_FAKE_NDISC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_FAKE_NDISC)) +#define NM_FAKE_NDISC_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_FAKE_NDISC, NMFakeNDiscClass)) + +#define NM_FAKE_NDISC_RS_SENT "rs-sent" + +typedef struct _NMFakeRNDisc NMFakeNDisc; +typedef struct _NMFakeRNDiscClass NMFakeNDiscClass; + +GType nm_fake_ndisc_get_type(void); + +NMNDisc *nm_fake_ndisc_new(int ifindex, const char *ifname); + +guint nm_fake_ndisc_add_ra(NMFakeNDisc * self, + guint seconds, + NMNDiscDHCPLevel dhcp_level, + int hop_limit, + guint32 mtu); + +void nm_fake_ndisc_add_gateway(NMFakeNDisc * self, + guint ra_id, + const char * addr, + gint64 expiry_msec, + NMIcmpv6RouterPref preference); + +void nm_fake_ndisc_add_prefix(NMFakeNDisc * self, + guint ra_id, + const char * network, + guint plen, + const char * gateway, + gint64 expiry_msec, + gint64 expiry_preferred_msec, + NMIcmpv6RouterPref preference); + +void nm_fake_ndisc_add_dns_server(NMFakeNDisc *self, + guint ra_id, + const char * address, + gint64 expiry_msec); + +void nm_fake_ndisc_add_dns_domain(NMFakeNDisc *self, + guint ra_id, + const char * domain, + gint64 expiry_msec); + +void nm_fake_ndisc_emit_new_ras(NMFakeNDisc *self); + +gboolean nm_fake_ndisc_done(NMFakeNDisc *self); + +#endif /* __NETWORKMANAGER_FAKE_NDISC_H__ */ diff --git a/src/core/ndisc/nm-lndp-ndisc.c b/src/core/ndisc/nm-lndp-ndisc.c new file mode 100644 index 00000000..f773478f --- /dev/null +++ b/src/core/ndisc/nm-lndp-ndisc.c @@ -0,0 +1,826 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2013 Red Hat, Inc. + */ + +#include "src/core/nm-default-daemon.h" + +#include "nm-lndp-ndisc.h" + +#include <arpa/inet.h> +#include <netinet/icmp6.h> +/* stdarg.h included because of a bug in ndp.h */ +#include <stdarg.h> +#include <ndp.h> + +#include "nm-glib-aux/nm-str-buf.h" +#include "systemd/nm-sd-utils-shared.h" +#include "nm-ndisc-private.h" +#include "NetworkManagerUtils.h" +#include "platform/nm-platform.h" +#include "nm-platform/nmp-netns.h" + +#define _NMLOG_PREFIX_NAME "ndisc-lndp" + +/*****************************************************************************/ + +typedef struct { + struct ndp *ndp; + GSource * event_source; +} NMLndpNDiscPrivate; + +/*****************************************************************************/ + +struct _NMLndpNDisc { + NMNDisc parent; + NMLndpNDiscPrivate _priv; +}; + +struct _NMLndpNDiscClass { + NMNDiscClass parent; +}; + +/*****************************************************************************/ + +G_DEFINE_TYPE(NMLndpNDisc, nm_lndp_ndisc, NM_TYPE_NDISC) + +#define NM_LNDP_NDISC_GET_PRIVATE(self) \ + _NM_GET_PRIVATE(self, NMLndpNDisc, NM_IS_LNDP_NDISC, NMNDisc) + +/*****************************************************************************/ + +static gboolean +send_rs(NMNDisc *ndisc, GError **error) +{ + NMLndpNDiscPrivate *priv = NM_LNDP_NDISC_GET_PRIVATE(ndisc); + struct ndp_msg * msg; + int errsv; + + errsv = ndp_msg_new(&msg, NDP_MSG_RS); + if (errsv) { + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + "cannot create router solicitation"); + return FALSE; + } + ndp_msg_ifindex_set(msg, nm_ndisc_get_ifindex(ndisc)); + + errsv = ndp_msg_send(priv->ndp, msg); + ndp_msg_destroy(msg); + if (errsv) { + errsv = nm_errno_native(errsv); + g_set_error(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + "%s (%d)", + nm_strerror_native(errsv), + errsv); + return FALSE; + } + + return TRUE; +} + +static NMIcmpv6RouterPref +_route_preference_coerce(enum ndp_route_preference pref) +{ +#define _ASSERT_ENUM(v1, v2) \ + G_STMT_START \ + { \ + G_STATIC_ASSERT((NMIcmpv6RouterPref)(v1) == (v2)); \ + G_STATIC_ASSERT((enum ndp_route_preference)(v2) == (v1)); \ + G_STATIC_ASSERT((gint64)(v1) == (v2)); \ + G_STATIC_ASSERT((gint64)(v2) == (v1)); \ + } \ + G_STMT_END + + switch (pref) { + case NDP_ROUTE_PREF_LOW: + case NDP_ROUTE_PREF_MEDIUM: + case NDP_ROUTE_PREF_HIGH: + _ASSERT_ENUM(NDP_ROUTE_PREF_LOW, NM_ICMPV6_ROUTER_PREF_LOW); + _ASSERT_ENUM(NDP_ROUTE_PREF_MEDIUM, NM_ICMPV6_ROUTER_PREF_MEDIUM); + _ASSERT_ENUM(NDP_ROUTE_PREF_HIGH, NM_ICMPV6_ROUTER_PREF_HIGH); + return (NMIcmpv6RouterPref) pref; + } + + /* unexpected value must be treated as MEDIUM (RFC 4191). */ + return NM_ICMPV6_ROUTER_PREF_MEDIUM; +} + +static int +receive_ra(struct ndp *ndp, struct ndp_msg *msg, gpointer user_data) +{ + NMNDisc * ndisc = (NMNDisc *) user_data; + NMNDiscDataInternal *rdata = ndisc->rdata; + NMNDiscConfigMap changed = 0; + struct ndp_msgra * msgra = ndp_msgra(msg); + struct in6_addr gateway_addr; + const gint64 now_msec = nm_utils_get_monotonic_timestamp_msec(); + int offset; + int hop_limit; + guint32 val; + + /* Router discovery is subject to the following RFC documents: + * + * http://tools.ietf.org/html/rfc4861 + * http://tools.ietf.org/html/rfc4862 + * + * The biggest difference from good old DHCP is that all configuration + * items have their own lifetimes and they are merged from various + * sources. Router discovery is *not* contract-based, so there is *no* + * single time when the configuration is finished and updates can + * come at any time. + */ + _LOGD("received router advertisement at timestamp %" G_GINT64_FORMAT ".%03d seconds", + now_msec / 1000, + (int) (now_msec % 1000)); + + gateway_addr = *ndp_msg_addrto(msg); + if (IN6_IS_ADDR_UNSPECIFIED(&gateway_addr)) + g_return_val_if_reached(0); + + /* DHCP level: + * + * The problem with DHCP level is what to do if subsequent + * router advertisements carry different flags. Currently, we just + * rewrite the flag with every inbound RA. + */ + { + NMNDiscDHCPLevel dhcp_level; + + if (ndp_msgra_flag_managed(msgra)) + dhcp_level = NM_NDISC_DHCP_LEVEL_MANAGED; + else if (ndp_msgra_flag_other(msgra)) + dhcp_level = NM_NDISC_DHCP_LEVEL_OTHERCONF; + else + dhcp_level = NM_NDISC_DHCP_LEVEL_NONE; + + /* when receiving multiple RA (possibly from different routers), + * let's keep the "most managed" level. */ + G_STATIC_ASSERT_EXPR(NM_NDISC_DHCP_LEVEL_MANAGED > NM_NDISC_DHCP_LEVEL_OTHERCONF); + G_STATIC_ASSERT_EXPR(NM_NDISC_DHCP_LEVEL_OTHERCONF > NM_NDISC_DHCP_LEVEL_NONE); + dhcp_level = MAX(dhcp_level, rdata->public.dhcp_level); + + if (dhcp_level != rdata->public.dhcp_level) { + rdata->public.dhcp_level = dhcp_level; + changed |= NM_NDISC_CONFIG_DHCP_LEVEL; + } + } + + /* Default gateway: + * + * Subsequent router advertisements can represent new default gateways + * on the network. We should present all of them in router preference + * order. + */ + { + const NMNDiscGateway gateway = { + .address = gateway_addr, + .expiry_msec = _nm_ndisc_lifetime_to_expiry(now_msec, ndp_msgra_router_lifetime(msgra)), + .preference = _route_preference_coerce(ndp_msgra_route_preference(msgra)), + }; + + /* https://tools.ietf.org/html/rfc2461#section-4.2 + * > A Lifetime of 0 indicates that the router is not a + * > default router and SHOULD NOT appear on the default + * > router list. + * We handle that by tracking a gateway that expires right now. */ + + if (nm_ndisc_add_gateway(ndisc, &gateway, now_msec)) + changed |= NM_NDISC_CONFIG_GATEWAYS; + } + + /* Addresses & Routes */ + ndp_msg_opt_for_each_offset (offset, msg, NDP_MSG_OPT_PREFIX) { + guint8 r_plen; + struct in6_addr r_network; + + /* Device route */ + + r_plen = ndp_msg_opt_prefix_len(msg, offset); + if (r_plen == 0 || r_plen > 128) + continue; + nm_utils_ip6_address_clear_host_address(&r_network, + ndp_msg_opt_prefix(msg, offset), + r_plen); + + if (IN6_IS_ADDR_UNSPECIFIED(&r_network) || IN6_IS_ADDR_LINKLOCAL(&r_network)) + continue; + + if (ndp_msg_opt_prefix_flag_on_link(msg, offset)) { + const NMNDiscRoute route = { + .network = r_network, + .plen = r_plen, + .expiry_msec = + _nm_ndisc_lifetime_to_expiry(now_msec, + ndp_msg_opt_prefix_valid_time(msg, offset)), + }; + + if (nm_ndisc_add_route(ndisc, &route, now_msec)) + changed |= NM_NDISC_CONFIG_ROUTES; + } + + /* Address */ + if (r_plen == 64 && ndp_msg_opt_prefix_flag_auto_addr_conf(msg, offset)) { + const guint32 valid_time = ndp_msg_opt_prefix_valid_time(msg, offset); + const guint32 preferred_time = + NM_MIN(ndp_msg_opt_prefix_preferred_time(msg, offset), valid_time); + const NMNDiscAddress address = { + .address = r_network, + .expiry_msec = _nm_ndisc_lifetime_to_expiry(now_msec, valid_time), + .expiry_preferred_msec = _nm_ndisc_lifetime_to_expiry(now_msec, preferred_time), + }; + + if (nm_ndisc_complete_and_add_address(ndisc, &address, now_msec)) + changed |= NM_NDISC_CONFIG_ADDRESSES; + } + } + ndp_msg_opt_for_each_offset (offset, msg, NDP_MSG_OPT_ROUTE) { + guint8 plen = ndp_msg_opt_route_prefix_len(msg, offset); + struct in6_addr network; + + if (plen == 0 || plen > 128) + continue; + + nm_utils_ip6_address_clear_host_address(&network, + ndp_msg_opt_route_prefix(msg, offset), + plen); + + { + const NMNDiscRoute route = { + .network = network, + .gateway = gateway_addr, + .plen = plen, + .expiry_msec = + _nm_ndisc_lifetime_to_expiry(now_msec, ndp_msg_opt_route_lifetime(msg, offset)), + .preference = _route_preference_coerce(ndp_msg_opt_route_preference(msg, offset)), + }; + + /* Routers through this particular gateway */ + if (nm_ndisc_add_route(ndisc, &route, now_msec)) + changed |= NM_NDISC_CONFIG_ROUTES; + } + } + + ndp_msg_opt_for_each_offset (offset, msg, NDP_MSG_OPT_RDNSS) { + struct in6_addr *addr; + int addr_index; + + ndp_msg_opt_rdnss_for_each_addr (addr, addr_index, msg, offset) { + const NMNDiscDNSServer dns_server = { + .address = *addr, + .expiry_msec = + _nm_ndisc_lifetime_to_expiry(now_msec, ndp_msg_opt_rdnss_lifetime(msg, offset)), + }; + + if (nm_ndisc_add_dns_server(ndisc, &dns_server, now_msec)) + changed |= NM_NDISC_CONFIG_DNS_SERVERS; + } + } + ndp_msg_opt_for_each_offset (offset, msg, NDP_MSG_OPT_DNSSL) { + char *domain; + int domain_index; + + ndp_msg_opt_dnssl_for_each_domain (domain, domain_index, msg, offset) { + const NMNDiscDNSDomain dns_domain = { + .domain = domain, + .expiry_msec = + _nm_ndisc_lifetime_to_expiry(now_msec, ndp_msg_opt_dnssl_lifetime(msg, offset)), + }; + + if (nm_ndisc_add_dns_domain(ndisc, &dns_domain, now_msec)) + changed |= NM_NDISC_CONFIG_DNS_DOMAINS; + } + } + + hop_limit = ndp_msgra_curhoplimit(msgra); + if (rdata->public.hop_limit != hop_limit) { + rdata->public.hop_limit = hop_limit; + changed |= NM_NDISC_CONFIG_HOP_LIMIT; + } + + val = ndp_msgra_reachable_time(msgra); + if (val && rdata->public.reachable_time_ms != val) { + rdata->public.reachable_time_ms = val; + changed |= NM_NDISC_CONFIG_REACHABLE_TIME; + } + + val = ndp_msgra_retransmit_time(msgra); + if (val && rdata->public.retrans_timer_ms != val) { + rdata->public.retrans_timer_ms = val; + changed |= NM_NDISC_CONFIG_RETRANS_TIMER; + } + + /* MTU */ + ndp_msg_opt_for_each_offset (offset, msg, NDP_MSG_OPT_MTU) { + guint32 mtu = ndp_msg_opt_mtu(msg, offset); + if (mtu >= 1280) { + if (rdata->public.mtu != mtu) { + rdata->public.mtu = mtu; + changed |= NM_NDISC_CONFIG_MTU; + } + } else { + /* All sorts of bad things would happen if we accepted this. + * Kernel would set it, but would flush out all IPv6 addresses away + * from the link, even the link-local, and we wouldn't be able to + * listen for further RAs that could fix the MTU. */ + _LOGW("MTU too small for IPv6 ignored: %d", mtu); + } + } + + nm_ndisc_ra_received(ndisc, now_msec, changed); + return 0; +} + +static void * +_ndp_msg_add_option(struct ndp_msg *msg, gsize len) +{ + gsize payload_len = ndp_msg_payload_len(msg); + void *ret = &((uint8_t *) msg)[payload_len]; + + nm_assert(len <= G_MAXSIZE - payload_len); + len += payload_len; + + if (len > ndp_msg_payload_maxlen(msg)) + return NULL; + + ndp_msg_payload_len_set(msg, len); + nm_assert(len == ndp_msg_payload_len(msg)); + return ret; +} + +/*****************************************************************************/ + +/* "Recursive DNS Server Option" at https://tools.ietf.org/html/rfc8106#section-5.1 */ + +#define NM_ND_OPT_RDNSS 25 + +typedef struct _nm_packed { + struct nd_opt_hdr header; + uint16_t reserved; + uint32_t lifetime; + struct in6_addr addrs[0]; +} NMLndpRdnssOption; + +G_STATIC_ASSERT(sizeof(NMLndpRdnssOption) == 8u); + +/*****************************************************************************/ + +/* "DNS Search List Option" at https://tools.ietf.org/html/rfc8106#section-5.2 */ + +#define NM_ND_OPT_DNSSL 31 + +typedef struct _nm_packed { + struct nd_opt_hdr header; + uint16_t reserved; + uint32_t lifetime; + uint8_t search_list[0]; +} NMLndpDnsslOption; + +G_STATIC_ASSERT(sizeof(NMLndpDnsslOption) == 8u); + +/*****************************************************************************/ + +static gboolean +send_ra(NMNDisc *ndisc, GError **error) +{ + NMLndpNDiscPrivate * priv = NM_LNDP_NDISC_GET_PRIVATE(ndisc); + NMNDiscDataInternal * rdata = ndisc->rdata; + int errsv; + struct in6_addr * addr; + struct ndp_msg * msg; + guint i; + nm_auto_str_buf NMStrBuf sbuf = NM_STR_BUF_INIT(0, FALSE); + + errsv = ndp_msg_new(&msg, NDP_MSG_RA); + if (errsv) { + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + "cannot create a router advertisement"); + return FALSE; + } + + ndp_msg_ifindex_set(msg, nm_ndisc_get_ifindex(ndisc)); + + /* Multicast to all nodes. */ + addr = ndp_msg_addrto(msg); + addr->s6_addr32[0] = htonl(0xff020000); + addr->s6_addr32[1] = 0; + addr->s6_addr32[2] = 0; + addr->s6_addr32[3] = htonl(0x1); + + ndp_msgra_router_lifetime_set(ndp_msgra(msg), NM_NDISC_ROUTER_LIFETIME); + + /* The device let us know about all addresses that the device got + * whose prefixes are suitable for delegating. Let's announce them. */ + for (i = 0; i < rdata->addresses->len; i++) { + const NMNDiscAddress * address = &g_array_index(rdata->addresses, NMNDiscAddress, i); + struct nd_opt_prefix_info *prefix; + + prefix = _ndp_msg_add_option(msg, sizeof(*prefix)); + if (!prefix) { + /* Maybe we could sent separate RAs, but why bother... */ + _LOGW("The RA is too big, had to omit some some prefixes."); + break; + } + + prefix->nd_opt_pi_type = ND_OPT_PREFIX_INFORMATION; + prefix->nd_opt_pi_len = 4; + prefix->nd_opt_pi_prefix_len = 64; + prefix->nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_ONLINK; + prefix->nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_AUTO; + prefix->nd_opt_pi_valid_time = + htonl(_nm_ndisc_lifetime_from_expiry(NM_NDISC_EXPIRY_BASE_TIMESTAMP, + address->expiry_msec, + TRUE)); + prefix->nd_opt_pi_preferred_time = + htonl(_nm_ndisc_lifetime_from_expiry(NM_NDISC_EXPIRY_BASE_TIMESTAMP, + address->expiry_preferred_msec, + TRUE)); + prefix->nd_opt_pi_prefix.s6_addr32[0] = address->address.s6_addr32[0]; + prefix->nd_opt_pi_prefix.s6_addr32[1] = address->address.s6_addr32[1]; + prefix->nd_opt_pi_prefix.s6_addr32[2] = 0; + prefix->nd_opt_pi_prefix.s6_addr32[3] = 0; + } + + if (rdata->dns_servers->len > 0u) { + NMLndpRdnssOption *option; + gsize len = sizeof(*option) + (sizeof(option->addrs[0]) * rdata->dns_servers->len); + + option = _ndp_msg_add_option(msg, len); + if (!option) { + _LOGW("The RA is too big, had to omit DNS information."); + goto dns_servers_done; + } + + option->header.nd_opt_type = NM_ND_OPT_RDNSS; + option->header.nd_opt_len = len / 8; + option->lifetime = htonl(900); + + for (i = 0; i < rdata->dns_servers->len; i++) { + const NMNDiscDNSServer *dns_server = + &g_array_index(rdata->dns_servers, NMNDiscDNSServer, i); + + option->addrs[i] = dns_server->address; + } + } +dns_servers_done: + + if (rdata->dns_domains->len > 0u) { + NMLndpDnsslOption *option; + gsize padding; + gsize len; + + nm_str_buf_reset(&sbuf); + + for (i = 0; i < rdata->dns_domains->len; i++) { + const NMNDiscDNSDomain *dns_domain = + &g_array_index(rdata->dns_domains, NMNDiscDNSDomain, i); + const char *domain = dns_domain->domain; + gsize domain_l; + gsize n_reserved; + int r; + + if (nm_str_is_empty(domain)) { + nm_assert_not_reached(); + continue; + } + + domain_l = strlen(domain); + + nm_str_buf_maybe_expand(&sbuf, domain_l + 2u, FALSE); + n_reserved = sbuf.allocated - sbuf.len; + + r = nm_sd_dns_name_to_wire_format( + domain, + (guint8 *) (&nm_str_buf_get_str_unsafe(&sbuf)[sbuf.len]), + n_reserved, + FALSE); + + if (r < 0 || ((gsize) r) > n_reserved) { + nm_assert(r != -ENOBUFS); + nm_assert(r < 0); + /* we don't expect errors here, unless the domain name is invalid. + * That should have been caught (and rejected) by upper layers, but + * at this point it seems dangerous to assert (as it's hard to review + * that all callers got it correct). So instead silently ignore the error. */ + continue; + } + + nm_str_buf_set_size(&sbuf, sbuf.len + ((gsize) r), TRUE, FALSE); + } + + if (sbuf.len == 0) { + /* no valid domains? */ + goto dns_domains_done; + } + + len = sizeof(*option) + sbuf.len; + padding = len % 8u; + if (padding != 0u) { + padding = 8u - padding; + len += padding; + } + + nm_assert(len % 8u == 0u); + nm_assert(len > 0u); + nm_assert(len / 8u >= 2u); + + if (len / 8u >= 256u || !(option = _ndp_msg_add_option(msg, len))) { + _LOGW("The RA is too big, had to omit DNS search list."); + goto dns_domains_done; + } + + nm_str_buf_append_c_len(&sbuf, '\0', padding); + + option->header.nd_opt_type = NM_ND_OPT_DNSSL; + option->header.nd_opt_len = len / 8u; + option->reserved = 0; + option->lifetime = htonl(900); + memcpy(option->search_list, nm_str_buf_get_str_unsafe(&sbuf), sbuf.len); + } +dns_domains_done: + + errsv = ndp_msg_send(priv->ndp, msg); + + ndp_msg_destroy(msg); + if (errsv) { + errsv = nm_errno_native(errsv); + g_set_error(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + "%s (%d)", + nm_strerror_native(errsv), + errsv); + return FALSE; + } + + return TRUE; +} + +static int +receive_rs(struct ndp *ndp, struct ndp_msg *msg, gpointer user_data) +{ + NMNDisc *ndisc = user_data; + + nm_ndisc_rs_received(ndisc); + return 0; +} + +static gboolean +event_ready(int fd, GIOCondition condition, gpointer user_data) +{ + gs_unref_object NMNDisc *ndisc = g_object_ref(NM_NDISC(user_data)); + nm_auto_pop_netns NMPNetns *netns = NULL; + NMLndpNDiscPrivate * priv = NM_LNDP_NDISC_GET_PRIVATE(ndisc); + + _LOGD("processing libndp events"); + + if (!nm_ndisc_netns_push(ndisc, &netns)) { + /* something is very wrong. Stop handling events. */ + nm_clear_g_source_inst(&priv->event_source); + return G_SOURCE_REMOVE; + } + + ndp_callall_eventfd_handler(priv->ndp); + return G_SOURCE_CONTINUE; +} + +static void +start(NMNDisc *ndisc) +{ + NMLndpNDiscPrivate *priv = NM_LNDP_NDISC_GET_PRIVATE(ndisc); + int fd; + + g_return_if_fail(!priv->event_source); + + fd = ndp_get_eventfd(priv->ndp); + + priv->event_source = + nm_g_unix_fd_source_new(fd, G_IO_IN, G_PRIORITY_DEFAULT, event_ready, ndisc, NULL); + g_source_attach(priv->event_source, NULL); + + /* Flush any pending messages to avoid using obsolete information */ + event_ready(fd, 0, ndisc); + + switch (nm_ndisc_get_node_type(ndisc)) { + case NM_NDISC_NODE_TYPE_HOST: + ndp_msgrcv_handler_register(priv->ndp, + receive_ra, + NDP_MSG_RA, + nm_ndisc_get_ifindex(ndisc), + ndisc); + break; + case NM_NDISC_NODE_TYPE_ROUTER: + ndp_msgrcv_handler_register(priv->ndp, + receive_rs, + NDP_MSG_RS, + nm_ndisc_get_ifindex(ndisc), + ndisc); + break; + default: + g_assert_not_reached(); + } +} + +static void +_cleanup(NMNDisc *ndisc) +{ + NMLndpNDiscPrivate *priv = NM_LNDP_NDISC_GET_PRIVATE(ndisc); + + nm_clear_g_source_inst(&priv->event_source); + + if (priv->ndp) { + switch (nm_ndisc_get_node_type(ndisc)) { + case NM_NDISC_NODE_TYPE_HOST: + ndp_msgrcv_handler_unregister(priv->ndp, + receive_ra, + NDP_MSG_RA, + nm_ndisc_get_ifindex(ndisc), + ndisc); + break; + case NM_NDISC_NODE_TYPE_ROUTER: + ndp_msgrcv_handler_unregister(priv->ndp, + receive_rs, + NDP_MSG_RS, + nm_ndisc_get_ifindex(ndisc), + ndisc); + break; + default: + nm_assert_not_reached(); + break; + } + ndp_close(priv->ndp); + priv->ndp = NULL; + } +} + +static void +stop(NMNDisc *ndisc) +{ + _cleanup(ndisc); +} + +/*****************************************************************************/ + +static int +ipv6_sysctl_get(NMPlatform *platform, + const char *ifname, + const char *property, + int min, + int max, + int defval) +{ + return nm_platform_sysctl_ip_conf_get_int_checked(platform, + AF_INET6, + ifname, + property, + 10, + min, + max, + defval); +} + +void +nm_lndp_ndisc_get_sysctl(NMPlatform *platform, + const char *ifname, + int * out_max_addresses, + int * out_router_solicitations, + int * out_router_solicitation_interval, + guint32 * out_default_ra_timeout) +{ + int router_solicitation_interval = 0; + int router_solicitations = 0; + + if (out_max_addresses) { + *out_max_addresses = ipv6_sysctl_get(platform, + ifname, + "max_addresses", + 0, + G_MAXINT32, + NM_NDISC_MAX_ADDRESSES_DEFAULT); + } + if (out_router_solicitations || out_default_ra_timeout) { + router_solicitations = ipv6_sysctl_get(platform, + ifname, + "router_solicitations", + 1, + G_MAXINT32, + NM_NDISC_ROUTER_SOLICITATIONS_DEFAULT); + NM_SET_OUT(out_router_solicitations, router_solicitations); + } + if (out_router_solicitation_interval || out_default_ra_timeout) { + router_solicitation_interval = ipv6_sysctl_get(platform, + ifname, + "router_solicitation_interval", + 1, + G_MAXINT32, + NM_NDISC_RFC4861_RTR_SOLICITATION_INTERVAL); + NM_SET_OUT(out_router_solicitation_interval, router_solicitation_interval); + } + if (out_default_ra_timeout) { + *out_default_ra_timeout = + NM_MAX((((gint64) router_solicitations) * router_solicitation_interval) + 1, 30); + } +} + +/*****************************************************************************/ + +static void +nm_lndp_ndisc_init(NMLndpNDisc *lndp_ndisc) +{} + +NMNDisc * +nm_lndp_ndisc_new(NMPlatform * platform, + int ifindex, + const char * ifname, + NMUtilsStableType stable_type, + const char * network_id, + NMSettingIP6ConfigAddrGenMode addr_gen_mode, + NMNDiscNodeType node_type, + int max_addresses, + int router_solicitations, + int router_solicitation_interval, + guint32 ra_timeout, + GError ** error) +{ + nm_auto_pop_netns NMPNetns *netns = NULL; + NMNDisc * ndisc; + NMLndpNDiscPrivate * priv; + int errsv; + + g_return_val_if_fail(NM_IS_PLATFORM(platform), NULL); + g_return_val_if_fail(!error || !*error, NULL); + g_return_val_if_fail(network_id, NULL); + + if (!nm_platform_netns_push(platform, &netns)) + return NULL; + + ndisc = g_object_new(NM_TYPE_LNDP_NDISC, + NM_NDISC_PLATFORM, + platform, + NM_NDISC_STABLE_TYPE, + (int) stable_type, + NM_NDISC_IFINDEX, + ifindex, + NM_NDISC_IFNAME, + ifname, + NM_NDISC_NETWORK_ID, + network_id, + NM_NDISC_ADDR_GEN_MODE, + (int) addr_gen_mode, + NM_NDISC_NODE_TYPE, + (int) node_type, + NM_NDISC_MAX_ADDRESSES, + max_addresses, + NM_NDISC_ROUTER_SOLICITATIONS, + router_solicitations, + NM_NDISC_ROUTER_SOLICITATION_INTERVAL, + router_solicitation_interval, + NM_NDISC_RA_TIMEOUT, + (guint) ra_timeout, + NULL); + + priv = NM_LNDP_NDISC_GET_PRIVATE(ndisc); + + errsv = ndp_open(&priv->ndp); + + if (errsv != 0) { + errsv = nm_errno_native(errsv); + g_set_error(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + "failure creating libndp socket: %s (%d)", + nm_strerror_native(errsv), + errsv); + g_object_unref(ndisc); + return NULL; + } + return ndisc; +} + +static void +dispose(GObject *object) +{ + NMNDisc *ndisc = NM_NDISC(object); + + _cleanup(ndisc); + + G_OBJECT_CLASS(nm_lndp_ndisc_parent_class)->dispose(object); +} + +static void +nm_lndp_ndisc_class_init(NMLndpNDiscClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS(klass); + NMNDiscClass *ndisc_class = NM_NDISC_CLASS(klass); + + object_class->dispose = dispose; + ndisc_class->start = start; + ndisc_class->stop = stop; + ndisc_class->send_rs = send_rs; + ndisc_class->send_ra = send_ra; +} diff --git a/src/core/ndisc/nm-lndp-ndisc.h b/src/core/ndisc/nm-lndp-ndisc.h new file mode 100644 index 00000000..96fc9737 --- /dev/null +++ b/src/core/ndisc/nm-lndp-ndisc.h @@ -0,0 +1,46 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2013 Red Hat, Inc. + */ + +#ifndef __NETWORKMANAGER_LNDP_NDISC_H__ +#define __NETWORKMANAGER_LNDP_NDISC_H__ + +#include "nm-ndisc.h" +#include "nm-core-utils.h" + +#define NM_TYPE_LNDP_NDISC (nm_lndp_ndisc_get_type()) +#define NM_LNDP_NDISC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_LNDP_NDISC, NMLndpNDisc)) +#define NM_LNDP_NDISC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_LNDP_NDISC, NMLndpNDiscClass)) +#define NM_IS_LNDP_NDISC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_LNDP_NDISC)) +#define NM_IS_LNDP_NDISC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_LNDP_NDISC)) +#define NM_LNDP_NDISC_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_LNDP_NDISC, NMLndpNDiscClass)) + +typedef struct _NMLndpNDisc NMLndpNDisc; +typedef struct _NMLndpNDiscClass NMLndpNDiscClass; + +GType nm_lndp_ndisc_get_type(void); + +NMNDisc *nm_lndp_ndisc_new(NMPlatform * platform, + int ifindex, + const char * ifname, + NMUtilsStableType stable_type, + const char * network_id, + NMSettingIP6ConfigAddrGenMode addr_gen_mode, + NMNDiscNodeType node_type, + int max_addresses, + int router_solicitations, + int router_solicitation_interval, + guint32 ra_timeout, + GError ** error); + +void nm_lndp_ndisc_get_sysctl(NMPlatform *platform, + const char *ifname, + int * out_max_addresses, + int * out_router_solicitations, + int * out_router_solicitation_interval, + guint32 * out_default_ra_timeout); + +#endif /* __NETWORKMANAGER_LNDP_NDISC_H__ */ diff --git a/src/core/ndisc/nm-ndisc-private.h b/src/core/ndisc/nm-ndisc-private.h new file mode 100644 index 00000000..04739124 --- /dev/null +++ b/src/core/ndisc/nm-ndisc-private.h @@ -0,0 +1,68 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2015 Red Hat, Inc. + */ + +#ifndef __NETWORKMANAGER_NDISC_PRIVATE_H__ +#define __NETWORKMANAGER_NDISC_PRIVATE_H__ + +#include "nm-ndisc.h" + +/* Functions only used by ndisc implementations */ + +struct _NMNDiscDataInternal { + NMNDiscData public; + GArray *gateways; + GArray *addresses; + GArray *routes; + GArray *dns_servers; + GArray *dns_domains; +}; + +typedef struct _NMNDiscDataInternal NMNDiscDataInternal; + +void nm_ndisc_ra_received(NMNDisc *ndisc, gint64 now_msec, NMNDiscConfigMap changed); +void nm_ndisc_rs_received(NMNDisc *ndisc); + +gboolean nm_ndisc_add_gateway(NMNDisc *ndisc, const NMNDiscGateway *new_item, gint64 now_msec); +gboolean +nm_ndisc_complete_and_add_address(NMNDisc *ndisc, const NMNDiscAddress *new_item, gint64 now_msec); +gboolean nm_ndisc_add_route(NMNDisc *ndisc, const NMNDiscRoute *new_item, gint64 now_msec); +gboolean nm_ndisc_add_dns_server(NMNDisc *ndisc, const NMNDiscDNSServer *new_item, gint64 now_msec); +gboolean nm_ndisc_add_dns_domain(NMNDisc *ndisc, const NMNDiscDNSDomain *new_item, gint64 now_msec); + +/*****************************************************************************/ + +#define _NMLOG_DOMAIN LOGD_IP6 +#define _NMLOG(level, ...) _LOG(level, _NMLOG_DOMAIN, ndisc, __VA_ARGS__) + +#define _LOG(level, domain, self, ...) \ + G_STMT_START \ + { \ + const NMLogLevel __level = (level); \ + const NMLogDomain __domain = (domain); \ + \ + if (nm_logging_enabled(__level, __domain)) { \ + NMNDisc *const __self = (self); \ + char __prefix[64]; \ + const char * __ifname = __self ? nm_ndisc_get_ifname(__self) : NULL; \ + \ + _nm_log(__level, \ + __domain, \ + 0, \ + __ifname, \ + NULL, \ + "%s: " _NM_UTILS_MACRO_FIRST(__VA_ARGS__), \ + (__self ? nm_sprintf_buf(__prefix, \ + "%s[%p,%s%s%s]", \ + _NMLOG_PREFIX_NAME, \ + __self, \ + NM_PRINT_FMT_QUOTE_STRING(__ifname)) \ + : _NMLOG_PREFIX_NAME) _NM_UTILS_MACRO_REST(__VA_ARGS__)); \ + } \ + } \ + G_STMT_END + +/*****************************************************************************/ + +#endif /* __NETWORKMANAGER_NDISC_PRIVATE_H__ */ diff --git a/src/core/ndisc/nm-ndisc.c b/src/core/ndisc/nm-ndisc.c new file mode 100644 index 00000000..a5c1b935 --- /dev/null +++ b/src/core/ndisc/nm-ndisc.c @@ -0,0 +1,1830 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2013 Red Hat, Inc. + */ + +#include "src/core/nm-default-daemon.h" + +#include "nm-ndisc.h" + +#include <stdlib.h> +#include <arpa/inet.h> + +#include "nm-setting-ip6-config.h" + +#include "nm-ndisc-private.h" +#include "nm-utils.h" +#include "platform/nm-platform.h" +#include "nm-platform/nmp-netns.h" +#include "nm-l3-config-data.h" + +#define _NMLOG_PREFIX_NAME "ndisc" + +#define RFC7559_IRT ((gint32) 4) /* RFC7559, Initial Retransmission Time, in seconds */ +#define RFC7559_MRT ((gint32) 3600) /* RFC7559, Maximum Retransmission Time, in seconds */ + +#define _SIZE_MAX_GATEWAYS 100u +#define _SIZE_MAX_ADDRESSES 100u +#define _SIZE_MAX_ROUTES 1000u +#define _SIZE_MAX_DNS_SERVERS 64u +#define _SIZE_MAX_DNS_DOMAINS 64u + +/*****************************************************************************/ + +struct _NMNDiscPrivate { + /* this *must* be the first field. */ + NMNDiscDataInternal rdata; + + char *last_error; + + GSource *ra_timeout_source; + + gint32 announcements_left; + guint send_ra_id; + gint32 last_ra; + + gint32 solicit_retransmit_time_msec; + + GSource *solicit_timer_source; + + GSource *timeout_expire_source; + + NMUtilsIPv6IfaceId iid; + + /* immutable values: */ + int ifindex; + char * ifname; + char * network_id; + guint max_addresses; + NMSettingIP6ConfigAddrGenMode addr_gen_mode; + NMUtilsStableType stable_type; + guint32 ra_timeout; + gint32 router_solicitations; + gint32 router_solicitation_interval; + NMNDiscNodeType node_type; + + NMPlatform *platform; + NMPNetns * netns; +}; + +typedef struct _NMNDiscPrivate NMNDiscPrivate; + +NM_GOBJECT_PROPERTIES_DEFINE_BASE(PROP_PLATFORM, + PROP_IFINDEX, + PROP_IFNAME, + PROP_STABLE_TYPE, + PROP_NETWORK_ID, + PROP_ADDR_GEN_MODE, + PROP_MAX_ADDRESSES, + PROP_RA_TIMEOUT, + PROP_ROUTER_SOLICITATIONS, + PROP_ROUTER_SOLICITATION_INTERVAL, + PROP_NODE_TYPE, ); + +enum { CONFIG_RECEIVED, RA_TIMEOUT_SIGNAL, LAST_SIGNAL }; + +static guint signals[LAST_SIGNAL] = {0}; + +G_DEFINE_TYPE(NMNDisc, nm_ndisc, G_TYPE_OBJECT) + +#define NM_NDISC_GET_PRIVATE(self) _NM_GET_PRIVATE_PTR(self, NMNDisc, NM_IS_NDISC) + +/*****************************************************************************/ + +static void _config_changed_log(NMNDisc *ndisc, NMNDiscConfigMap changed); +static gboolean timeout_expire_cb(gpointer user_data); + +/*****************************************************************************/ + +NML3ConfigData * +nm_ndisc_data_to_l3cd(NMDedupMultiIndex * multi_idx, + int ifindex, + const NMNDiscData * rdata, + NMSettingIP6ConfigPrivacy ip6_privacy, + guint32 route_table, + guint32 route_metric, + gboolean kernel_support_rta_pref, + gboolean kernel_support_extended_ifa_flags) +{ + nm_auto_unref_l3cd_init NML3ConfigData *l3cd = NULL; + guint32 ifa_flags; + guint8 plen; + guint i; + const gint32 now_sec = nm_utils_get_monotonic_timestamp_sec(); + + l3cd = nm_l3_config_data_new(multi_idx, ifindex); + + nm_l3_config_data_set_source(l3cd, NM_IP_CONFIG_SOURCE_NDISC); + + nm_l3_config_data_set_ip6_privacy(l3cd, ip6_privacy); + + /* Check, whether kernel is recent enough to help user space handling RA. + * If it's not supported, we have no ipv6-privacy and must add autoconf + * addresses as /128. The reason for the /128 is to prevent the kernel + * from adding a prefix route for this address. */ + ifa_flags = 0; + if (kernel_support_extended_ifa_flags) { + ifa_flags |= IFA_F_NOPREFIXROUTE; + if (NM_IN_SET(ip6_privacy, + NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_TEMP_ADDR, + NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_PUBLIC_ADDR)) + ifa_flags |= IFA_F_MANAGETEMPADDR; + plen = 64; + } else + plen = 128; + + for (i = 0; i < rdata->addresses_n; i++) { + const NMNDiscAddress *ndisc_addr = &rdata->addresses[i]; + NMPlatformIP6Address a; + + a = (NMPlatformIP6Address){ + .ifindex = ifindex, + .address = ndisc_addr->address, + .plen = plen, + .timestamp = now_sec, + .lifetime = _nm_ndisc_lifetime_from_expiry(((gint64) now_sec) * 1000, + ndisc_addr->expiry_msec, + TRUE), + .preferred = _nm_ndisc_lifetime_from_expiry( + ((gint64) now_sec) * 1000, + NM_MIN(ndisc_addr->expiry_msec, ndisc_addr->expiry_preferred_msec), + TRUE), + .addr_source = NM_IP_CONFIG_SOURCE_NDISC, + .n_ifa_flags = ifa_flags, + }; + + nm_l3_config_data_add_address_6(l3cd, &a); + } + + for (i = 0; i < rdata->routes_n; i++) { + const NMNDiscRoute *ndisc_route = &rdata->routes[i]; + NMPlatformIP6Route r; + + r = (NMPlatformIP6Route){ + .ifindex = ifindex, + .network = ndisc_route->network, + .plen = ndisc_route->plen, + .gateway = ndisc_route->gateway, + .rt_source = NM_IP_CONFIG_SOURCE_NDISC, + .table_coerced = nm_platform_route_table_coerce(route_table), + .metric = route_metric, + .rt_pref = ndisc_route->preference, + }; + nm_assert((NMIcmpv6RouterPref) r.rt_pref == ndisc_route->preference); + + nm_l3_config_data_add_route_6(l3cd, &r); + } + + if (rdata->gateways_n > 0) { + const NMIcmpv6RouterPref first_pref = rdata->gateways[0].preference; + NMPlatformIP6Route r = { + .rt_source = NM_IP_CONFIG_SOURCE_NDISC, + .ifindex = ifindex, + .table_coerced = nm_platform_route_table_coerce(route_table), + .metric = route_metric, + }; + + for (i = 0; i < rdata->gateways_n; i++) { + r.gateway = rdata->gateways[i].address; + r.rt_pref = rdata->gateways[i].preference; + nm_assert((NMIcmpv6RouterPref) r.rt_pref == rdata->gateways[i].preference); + nm_l3_config_data_add_route_6(l3cd, &r); + + if (first_pref != rdata->gateways[i].preference && !kernel_support_rta_pref) { + /* We are unable to configure a router preference. Hence, we skip all gateways + * with a different preference from the first gateway. Note, that the gateways + * are sorted in order of highest to lowest preference. */ + break; + } + } + } + + for (i = 0; i < rdata->dns_servers_n; i++) + nm_l3_config_data_add_nameserver(l3cd, AF_INET6, &rdata->dns_servers[i].address); + + for (i = 0; i < rdata->dns_domains_n; i++) + nm_l3_config_data_add_search(l3cd, AF_INET6, rdata->dns_domains[i].domain); + + nm_l3_config_data_set_ndisc_hop_limit(l3cd, rdata->hop_limit); + nm_l3_config_data_set_ndisc_reachable_time_msec(l3cd, rdata->reachable_time_ms); + nm_l3_config_data_set_ndisc_retrans_timer_msec(l3cd, rdata->retrans_timer_ms); + + nm_l3_config_data_set_ip6_mtu(l3cd, rdata->mtu); + + return g_steal_pointer(&l3cd); +} + +/*****************************************************************************/ + +static guint8 +_preference_to_priority(NMIcmpv6RouterPref pref) +{ + switch (pref) { + case NM_ICMPV6_ROUTER_PREF_LOW: + return 1; + case NM_ICMPV6_ROUTER_PREF_MEDIUM: + return 2; + case NM_ICMPV6_ROUTER_PREF_HIGH: + return 3; + case NM_ICMPV6_ROUTER_PREF_INVALID: + break; + } + return 0; +} + +/*****************************************************************************/ + +static gboolean +expiry_next(gint64 now_msec, gint64 expiry_msec, gint64 *next_msec) +{ + if (expiry_msec == NM_NDISC_EXPIRY_INFINITY) + return TRUE; + + if (expiry_msec <= now_msec) { + /* expired. */ + return FALSE; + } + + if (next_msec) { + if (*next_msec > expiry_msec) + *next_msec = expiry_msec; + } + + /* the timestamp is good (not yet expired) */ + return TRUE; +} + +static const char * +_get_exp(char *buf, gsize buf_size, gint64 now_msec, gint64 expiry_time) +{ + int l; + + if (expiry_time == NM_NDISC_EXPIRY_INFINITY) + return "permanent"; + l = g_snprintf(buf, buf_size, "%.3f", ((double) (expiry_time - now_msec)) / 1000); + nm_assert(l < buf_size); + return buf; +} + +#define get_exp(buf, now_msec, item) \ + _get_exp((buf), G_N_ELEMENTS(buf), (now_msec), (item)->expiry_msec) + +/*****************************************************************************/ + +NMPNetns * +nm_ndisc_netns_get(NMNDisc *self) +{ + g_return_val_if_fail(NM_IS_NDISC(self), NULL); + + return NM_NDISC_GET_PRIVATE(self)->netns; +} + +gboolean +nm_ndisc_netns_push(NMNDisc *self, NMPNetns **netns) +{ + NMNDiscPrivate *priv; + + g_return_val_if_fail(NM_IS_NDISC(self), FALSE); + + priv = NM_NDISC_GET_PRIVATE(self); + if (priv->netns && !nmp_netns_push(priv->netns)) { + NM_SET_OUT(netns, NULL); + return FALSE; + } + + NM_SET_OUT(netns, priv->netns); + return TRUE; +} + +/*****************************************************************************/ + +int +nm_ndisc_get_ifindex(NMNDisc *self) +{ + g_return_val_if_fail(NM_IS_NDISC(self), 0); + + return NM_NDISC_GET_PRIVATE(self)->ifindex; +} + +const char * +nm_ndisc_get_ifname(NMNDisc *self) +{ + g_return_val_if_fail(NM_IS_NDISC(self), NULL); + + return NM_NDISC_GET_PRIVATE(self)->ifname; +} + +NMNDiscNodeType +nm_ndisc_get_node_type(NMNDisc *self) +{ + g_return_val_if_fail(NM_IS_NDISC(self), NM_NDISC_NODE_TYPE_INVALID); + + return NM_NDISC_GET_PRIVATE(self)->node_type; +} + +/*****************************************************************************/ + +static void +_ASSERT_data_gateways(const NMNDiscDataInternal *data) +{ +#if NM_MORE_ASSERTS > 10 + guint i, j; + const NMNDiscGateway *item_prev = NULL; + + if (!data->gateways->len) + return; + + for (i = 0; i < data->gateways->len; i++) { + const NMNDiscGateway *item = &g_array_index(data->gateways, NMNDiscGateway, i); + + nm_assert(!IN6_IS_ADDR_UNSPECIFIED(&item->address)); + for (j = 0; j < i; j++) { + const NMNDiscGateway *item2 = &g_array_index(data->gateways, NMNDiscGateway, j); + + nm_assert(!IN6_ARE_ADDR_EQUAL(&item->address, &item2->address)); + } + + if (i > 0) { + nm_assert(_preference_to_priority(item_prev->preference) + >= _preference_to_priority(item->preference)); + } + + item_prev = item; + } +#endif +} + +/*****************************************************************************/ + +static const NMNDiscData * +_data_complete(NMNDiscDataInternal *data) +{ + _ASSERT_data_gateways(data); + +#define _SET(data, field) \ + G_STMT_START \ + { \ + if ((data->public.field##_n = data->field->len) > 0) \ + data->public.field = (gpointer) data->field->data; \ + else \ + data->public.field = NULL; \ + } \ + G_STMT_END + _SET(data, gateways); + _SET(data, addresses); + _SET(data, routes); + _SET(data, dns_servers); + _SET(data, dns_domains); +#undef _SET + return &data->public; +} + +void +nm_ndisc_emit_config_change(NMNDisc *self, NMNDiscConfigMap changed) +{ + _config_changed_log(self, changed); + g_signal_emit(self, + signals[CONFIG_RECEIVED], + 0, + _data_complete(&NM_NDISC_GET_PRIVATE(self)->rdata), + (guint) changed); +} + +/*****************************************************************************/ + +gboolean +nm_ndisc_add_gateway(NMNDisc *ndisc, const NMNDiscGateway *new_item, gint64 now_msec) +{ + NMNDiscDataInternal *rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata; + guint i; + guint insert_idx = G_MAXUINT; + + for (i = 0; i < rdata->gateways->len;) { + NMNDiscGateway *item = &g_array_index(rdata->gateways, NMNDiscGateway, i); + + if (IN6_ARE_ADDR_EQUAL(&item->address, &new_item->address)) { + if (new_item->expiry_msec <= now_msec) { + g_array_remove_index(rdata->gateways, i); + _ASSERT_data_gateways(rdata); + return TRUE; + } + + if (item->preference != new_item->preference) { + g_array_remove_index(rdata->gateways, i); + continue; + } + + if (item->expiry_msec == new_item->expiry_msec) + return FALSE; + + item->expiry_msec = new_item->expiry_msec; + _ASSERT_data_gateways(rdata); + return TRUE; + } + + /* Put before less preferable gateways. */ + if (_preference_to_priority(item->preference) + < _preference_to_priority(new_item->preference) + && insert_idx == G_MAXUINT) + insert_idx = i; + + i++; + } + + if (rdata->gateways->len >= _SIZE_MAX_GATEWAYS) + return FALSE; + + if (new_item->expiry_msec <= now_msec) + return FALSE; + + g_array_insert_val(rdata->gateways, + insert_idx == G_MAXUINT ? rdata->gateways->len : insert_idx, + *new_item); + _ASSERT_data_gateways(rdata); + return TRUE; +} + +/** + * complete_address: + * @ndisc: the #NMNDisc + * @addr: the #NMNDiscAddress + * + * Adds the host part to the address that has network part set. + * If the address already has a host part, add a different host part + * if possible (this is useful in case DAD failed). + * + * Can fail if a different address can not be generated (DAD failure + * for an EUI-64 address or DAD counter overflow). + * + * Returns: %TRUE if the address could be completed, %FALSE otherwise. + **/ +static gboolean +complete_address(NMNDisc *ndisc, NMNDiscAddress *addr) +{ + NMNDiscPrivate *priv; + GError * error = NULL; + + g_return_val_if_fail(NM_IS_NDISC(ndisc), FALSE); + + priv = NM_NDISC_GET_PRIVATE(ndisc); + if (priv->addr_gen_mode == NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY) { + if (!nm_utils_ipv6_addr_set_stable_privacy(priv->stable_type, + &addr->address, + priv->ifname, + priv->network_id, + addr->dad_counter++, + &error)) { + _LOGW("complete-address: failed to generate an stable-privacy address: %s", + error->message); + g_clear_error(&error); + return FALSE; + } + _LOGD("complete-address: using an stable-privacy address"); + return TRUE; + } + + if (!priv->iid.id) { + _LOGW("complete-address: can't generate an EUI-64 address: no interface identifier"); + return FALSE; + } + + if (addr->address.s6_addr32[2] == 0x0 && addr->address.s6_addr32[3] == 0x0) { + _LOGD("complete-address: adding an EUI-64 address"); + nm_utils_ipv6_addr_set_interface_identifier(&addr->address, priv->iid); + return TRUE; + } + + _LOGW("complete-address: can't generate a new_item EUI-64 address"); + return FALSE; +} + +static gboolean +nm_ndisc_add_address(NMNDisc * ndisc, + const NMNDiscAddress *new_item, + gint64 now_msec, + gboolean from_ra) +{ + NMNDiscPrivate * priv = NM_NDISC_GET_PRIVATE(ndisc); + NMNDiscDataInternal *rdata = &priv->rdata; + NMNDiscAddress * new2; + NMNDiscAddress * existing = NULL; + guint i; + + nm_assert(new_item); + nm_assert(!IN6_IS_ADDR_UNSPECIFIED(&new_item->address)); + nm_assert(!IN6_IS_ADDR_LINKLOCAL(&new_item->address)); + nm_assert(new_item->expiry_preferred_msec <= new_item->expiry_msec); + nm_assert((!!from_ra) == (now_msec > 0)); + + for (i = 0; i < rdata->addresses->len; i++) { + NMNDiscAddress *item = &g_array_index(rdata->addresses, NMNDiscAddress, i); + + if (from_ra) { + /* RFC4862 5.5.3.d, we find an existing address with the same prefix. + * (note that all prefixes at this point have implicitly length /64). */ + if (memcmp(&item->address, &new_item->address, 8) == 0) { + existing = item; + break; + } + } else { + if (IN6_ARE_ADDR_EQUAL(&item->address, &new_item->address)) { + existing = item; + break; + } + } + } + + if (existing) { + gint64 new_expiry_preferred_msec; + gint64 new_expiry_msec; + + if (from_ra) { + if (new_item->expiry_msec == NM_NDISC_EXPIRY_INFINITY) + new_expiry_msec = NM_NDISC_EXPIRY_INFINITY; + else { + const gint64 NDISC_PREFIX_LFT_MIN_MSEC = 7200 * 1000; /* RFC4862 5.5.3.e */ + gint64 new_lifetime; + gint64 existing_lifetime; + + new_lifetime = new_item->expiry_msec - now_msec; + if (existing->expiry_msec == NM_NDISC_EXPIRY_INFINITY) + existing_lifetime = G_MAXINT64; + else + existing_lifetime = existing->expiry_msec - now_msec; + + /* see RFC4862 5.5.3.e */ + if (new_lifetime >= NDISC_PREFIX_LFT_MIN_MSEC + || new_lifetime >= existing_lifetime) { + /* either extend the lifetime of the new_item lifetime is longer than + * NDISC_PREFIX_LFT_MIN_MSEC. */ + new_expiry_msec = new_item->expiry_msec; + } else if (existing_lifetime <= NDISC_PREFIX_LFT_MIN_MSEC) { + /* keep the current lifetime. */ + new_expiry_msec = existing->expiry_msec; + } else { + /* trim the current lifetime to NDISC_PREFIX_LFT_MIN_MSEC. */ + new_expiry_msec = now_msec + NDISC_PREFIX_LFT_MIN_MSEC; + } + } + + new_expiry_preferred_msec = + NM_MIN(new_item->expiry_preferred_msec, new_item->expiry_msec); + new_expiry_preferred_msec = NM_MIN(new_expiry_preferred_msec, new_expiry_msec); + } else { + if (new_item->expiry_msec <= now_msec) { + g_array_remove_index(rdata->addresses, i); + return TRUE; + } + + new_expiry_msec = new_item->expiry_msec; + new_expiry_preferred_msec = + NM_MIN(new_item->expiry_preferred_msec, new_item->expiry_msec); + } + + /* the dad_counter does not get modified. */ + if (new_expiry_msec == existing->expiry_msec + && new_expiry_preferred_msec == existing->expiry_preferred_msec) { + return FALSE; + } + + existing->expiry_msec = new_expiry_msec; + existing->expiry_preferred_msec = new_expiry_preferred_msec; + return TRUE; + } + + /* we create at most max_addresses autoconf addresses. This is different from + * what the kernel does, because it considers *all* addresses (including + * static and other temporary addresses). + **/ + if (rdata->addresses->len >= priv->max_addresses) + return FALSE; + + if (new_item->expiry_msec <= now_msec) + return FALSE; + + new2 = nm_g_array_append_new(rdata->addresses, NMNDiscAddress); + + *new2 = *new_item; + + new2->expiry_preferred_msec = NM_MIN(new2->expiry_preferred_msec, new2->expiry_msec); + + if (from_ra) { + new2->dad_counter = 0; + if (!complete_address(ndisc, new2)) { + g_array_set_size(rdata->addresses, rdata->addresses->len - 1); + return FALSE; + } + } + + return TRUE; +} + +gboolean +nm_ndisc_complete_and_add_address(NMNDisc *ndisc, const NMNDiscAddress *new_item, gint64 now_msec) +{ + return nm_ndisc_add_address(ndisc, new_item, now_msec, TRUE); +} + +gboolean +nm_ndisc_add_route(NMNDisc *ndisc, const NMNDiscRoute *new_item, gint64 now_msec) +{ + NMNDiscPrivate * priv; + NMNDiscDataInternal *rdata; + guint i; + guint insert_idx = G_MAXUINT; + gboolean changed = FALSE; + + if (new_item->plen == 0 || new_item->plen > 128) { + /* Only expect non-default routes. The router has no idea what the + * local configuration or user preferences are, so sending routes + * with a prefix length of 0 must be ignored by NMNDisc. + * + * Also, upper layers also don't expect that NMNDisc exposes routes + * with a plen or zero or larger then 128. + */ + g_return_val_if_reached(FALSE); + } + + priv = NM_NDISC_GET_PRIVATE(ndisc); + rdata = &priv->rdata; + + for (i = 0; i < rdata->routes->len;) { + NMNDiscRoute *item = &g_array_index(rdata->routes, NMNDiscRoute, i); + + if (IN6_ARE_ADDR_EQUAL(&item->network, &new_item->network) + && item->plen == new_item->plen) { + if (new_item->expiry_msec <= now_msec) { + g_array_remove_index(rdata->routes, i); + return TRUE; + } + + if (item->preference != new_item->preference) { + g_array_remove_index(rdata->routes, i); + changed = TRUE; + continue; + } + + if (item->expiry_msec == new_item->expiry_msec + && IN6_ARE_ADDR_EQUAL(&item->gateway, &new_item->gateway)) + return FALSE; + + item->expiry_msec = new_item->expiry_msec; + item->gateway = new_item->gateway; + return TRUE; + } + + /* Put before less preferable routes. */ + if (_preference_to_priority(item->preference) + < _preference_to_priority(new_item->preference) + && insert_idx == G_MAXUINT) + insert_idx = i; + + i++; + } + + if (rdata->routes->len >= _SIZE_MAX_ROUTES) + return FALSE; + + if (new_item->expiry_msec <= now_msec) { + nm_assert(!changed); + return FALSE; + } + + g_array_insert_val(rdata->routes, insert_idx == G_MAXUINT ? 0u : insert_idx, *new_item); + return TRUE; +} + +gboolean +nm_ndisc_add_dns_server(NMNDisc *ndisc, const NMNDiscDNSServer *new_item, gint64 now_msec) +{ + NMNDiscPrivate * priv; + NMNDiscDataInternal *rdata; + guint i; + + priv = NM_NDISC_GET_PRIVATE(ndisc); + rdata = &priv->rdata; + + for (i = 0; i < rdata->dns_servers->len; i++) { + NMNDiscDNSServer *item = &g_array_index(rdata->dns_servers, NMNDiscDNSServer, i); + + if (IN6_ARE_ADDR_EQUAL(&item->address, &new_item->address)) { + if (new_item->expiry_msec <= now_msec) { + g_array_remove_index(rdata->dns_servers, i); + return TRUE; + } + + if (item->expiry_msec == new_item->expiry_msec) + return FALSE; + + item->expiry_msec = new_item->expiry_msec; + return TRUE; + } + } + + if (rdata->dns_servers->len >= _SIZE_MAX_DNS_SERVERS) + return FALSE; + + if (new_item->expiry_msec <= now_msec) + return FALSE; + + g_array_append_val(rdata->dns_servers, *new_item); + return TRUE; +} + +/* Copies new_item->domain if 'new_item' is added to the dns_domains list */ +gboolean +nm_ndisc_add_dns_domain(NMNDisc *ndisc, const NMNDiscDNSDomain *new_item, gint64 now_msec) +{ + NMNDiscPrivate * priv; + NMNDiscDataInternal *rdata; + NMNDiscDNSDomain * item; + guint i; + + priv = NM_NDISC_GET_PRIVATE(ndisc); + rdata = &priv->rdata; + + for (i = 0; i < rdata->dns_domains->len; i++) { + item = &g_array_index(rdata->dns_domains, NMNDiscDNSDomain, i); + + if (nm_streq(item->domain, new_item->domain)) { + if (new_item->expiry_msec <= now_msec) { + g_array_remove_index(rdata->dns_domains, i); + return TRUE; + } + + if (item->expiry_msec == new_item->expiry_msec) + return FALSE; + + item->expiry_msec = new_item->expiry_msec; + return TRUE; + } + } + + if (rdata->dns_domains->len >= _SIZE_MAX_DNS_DOMAINS) + return FALSE; + + if (new_item->expiry_msec <= now_msec) + return FALSE; + + item = nm_g_array_append_new(rdata->dns_domains, NMNDiscDNSDomain); + *item = (NMNDiscDNSDomain){ + .domain = g_strdup(new_item->domain), + .expiry_msec = new_item->expiry_msec, + }; + return TRUE; +} + +/*****************************************************************************/ + +#define _MAYBE_WARN(...) \ + G_STMT_START \ + { \ + gboolean _different_message; \ + \ + _different_message = !nm_streq0(priv->last_error, error->message); \ + _NMLOG(_different_message ? LOGL_WARN : LOGL_DEBUG, __VA_ARGS__); \ + if (_different_message) { \ + nm_clear_g_free(&priv->last_error); \ + priv->last_error = g_strdup(error->message); \ + } \ + } \ + G_STMT_END + +static gint32 +solicit_retransmit_time_jitter(gint32 solicit_retransmit_time_msec) +{ + gint32 ten_percent; + + nm_assert(solicit_retransmit_time_msec > 0); + nm_assert(solicit_retransmit_time_msec < 3 * RFC7559_MRT * 1000); + + /* Add a ±10% jitter. + * + * This is the "RAND" parameter from https://tools.ietf.org/html/rfc3315#section-14 + * as requested by RFC7559. */ + + ten_percent = NM_MAX(1, solicit_retransmit_time_msec / 10); + + return solicit_retransmit_time_msec - ten_percent + + ((gint32)(g_random_int() % (2u * ((guint32) ten_percent)))); +} + +static gboolean +solicit_timer_cb(gpointer user_data) +{ + const gint32 TIMEOUT_APPROX_THRESHOLD_SEC = 10000; + nm_auto_pop_netns NMPNetns *netns = NULL; + NMNDisc * ndisc = user_data; + NMNDiscClass * klass = NM_NDISC_GET_CLASS(ndisc); + NMNDiscPrivate * priv = NM_NDISC_GET_PRIVATE(ndisc); + gs_free_error GError *error = NULL; + gint32 timeout_msec; + + if (!nm_ndisc_netns_push(ndisc, &netns)) { + nm_utils_error_set(&error, + NM_UTILS_ERROR_UNKNOWN, + "failure to switch netns for soliciting routers"); + } else + klass->send_rs(ndisc, &error); + + if (error) + _MAYBE_WARN("solicit: failure sending router solicitation: %s", error->message); + else { + _LOGT("solicit: router solicitation sent"); + nm_clear_g_free(&priv->last_error); + } + + /* https://tools.ietf.org/html/rfc4861#section-6.3.7 describes how to send solicitations: + * + * > ... a host SHOULD transmit up to MAX_RTR_SOLICITATIONS Router Solicitation messages, + * > each separated by at least RTR_SOLICITATION_INTERVAL seconds. + * + * but this was extended by https://tools.ietf.org/html/rfc7559#section-2 to send continuously + * and with exponential backoff (detailed the algorithm in https://tools.ietf.org/html/rfc3315#section-14). + * We do RFC7559. + */ + if (priv->solicit_retransmit_time_msec == 0) { + G_STATIC_ASSERT(RFC7559_IRT == NM_NDISC_RFC4861_RTR_SOLICITATION_INTERVAL); + priv->solicit_retransmit_time_msec = solicit_retransmit_time_jitter(RFC7559_IRT * 1000); + timeout_msec = priv->solicit_retransmit_time_msec; + } else { + priv->solicit_retransmit_time_msec += + solicit_retransmit_time_jitter(priv->solicit_retransmit_time_msec); + timeout_msec = priv->solicit_retransmit_time_msec; + if (priv->solicit_retransmit_time_msec > RFC7559_MRT * 1000) { + priv->solicit_retransmit_time_msec = RFC7559_MRT * 1000; + timeout_msec = solicit_retransmit_time_jitter(priv->solicit_retransmit_time_msec); + } + } + + _LOGD("solicit: schedule sending next solicitation in%s %.3f seconds", + timeout_msec / 1000 >= TIMEOUT_APPROX_THRESHOLD_SEC ? " about" : "", + ((double) timeout_msec) / 1000); + + nm_clear_g_source_inst(&priv->solicit_timer_source); + priv->solicit_timer_source = nm_g_timeout_add_source_approx(timeout_msec, + TIMEOUT_APPROX_THRESHOLD_SEC, + solicit_timer_cb, + ndisc); + return G_SOURCE_CONTINUE; +} + +static void +solicit_timer_start(NMNDisc *ndisc) +{ + NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(ndisc); + gint32 delay_msec; + + /* rfc4861, Section 6.3.7: + * + * We should randomly wait up to NM_NDISC_RFC4861_MAX_RTR_SOLICITATION_DELAY (1 second) + * before sending the first RS. RFC4861 is from 2007, I don't think 1 second is + * a suitable delay in 2021. Wait only up to 250 msec instead. */ + + delay_msec = + g_random_int() % ((guint32)(NM_NDISC_RFC4861_MAX_RTR_SOLICITATION_DELAY * 1000 / 4)); + + _LOGD("solicit: schedule sending first solicitation (of %d) in %.3f seconds", + priv->router_solicitations, + ((double) delay_msec) / 1000); + + priv->solicit_retransmit_time_msec = 0; + nm_clear_g_source_inst(&priv->solicit_timer_source); + priv->solicit_timer_source = nm_g_timeout_add_source(delay_msec, solicit_timer_cb, ndisc); +} + +/*****************************************************************************/ + +static gboolean +announce_router(NMNDisc *ndisc) +{ + nm_auto_pop_netns NMPNetns *netns = NULL; + NMNDiscClass * klass = NM_NDISC_GET_CLASS(ndisc); + NMNDiscPrivate * priv = NM_NDISC_GET_PRIVATE(ndisc); + GError * error = NULL; + + if (!nm_ndisc_netns_push(ndisc, &netns)) + return G_SOURCE_REMOVE; + + priv->last_ra = nm_utils_get_monotonic_timestamp_sec(); + if (klass->send_ra(ndisc, &error)) { + _LOGD("router advertisement sent"); + nm_clear_g_free(&priv->last_error); + } else { + _MAYBE_WARN("failure sending router advertisement: %s", error->message); + g_clear_error(&error); + } + + if (--priv->announcements_left) { + _LOGD("will resend an initial router advertisement"); + + /* Schedule next initial announcement retransmit. */ + priv->send_ra_id = + g_timeout_add_seconds(g_random_int_range(NM_NDISC_ROUTER_ADVERT_DELAY, + NM_NDISC_ROUTER_ADVERT_INITIAL_INTERVAL), + (GSourceFunc) announce_router, + ndisc); + } else { + _LOGD("will send an unsolicited router advertisement"); + + /* Schedule next unsolicited announcement. */ + priv->announcements_left = 1; + priv->send_ra_id = g_timeout_add_seconds(NM_NDISC_ROUTER_ADVERT_MAX_INTERVAL, + (GSourceFunc) announce_router, + ndisc); + } + + return G_SOURCE_REMOVE; +} + +static void +announce_router_initial(NMNDisc *ndisc) +{ + NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(ndisc); + + _LOGD("will send an initial router advertisement"); + + /* Retry three more times. */ + priv->announcements_left = NM_NDISC_ROUTER_ADVERTISEMENTS_DEFAULT; + + /* Unschedule an unsolicited resend if we are allowed to send now. */ + if (G_LIKELY(nm_utils_get_monotonic_timestamp_sec() - priv->last_ra + > NM_NDISC_ROUTER_ADVERT_DELAY)) + nm_clear_g_source(&priv->send_ra_id); + + /* Schedule the initial send rather early. Clamp the delay by minimal + * delay and not the initial advert internal so that we start fast. */ + if (G_LIKELY(!priv->send_ra_id)) { + priv->send_ra_id = + g_timeout_add_seconds(g_random_int_range(0, NM_NDISC_ROUTER_ADVERT_DELAY), + (GSourceFunc) announce_router, + ndisc); + } +} + +static void +announce_router_solicited(NMNDisc *ndisc) +{ + NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(ndisc); + + _LOGD("will send an solicited router advertisement"); + + /* Unschedule an unsolicited resend if we are allowed to send now. */ + if (nm_utils_get_monotonic_timestamp_sec() - priv->last_ra > NM_NDISC_ROUTER_ADVERT_DELAY) + nm_clear_g_source(&priv->send_ra_id); + + if (!priv->send_ra_id) { + priv->send_ra_id = g_timeout_add(g_random_int_range(0, NM_NDISC_ROUTER_ADVERT_DELAY_MS), + (GSourceFunc) announce_router, + ndisc); + } +} + +/*****************************************************************************/ + +void +nm_ndisc_set_config(NMNDisc * ndisc, + const GArray *addresses, + const GArray *dns_servers, + const GArray *dns_domains) +{ + gboolean changed = FALSE; + guint i; + + for (i = 0; i < addresses->len; i++) { + if (nm_ndisc_add_address(ndisc, &g_array_index(addresses, NMNDiscAddress, i), 0, FALSE)) + changed = TRUE; + } + + for (i = 0; i < dns_servers->len; i++) { + if (nm_ndisc_add_dns_server(ndisc, + &g_array_index(dns_servers, NMNDiscDNSServer, i), + G_MININT64)) + changed = TRUE; + } + + for (i = 0; i < dns_domains->len; i++) { + if (nm_ndisc_add_dns_domain(ndisc, + &g_array_index(dns_domains, NMNDiscDNSDomain, i), + G_MININT64)) + changed = TRUE; + } + + if (changed) + announce_router_initial(ndisc); +} + +/** + * nm_ndisc_set_iid: + * @ndisc: the #NMNDisc + * @iid: the new interface ID + * + * Sets the "Modified EUI-64" interface ID to be used when generating + * IPv6 addresses using received prefixes. Identifiers are either generated + * from the hardware addresses or manually set by the operator with + * "ip token" command. + * + * Upon token change (or initial setting) all addresses generated using + * the old identifier are removed. The caller should ensure the addresses + * will be reset by soliciting router advertisements. + * + * In case the stable privacy addressing is used %FALSE is returned and + * addresses are left untouched. + * + * Returns: %TRUE if addresses need to be regenerated, %FALSE otherwise. + **/ +gboolean +nm_ndisc_set_iid(NMNDisc *ndisc, const NMUtilsIPv6IfaceId iid) +{ + NMNDiscPrivate * priv; + NMNDiscDataInternal *rdata; + + g_return_val_if_fail(NM_IS_NDISC(ndisc), FALSE); + + priv = NM_NDISC_GET_PRIVATE(ndisc); + rdata = &priv->rdata; + + if (priv->iid.id != iid.id) { + priv->iid = iid; + + if (priv->addr_gen_mode == NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY) + return FALSE; + + if (rdata->addresses->len) { + _LOGD("IPv6 interface identifier changed, flushing addresses"); + g_array_remove_range(rdata->addresses, 0, rdata->addresses->len); + nm_ndisc_emit_config_change(ndisc, NM_NDISC_CONFIG_ADDRESSES); + solicit_timer_start(ndisc); + } + return TRUE; + } + + return FALSE; +} + +static gboolean +ra_timeout_cb(gpointer user_data) +{ + NMNDisc *ndisc = NM_NDISC(user_data); + + nm_clear_g_source_inst(&NM_NDISC_GET_PRIVATE(ndisc)->ra_timeout_source); + g_signal_emit(ndisc, signals[RA_TIMEOUT_SIGNAL], 0); + return G_SOURCE_CONTINUE; +} + +void +nm_ndisc_start(NMNDisc *ndisc) +{ + nm_auto_pop_netns NMPNetns *netns = NULL; + NMNDiscPrivate * priv; + + g_return_if_fail(NM_IS_NDISC(ndisc)); + + priv = NM_NDISC_GET_PRIVATE(ndisc); + + nm_assert(NM_NDISC_GET_CLASS(ndisc)->start); + nm_assert(!priv->ra_timeout_source); + + _LOGD("starting neighbor discovery for ifindex %d%s", + priv->ifindex, + priv->node_type == NM_NDISC_NODE_TYPE_HOST ? " (solicit)" : " (announce)"); + + if (!nm_ndisc_netns_push(ndisc, &netns)) + return; + + NM_NDISC_GET_CLASS(ndisc)->start(ndisc); + + if (priv->node_type == NM_NDISC_NODE_TYPE_HOST) { + G_STATIC_ASSERT_EXPR(NM_RA_TIMEOUT_DEFAULT == 0); + G_STATIC_ASSERT_EXPR(NM_RA_TIMEOUT_INFINITY == G_MAXINT32); + nm_assert(priv->ra_timeout > 0u); + nm_assert(priv->ra_timeout <= NM_RA_TIMEOUT_INFINITY); + + if (priv->ra_timeout < NM_RA_TIMEOUT_INFINITY) { + guint timeout_msec; + + _LOGD("scheduling RA timeout in %u seconds", priv->ra_timeout); + if (priv->ra_timeout < G_MAXUINT / 1000u) + timeout_msec = priv->ra_timeout * 1000u; + else + timeout_msec = G_MAXUINT; + priv->ra_timeout_source = nm_g_timeout_add_source(timeout_msec, ra_timeout_cb, ndisc); + } + + solicit_timer_start(ndisc); + return; + } + + nm_assert(priv->ra_timeout == 0u); + nm_assert(priv->node_type == NM_NDISC_NODE_TYPE_ROUTER); + announce_router_initial(ndisc); +} + +void +nm_ndisc_stop(NMNDisc *ndisc) +{ + nm_auto_pop_netns NMPNetns *netns = NULL; + NMNDiscDataInternal * rdata; + NMNDiscPrivate * priv; + + g_return_if_fail(NM_IS_NDISC(ndisc)); + + priv = NM_NDISC_GET_PRIVATE(ndisc); + + nm_assert(NM_NDISC_GET_CLASS(ndisc)->stop); + + _LOGD("stopping neighbor discovery for ifindex %d", priv->ifindex); + + if (!nm_ndisc_netns_push(ndisc, &netns)) + return; + + NM_NDISC_GET_CLASS(ndisc)->stop(ndisc); + + rdata = &priv->rdata; + + g_array_set_size(rdata->gateways, 0); + g_array_set_size(rdata->addresses, 0); + g_array_set_size(rdata->routes, 0); + g_array_set_size(rdata->dns_servers, 0); + g_array_set_size(rdata->dns_domains, 0); + priv->rdata.public.hop_limit = 64; + + nm_clear_g_source_inst(&priv->ra_timeout_source); + nm_clear_g_source(&priv->send_ra_id); + nm_clear_g_free(&priv->last_error); + nm_clear_g_source_inst(&priv->timeout_expire_source); + + priv->solicit_retransmit_time_msec = 0; + nm_clear_g_source_inst(&priv->solicit_timer_source); + + priv->announcements_left = 0; + + priv->last_ra = G_MININT32; +} + +NMNDiscConfigMap +nm_ndisc_dad_failed(NMNDisc *ndisc, const struct in6_addr *address, gboolean emit_changed_signal) +{ + NMNDiscDataInternal *rdata; + guint i; + gboolean changed = FALSE; + + rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata; + + for (i = 0; i < rdata->addresses->len;) { + NMNDiscAddress *item = &g_array_index(rdata->addresses, NMNDiscAddress, i); + + if (IN6_ARE_ADDR_EQUAL(&item->address, address)) { + char sbuf[NM_UTILS_INET_ADDRSTRLEN]; + + _LOGD("DAD failed for discovered address %s", _nm_utils_inet6_ntop(address, sbuf)); + changed = TRUE; + if (!complete_address(ndisc, item)) { + g_array_remove_index(rdata->addresses, i); + continue; + } + } + i++; + } + + if (emit_changed_signal && changed) + nm_ndisc_emit_config_change(ndisc, NM_NDISC_CONFIG_ADDRESSES); + + return changed ? NM_NDISC_CONFIG_ADDRESSES : NM_NDISC_CONFIG_NONE; +} + +#define CONFIG_MAP_MAX_STR 7 + +static void +config_map_to_string(NMNDiscConfigMap map, char *p) +{ + if (map & NM_NDISC_CONFIG_DHCP_LEVEL) + *p++ = 'd'; + if (map & NM_NDISC_CONFIG_GATEWAYS) + *p++ = 'G'; + if (map & NM_NDISC_CONFIG_ADDRESSES) + *p++ = 'A'; + if (map & NM_NDISC_CONFIG_ROUTES) + *p++ = 'R'; + if (map & NM_NDISC_CONFIG_DNS_SERVERS) + *p++ = 'S'; + if (map & NM_NDISC_CONFIG_DNS_DOMAINS) + *p++ = 'D'; + *p = '\0'; +} + +static const char * +dhcp_level_to_string(NMNDiscDHCPLevel dhcp_level) +{ + switch (dhcp_level) { + case NM_NDISC_DHCP_LEVEL_NONE: + return "none"; + case NM_NDISC_DHCP_LEVEL_OTHERCONF: + return "otherconf"; + case NM_NDISC_DHCP_LEVEL_MANAGED: + return "managed"; + default: + return "INVALID"; + } +} + +static void +_config_changed_log(NMNDisc *ndisc, NMNDiscConfigMap changed) +{ + NMNDiscPrivate * priv; + NMNDiscDataInternal *rdata; + guint i; + char changedstr[CONFIG_MAP_MAX_STR]; + char addrstr[NM_UTILS_INET_ADDRSTRLEN]; + char str_pref[35]; + char str_exp[100]; + gint64 now_msec; + + if (!_LOGD_ENABLED()) + return; + + now_msec = nm_utils_get_monotonic_timestamp_msec(); + + priv = NM_NDISC_GET_PRIVATE(ndisc); + rdata = &priv->rdata; + + config_map_to_string(changed, changedstr); + _LOGD("neighbor discovery configuration changed [%s]:", changedstr); + _LOGD(" dhcp-level %s", dhcp_level_to_string(priv->rdata.public.dhcp_level)); + + if (rdata->public.hop_limit) + _LOGD(" hop limit : %d", rdata->public.hop_limit); + if (rdata->public.reachable_time_ms) + _LOGD(" reachable time : %u", (guint) rdata->public.reachable_time_ms); + if (rdata->public.retrans_timer_ms) + _LOGD(" retrans timer : %u", (guint) rdata->public.retrans_timer_ms); + + for (i = 0; i < rdata->gateways->len; i++) { + const NMNDiscGateway *gateway = &g_array_index(rdata->gateways, NMNDiscGateway, i); + + _LOGD(" gateway %s pref %s exp %s", + _nm_utils_inet6_ntop(&gateway->address, addrstr), + nm_icmpv6_router_pref_to_string(gateway->preference, str_pref, sizeof(str_pref)), + get_exp(str_exp, now_msec, gateway)); + } + for (i = 0; i < rdata->addresses->len; i++) { + const NMNDiscAddress *address = &g_array_index(rdata->addresses, NMNDiscAddress, i); + + _LOGD(" address %s exp %s", + _nm_utils_inet6_ntop(&address->address, addrstr), + get_exp(str_exp, now_msec, address)); + } + for (i = 0; i < rdata->routes->len; i++) { + const NMNDiscRoute *route = &g_array_index(rdata->routes, NMNDiscRoute, i); + char sbuf[NM_UTILS_INET_ADDRSTRLEN]; + + _LOGD(" route %s/%u via %s pref %s exp %s", + _nm_utils_inet6_ntop(&route->network, addrstr), + (guint) route->plen, + _nm_utils_inet6_ntop(&route->gateway, sbuf), + nm_icmpv6_router_pref_to_string(route->preference, str_pref, sizeof(str_pref)), + get_exp(str_exp, now_msec, route)); + } + for (i = 0; i < rdata->dns_servers->len; i++) { + const NMNDiscDNSServer *dns_server = + &g_array_index(rdata->dns_servers, NMNDiscDNSServer, i); + + _LOGD(" dns_server %s exp %s", + _nm_utils_inet6_ntop(&dns_server->address, addrstr), + get_exp(str_exp, now_msec, dns_server)); + } + for (i = 0; i < rdata->dns_domains->len; i++) { + const NMNDiscDNSDomain *dns_domain = + &g_array_index(rdata->dns_domains, NMNDiscDNSDomain, i); + + _LOGD(" dns_domain %s exp %s", dns_domain->domain, get_exp(str_exp, now_msec, dns_domain)); + } +} + +/*****************************************************************************/ + +static gboolean +_array_set_size_max(GArray *array, guint size_max) +{ + nm_assert(array); + nm_assert(size_max > 0u); + + if (array->len <= size_max) + return FALSE; + + g_array_set_size(array, size_max); + return TRUE; +} + +static void +clean_gateways(NMNDisc *ndisc, gint64 now_msec, NMNDiscConfigMap *changed, gint64 *next_msec) +{ + NMNDiscDataInternal *rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata; + NMNDiscGateway * arr; + guint i; + guint j; + + if (rdata->gateways->len == 0) + return; + + arr = &g_array_index(rdata->gateways, NMNDiscGateway, 0); + + for (i = 0, j = 0; i < rdata->gateways->len; i++) { + if (!expiry_next(now_msec, arr[i].expiry_msec, next_msec)) + continue; + if (i != j) + arr[j] = arr[i]; + j++; + } + + if (i != j) { + *changed |= NM_NDISC_CONFIG_GATEWAYS; + g_array_set_size(rdata->gateways, j); + } + + if (_array_set_size_max(rdata->gateways, _SIZE_MAX_GATEWAYS)) + *changed |= NM_NDISC_CONFIG_GATEWAYS; + + _ASSERT_data_gateways(rdata); +} + +static void +clean_addresses(NMNDisc *ndisc, gint64 now_msec, NMNDiscConfigMap *changed, gint64 *next_msec) +{ + NMNDiscPrivate * priv = NM_NDISC_GET_PRIVATE(ndisc); + NMNDiscDataInternal *rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata; + NMNDiscAddress * arr; + guint i; + guint j; + + if (rdata->addresses->len == 0) + return; + + arr = &g_array_index(rdata->addresses, NMNDiscAddress, 0); + + for (i = 0, j = 0; i < rdata->addresses->len; i++) { + if (!expiry_next(now_msec, arr[i].expiry_msec, next_msec)) + continue; + if (i != j) + arr[j] = arr[i]; + j++; + } + + if (i != j) { + *changed = NM_NDISC_CONFIG_ADDRESSES; + g_array_set_size(rdata->addresses, j); + } + + if (_array_set_size_max(rdata->gateways, priv->max_addresses)) + *changed |= NM_NDISC_CONFIG_ADDRESSES; +} + +static void +clean_routes(NMNDisc *ndisc, gint64 now_msec, NMNDiscConfigMap *changed, gint64 *next_msec) +{ + NMNDiscDataInternal *rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata; + NMNDiscRoute * arr; + guint i; + guint j; + + if (rdata->routes->len == 0) + return; + + arr = &g_array_index(rdata->routes, NMNDiscRoute, 0); + + for (i = 0, j = 0; i < rdata->routes->len; i++) { + if (!expiry_next(now_msec, arr[i].expiry_msec, next_msec)) + continue; + if (i != j) + arr[j] = arr[i]; + j++; + } + + if (i != j) { + *changed |= NM_NDISC_CONFIG_ROUTES; + g_array_set_size(rdata->routes, j); + } + + if (_array_set_size_max(rdata->gateways, _SIZE_MAX_ROUTES)) + *changed |= NM_NDISC_CONFIG_ROUTES; +} + +static void +clean_dns_servers(NMNDisc *ndisc, gint64 now_msec, NMNDiscConfigMap *changed, gint64 *next_msec) +{ + NMNDiscDataInternal *rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata; + NMNDiscDNSServer * arr; + guint i; + guint j; + + if (rdata->dns_servers->len == 0) + return; + + arr = &g_array_index(rdata->dns_servers, NMNDiscDNSServer, 0); + + for (i = 0, j = 0; i < rdata->dns_servers->len; i++) { + if (!expiry_next(now_msec, arr[i].expiry_msec, next_msec)) + continue; + if (i != j) + arr[j] = arr[i]; + j++; + } + + if (i != j) { + *changed |= NM_NDISC_CONFIG_DNS_SERVERS; + g_array_set_size(rdata->dns_servers, j); + } + + if (_array_set_size_max(rdata->gateways, _SIZE_MAX_DNS_SERVERS)) + *changed |= NM_NDISC_CONFIG_DNS_SERVERS; +} + +static void +clean_dns_domains(NMNDisc *ndisc, gint64 now_msec, NMNDiscConfigMap *changed, gint64 *next_msec) +{ + NMNDiscDataInternal *rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata; + NMNDiscDNSDomain * arr; + guint i; + guint j; + + if (rdata->dns_domains->len == 0) + return; + + arr = &g_array_index(rdata->dns_domains, NMNDiscDNSDomain, 0); + + for (i = 0, j = 0; i < rdata->dns_domains->len; i++) { + if (!expiry_next(now_msec, arr[i].expiry_msec, next_msec)) + continue; + + if (i != j) { + g_free(arr[j].domain); + arr[j] = arr[i]; + arr[i].domain = NULL; + } + + j++; + } + + if (i != 0) { + *changed |= NM_NDISC_CONFIG_DNS_DOMAINS; + g_array_set_size(rdata->dns_domains, j); + } + + if (_array_set_size_max(rdata->gateways, _SIZE_MAX_DNS_DOMAINS)) + *changed |= NM_NDISC_CONFIG_DNS_DOMAINS; +} + +static void +check_timestamps(NMNDisc *ndisc, gint64 now_msec, NMNDiscConfigMap changed) +{ + NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(ndisc); + gint64 next_msec = G_MAXINT64; + + _LOGT("router-data: check for changed router advertisement data"); + + clean_gateways(ndisc, now_msec, &changed, &next_msec); + clean_addresses(ndisc, now_msec, &changed, &next_msec); + clean_routes(ndisc, now_msec, &changed, &next_msec); + clean_dns_servers(ndisc, now_msec, &changed, &next_msec); + clean_dns_domains(ndisc, now_msec, &changed, &next_msec); + + nm_assert(next_msec > now_msec); + + nm_clear_g_source_inst(&priv->timeout_expire_source); + + if (next_msec == NM_NDISC_EXPIRY_INFINITY) + _LOGD("router-data: next lifetime expiration will happen: never"); + else { + const gint64 timeout_msec = NM_MIN(next_msec - now_msec, ((gint64) G_MAXINT32)); + const guint TIMEOUT_APPROX_THRESHOLD_SEC = 10000; + + _LOGD("router-data: next lifetime expiration will happen: in %s%.3f seconds", + (timeout_msec / 1000) >= TIMEOUT_APPROX_THRESHOLD_SEC ? " about" : "", + ((double) timeout_msec) / 1000); + + priv->timeout_expire_source = nm_g_timeout_add_source_approx(timeout_msec, + TIMEOUT_APPROX_THRESHOLD_SEC, + timeout_expire_cb, + ndisc); + } + + /* When we receive an RA, we don't disable solicitations entirely. Instead, + * we set the interval the maximum (RFC7559_MRT). + * + * This contradicts https://tools.ietf.org/html/rfc7559#section-2.1, which says + * that we SHOULD stop sending RS if we receive an RA -- but only on a multicast + * capable link and if the RA has a valid router lifetime. + * + * But we really want to recover from a dead router on the network, so we + * don't want to cease sending RS entirely. + * + * But we only re-schedule the timer if the current interval is not already + * "RFC7559_MRT * 1000". Otherwise, we already have a slow interval counter + * pending. */ + if (priv->solicit_retransmit_time_msec != RFC7559_MRT * 1000) { + gint32 timeout_msec; + + priv->solicit_retransmit_time_msec = RFC7559_MRT * 1000; + timeout_msec = solicit_retransmit_time_jitter(priv->solicit_retransmit_time_msec); + + _LOGD("solicit: schedule sending next (slow) solicitation in about %.3f seconds", + ((double) timeout_msec) / 1000); + + nm_clear_g_source_inst(&priv->solicit_timer_source); + priv->solicit_timer_source = + nm_g_timeout_add_source_approx(timeout_msec, 0, solicit_timer_cb, ndisc); + } + + if (changed != NM_NDISC_CONFIG_NONE) + nm_ndisc_emit_config_change(ndisc, changed); +} + +static gboolean +timeout_expire_cb(gpointer user_data) +{ + check_timestamps(user_data, nm_utils_get_monotonic_timestamp_msec(), NM_NDISC_CONFIG_NONE); + return G_SOURCE_CONTINUE; +} + +void +nm_ndisc_ra_received(NMNDisc *ndisc, gint64 now_msec, NMNDiscConfigMap changed) +{ + NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(ndisc); + + nm_clear_g_source_inst(&priv->ra_timeout_source); + nm_clear_g_free(&priv->last_error); + check_timestamps(ndisc, now_msec, changed); +} + +void +nm_ndisc_rs_received(NMNDisc *ndisc) +{ + NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(ndisc); + + nm_clear_g_free(&priv->last_error); + announce_router_solicited(ndisc); +} + +/*****************************************************************************/ + +static void +dns_domain_free(gpointer data) +{ + g_free(((NMNDiscDNSDomain *) (data))->domain); +} + +static void +set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) +{ + NMNDisc * self = NM_NDISC(object); + NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(self); + int i; + + switch (prop_id) { + case PROP_PLATFORM: + /* construct-only */ + priv->platform = g_value_get_object(value) ?: NM_PLATFORM_GET; + if (!priv->platform) + g_return_if_reached(); + + g_object_ref(priv->platform); + + priv->netns = nm_platform_netns_get(priv->platform); + if (priv->netns) + g_object_ref(priv->netns); + + g_return_if_fail(!priv->netns || priv->netns == nmp_netns_get_current()); + break; + case PROP_IFINDEX: + /* construct-only */ + priv->ifindex = g_value_get_int(value); + g_return_if_fail(priv->ifindex > 0); + break; + case PROP_IFNAME: + /* construct-only */ + priv->ifname = g_value_dup_string(value); + g_return_if_fail(priv->ifname && priv->ifname[0]); + break; + case PROP_STABLE_TYPE: + /* construct-only */ + priv->stable_type = g_value_get_int(value); + break; + case PROP_NETWORK_ID: + /* construct-only */ + priv->network_id = g_value_dup_string(value); + g_return_if_fail(priv->network_id); + break; + case PROP_ADDR_GEN_MODE: + /* construct-only */ + priv->addr_gen_mode = g_value_get_int(value); + break; + case PROP_MAX_ADDRESSES: + /* construct-only */ + i = g_value_get_int(value); + nm_assert(i >= 0); + priv->max_addresses = i; + + if (priv->max_addresses <= 0) + priv->max_addresses = _SIZE_MAX_ADDRESSES; + else if (priv->max_addresses > 3u * _SIZE_MAX_ADDRESSES) + priv->max_addresses = 3u * _SIZE_MAX_ADDRESSES; + break; + case PROP_RA_TIMEOUT: + /* construct-only */ + priv->ra_timeout = g_value_get_uint(value); + nm_assert(priv->ra_timeout <= NM_RA_TIMEOUT_INFINITY); + break; + case PROP_ROUTER_SOLICITATIONS: + /* construct-only */ + priv->router_solicitations = g_value_get_int(value); + break; + case PROP_ROUTER_SOLICITATION_INTERVAL: + /* construct-only */ + priv->router_solicitation_interval = g_value_get_int(value); + break; + case PROP_NODE_TYPE: + /* construct-only */ + priv->node_type = g_value_get_int(value); + nm_assert(NM_IN_SET(priv->node_type, NM_NDISC_NODE_TYPE_HOST, NM_NDISC_NODE_TYPE_ROUTER)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); + break; + } +} + +static void +nm_ndisc_init(NMNDisc *ndisc) +{ + NMNDiscPrivate * priv; + NMNDiscDataInternal *rdata; + + priv = G_TYPE_INSTANCE_GET_PRIVATE(ndisc, NM_TYPE_NDISC, NMNDiscPrivate); + ndisc->_priv = priv; + + rdata = &priv->rdata; + + rdata->gateways = g_array_new(FALSE, FALSE, sizeof(NMNDiscGateway)); + rdata->addresses = g_array_new(FALSE, FALSE, sizeof(NMNDiscAddress)); + rdata->routes = g_array_new(FALSE, FALSE, sizeof(NMNDiscRoute)); + rdata->dns_servers = g_array_new(FALSE, FALSE, sizeof(NMNDiscDNSServer)); + rdata->dns_domains = g_array_new(FALSE, FALSE, sizeof(NMNDiscDNSDomain)); + g_array_set_clear_func(rdata->dns_domains, dns_domain_free); + priv->rdata.public.hop_limit = 64; +} + +static void +dispose(GObject *object) +{ + NMNDisc * ndisc = NM_NDISC(object); + NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(ndisc); + + nm_clear_g_source_inst(&priv->ra_timeout_source); + nm_clear_g_source_inst(&priv->solicit_timer_source); + nm_clear_g_source(&priv->send_ra_id); + nm_clear_g_free(&priv->last_error); + + nm_clear_g_source_inst(&priv->timeout_expire_source); + + G_OBJECT_CLASS(nm_ndisc_parent_class)->dispose(object); +} + +static void +finalize(GObject *object) +{ + NMNDisc * ndisc = NM_NDISC(object); + NMNDiscPrivate * priv = NM_NDISC_GET_PRIVATE(ndisc); + NMNDiscDataInternal *rdata = &priv->rdata; + + g_free(priv->ifname); + g_free(priv->network_id); + + g_array_unref(rdata->gateways); + g_array_unref(rdata->addresses); + g_array_unref(rdata->routes); + g_array_unref(rdata->dns_servers); + g_array_unref(rdata->dns_domains); + + g_clear_object(&priv->netns); + g_clear_object(&priv->platform); + + G_OBJECT_CLASS(nm_ndisc_parent_class)->finalize(object); +} + +static void +nm_ndisc_class_init(NMNDiscClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS(klass); + + g_type_class_add_private(klass, sizeof(NMNDiscPrivate)); + + object_class->set_property = set_property; + object_class->dispose = dispose; + object_class->finalize = finalize; + + obj_properties[PROP_PLATFORM] = + g_param_spec_object(NM_NDISC_PLATFORM, + "", + "", + NM_TYPE_PLATFORM, + G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + obj_properties[PROP_IFINDEX] = + g_param_spec_int(NM_NDISC_IFINDEX, + "", + "", + 0, + G_MAXINT, + 0, + G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + obj_properties[PROP_IFNAME] = + g_param_spec_string(NM_NDISC_IFNAME, + "", + "", + NULL, + G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + obj_properties[PROP_STABLE_TYPE] = + g_param_spec_int(NM_NDISC_STABLE_TYPE, + "", + "", + NM_UTILS_STABLE_TYPE_UUID, + NM_UTILS_STABLE_TYPE_RANDOM, + NM_UTILS_STABLE_TYPE_UUID, + G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + obj_properties[PROP_NETWORK_ID] = + g_param_spec_string(NM_NDISC_NETWORK_ID, + "", + "", + NULL, + G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + obj_properties[PROP_ADDR_GEN_MODE] = + g_param_spec_int(NM_NDISC_ADDR_GEN_MODE, + "", + "", + NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64, + NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY, + NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64, + G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + obj_properties[PROP_MAX_ADDRESSES] = + g_param_spec_int(NM_NDISC_MAX_ADDRESSES, + "", + "", + 0, + G_MAXINT32, + NM_NDISC_MAX_ADDRESSES_DEFAULT, + G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + G_STATIC_ASSERT_EXPR(G_MAXINT32 == NM_RA_TIMEOUT_INFINITY); + obj_properties[PROP_RA_TIMEOUT] = + g_param_spec_uint(NM_NDISC_RA_TIMEOUT, + "", + "", + 0, + G_MAXINT32, + 0, + G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + obj_properties[PROP_ROUTER_SOLICITATIONS] = + g_param_spec_int(NM_NDISC_ROUTER_SOLICITATIONS, + "", + "", + 1, + G_MAXINT32, + NM_NDISC_ROUTER_SOLICITATIONS_DEFAULT, + G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + obj_properties[PROP_ROUTER_SOLICITATION_INTERVAL] = + g_param_spec_int(NM_NDISC_ROUTER_SOLICITATION_INTERVAL, + "", + "", + 1, + G_MAXINT32, + NM_NDISC_RFC4861_RTR_SOLICITATION_INTERVAL, + G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + obj_properties[PROP_NODE_TYPE] = + g_param_spec_int(NM_NDISC_NODE_TYPE, + "", + "", + NM_NDISC_NODE_TYPE_INVALID, + NM_NDISC_NODE_TYPE_ROUTER, + NM_NDISC_NODE_TYPE_INVALID, + G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties); + + signals[CONFIG_RECEIVED] = g_signal_new(NM_NDISC_CONFIG_RECEIVED, + G_OBJECT_CLASS_TYPE(klass), + G_SIGNAL_RUN_FIRST, + 0, + NULL, + NULL, + NULL, + G_TYPE_NONE, + 2, + G_TYPE_POINTER, + G_TYPE_UINT); + signals[RA_TIMEOUT_SIGNAL] = g_signal_new(NM_NDISC_RA_TIMEOUT_SIGNAL, + G_OBJECT_CLASS_TYPE(klass), + G_SIGNAL_RUN_FIRST, + 0, + NULL, + NULL, + NULL, + G_TYPE_NONE, + 0); +} diff --git a/src/core/ndisc/nm-ndisc.h b/src/core/ndisc/nm-ndisc.h new file mode 100644 index 00000000..93aee4db --- /dev/null +++ b/src/core/ndisc/nm-ndisc.h @@ -0,0 +1,278 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2013 Red Hat, Inc. + */ + +#ifndef __NETWORKMANAGER_NDISC_H__ +#define __NETWORKMANAGER_NDISC_H__ + +#include <stdlib.h> +#include <netinet/in.h> +#include <linux/if_addr.h> + +#include "nm-setting-ip6-config.h" +#include "NetworkManagerUtils.h" + +#include "platform/nm-platform.h" +#include "platform/nmp-object.h" + +#define NM_RA_TIMEOUT_DEFAULT ((guint32) 0) +#define NM_RA_TIMEOUT_INFINITY ((guint32) G_MAXINT32) + +#define NM_TYPE_NDISC (nm_ndisc_get_type()) +#define NM_NDISC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_NDISC, NMNDisc)) +#define NM_NDISC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_NDISC, NMNDiscClass)) +#define NM_IS_NDISC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_NDISC)) +#define NM_IS_NDISC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_NDISC)) +#define NM_NDISC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_NDISC, NMNDiscClass)) + +#define NM_NDISC_PLATFORM "platform" +#define NM_NDISC_IFINDEX "ifindex" +#define NM_NDISC_IFNAME "ifname" +#define NM_NDISC_NETWORK_ID "network-id" +#define NM_NDISC_ADDR_GEN_MODE "addr-gen-mode" +#define NM_NDISC_STABLE_TYPE "stable-type" +#define NM_NDISC_NODE_TYPE "node-type" +#define NM_NDISC_MAX_ADDRESSES "max-addresses" +#define NM_NDISC_RA_TIMEOUT "ra-timeout" +#define NM_NDISC_ROUTER_SOLICITATIONS "router-solicitations" +#define NM_NDISC_ROUTER_SOLICITATION_INTERVAL "router-solicitation-interval" + +#define NM_NDISC_CONFIG_RECEIVED "config-received" +#define NM_NDISC_RA_TIMEOUT_SIGNAL "ra-timeout-signal" + +typedef enum { + NM_NDISC_DHCP_LEVEL_UNKNOWN, + NM_NDISC_DHCP_LEVEL_NONE, + NM_NDISC_DHCP_LEVEL_OTHERCONF, + NM_NDISC_DHCP_LEVEL_MANAGED +} NMNDiscDHCPLevel; + +#define NM_NDISC_INFINITY_U32 ((uint32_t) -1) + +/* It's important that this is G_MAXINT64, so that we can meaningfully do + * MIN(e1, e2) to find the minimum expiry time (and properly handle if any + * of them is infinity). + * + * While usually you assign this to "expiry_msec", you might say the + * unit of it is milliseconds. But of course, infinity has not really a unit. */ +#define NM_NDISC_EXPIRY_INFINITY G_MAXINT64 + +/* in common cases, the expiry_msec tracks the timestamp in nm_utils_get_monotonic_timestamp_mses() + * timestamp when the item expires. + * + * When we configure an NMNDiscAddress to be announced via the router advertisement, + * then that address does not have a fixed expiry point in time, instead, the expiry + * really contains the lifetime from the moment when we send the router advertisement. + * In that case, the expiry_msec is more a "lifetime" that starts counting at timestamp + * zero. + * + * The unit is milliseconds (but of course, the timestamp is zero, so it doesn't really matter). */ +#define NM_NDISC_EXPIRY_BASE_TIMESTAMP ((gint64) 0) + +static inline gint64 +_nm_ndisc_lifetime_to_expiry(gint64 now_msec, guint32 lifetime) +{ + if (lifetime == NM_NDISC_INFINITY_U32) + return NM_NDISC_EXPIRY_INFINITY; + return now_msec + (((gint64) lifetime) * 1000); +} + +static inline gint64 +_nm_ndisc_lifetime_from_expiry(gint64 now_msec, gint64 expiry_msec, gboolean ceil) +{ + gint64 diff; + + if (expiry_msec == NM_NDISC_EXPIRY_INFINITY) + return NM_NDISC_INFINITY_U32; + + /* we don't expect nor handle integer overflow. The time stamp and expiry + * should be reasonably small so that it cannot happen. */ + + diff = expiry_msec - now_msec; + + if (diff <= 0) + return 0; + + if (ceil) { + /* we ceil() towards the next full second (instead of floor()). */ + diff += 999; + } + + return NM_MIN(diff / 1000, (gint64)(G_MAXUINT32 - 1)); +} + +/*****************************************************************************/ + +typedef struct _NMNDiscGateway { + struct in6_addr address; + gint64 expiry_msec; + NMIcmpv6RouterPref preference; +} NMNDiscGateway; + +typedef struct _NMNDiscAddress { + struct in6_addr address; + gint64 expiry_msec; + gint64 expiry_preferred_msec; + guint8 dad_counter; +} NMNDiscAddress; + +typedef struct _NMNDiscRoute { + struct in6_addr network; + struct in6_addr gateway; + gint64 expiry_msec; + NMIcmpv6RouterPref preference; + guint8 plen; +} NMNDiscRoute; + +typedef struct { + struct in6_addr address; + gint64 expiry_msec; +} NMNDiscDNSServer; + +typedef struct { + char * domain; + gint64 expiry_msec; +} NMNDiscDNSDomain; + +typedef enum { + NM_NDISC_CONFIG_NONE = 0, + NM_NDISC_CONFIG_DHCP_LEVEL = 1 << 0, + NM_NDISC_CONFIG_GATEWAYS = 1 << 1, + NM_NDISC_CONFIG_ADDRESSES = 1 << 2, + NM_NDISC_CONFIG_ROUTES = 1 << 3, + NM_NDISC_CONFIG_DNS_SERVERS = 1 << 4, + NM_NDISC_CONFIG_DNS_DOMAINS = 1 << 5, + NM_NDISC_CONFIG_HOP_LIMIT = 1 << 6, + NM_NDISC_CONFIG_MTU = 1 << 7, + NM_NDISC_CONFIG_REACHABLE_TIME = 1 << 8, + NM_NDISC_CONFIG_RETRANS_TIMER = 1 << 9, +} NMNDiscConfigMap; + +typedef enum { + NM_NDISC_NODE_TYPE_INVALID, + NM_NDISC_NODE_TYPE_HOST, + NM_NDISC_NODE_TYPE_ROUTER, +} NMNDiscNodeType; + +#define NM_NDISC_RFC4861_RTR_SOLICITATION_INTERVAL 4 /* seconds */ +#define NM_NDISC_RFC4861_MAX_RTR_SOLICITATION_DELAY 1 /* seconds */ + +#define NM_NDISC_MAX_ADDRESSES_DEFAULT 16 +#define NM_NDISC_ROUTER_SOLICITATIONS_DEFAULT 3 /* RFC4861, MAX_RTR_SOLICITATIONS */ +#define NM_NDISC_ROUTER_ADVERTISEMENTS_DEFAULT 3 /* RFC4861, MAX_INITIAL_RTR_ADVERTISEMENTS */ +#define NM_NDISC_ROUTER_ADVERT_DELAY 3 /* RFC4861, MIN_DELAY_BETWEEN_RAS */ +#define NM_NDISC_ROUTER_ADVERT_INITIAL_INTERVAL 16 /* RFC4861, MAX_INITIAL_RTR_ADVERT_INTERVAL */ +#define NM_NDISC_ROUTER_ADVERT_DELAY_MS 500 /* RFC4861, MAX_RA_DELAY_TIME */ +#define NM_NDISC_ROUTER_ADVERT_MAX_INTERVAL 600 /* RFC4861, MaxRtrAdvInterval default */ +#define NM_NDISC_ROUTER_LIFETIME 900 /* 1.5 * NM_NDISC_ROUTER_ADVERT_MAX_INTERVAL */ + +struct _NMNDiscPrivate; +struct _NMNDiscDataInternal; + +typedef struct { + NMNDiscDHCPLevel dhcp_level; + guint32 mtu; + int hop_limit; + guint32 reachable_time_ms; + guint32 retrans_timer_ms; + + guint gateways_n; + guint addresses_n; + guint routes_n; + guint dns_servers_n; + guint dns_domains_n; + + const NMNDiscGateway * gateways; + const NMNDiscAddress * addresses; + const NMNDiscRoute * routes; + const NMNDiscDNSServer *dns_servers; + const NMNDiscDNSDomain *dns_domains; +} NMNDiscData; + +/** + * NMNDisc: + * + * Interface-specific structure that handles incoming router advertisements, + * caches advertised items and removes them when they are obsolete. + */ +typedef struct { + GObject parent; + union { + struct _NMNDiscPrivate * _priv; + struct _NMNDiscDataInternal *rdata; + }; +} NMNDisc; + +typedef struct { + GObjectClass parent; + + void (*start)(NMNDisc *ndisc); + void (*stop)(NMNDisc *ndisc); + gboolean (*send_rs)(NMNDisc *ndisc, GError **error); + gboolean (*send_ra)(NMNDisc *ndisc, GError **error); +} NMNDiscClass; + +GType nm_ndisc_get_type(void); + +void nm_ndisc_emit_config_change(NMNDisc *self, NMNDiscConfigMap changed); + +int nm_ndisc_get_ifindex(NMNDisc *self); +const char * nm_ndisc_get_ifname(NMNDisc *self); +NMNDiscNodeType nm_ndisc_get_node_type(NMNDisc *self); + +gboolean nm_ndisc_set_iid(NMNDisc *ndisc, const NMUtilsIPv6IfaceId iid); +void nm_ndisc_start(NMNDisc *ndisc); +void nm_ndisc_stop(NMNDisc *ndisc); +NMNDiscConfigMap +nm_ndisc_dad_failed(NMNDisc *ndisc, const struct in6_addr *address, gboolean emit_changed_signal); +void nm_ndisc_set_config(NMNDisc * ndisc, + const GArray *addresses, + const GArray *dns_servers, + const GArray *dns_domains); + +NMPlatform *nm_ndisc_get_platform(NMNDisc *self); +NMPNetns * nm_ndisc_netns_get(NMNDisc *self); +gboolean nm_ndisc_netns_push(NMNDisc *self, NMPNetns **netns); + +static inline gboolean +nm_ndisc_dad_addr_is_fail_candidate_event(NMPlatformSignalChangeType change_type, + const NMPlatformIP6Address *addr) +{ + return !NM_FLAGS_HAS(addr->n_ifa_flags, IFA_F_TEMPORARY) + && ((change_type == NM_PLATFORM_SIGNAL_CHANGED && addr->n_ifa_flags & IFA_F_DADFAILED) + || (change_type == NM_PLATFORM_SIGNAL_REMOVED + && addr->n_ifa_flags & IFA_F_TENTATIVE)); +} + +static inline gboolean +nm_ndisc_dad_addr_is_fail_candidate(NMPlatform *platform, const NMPObject *obj) +{ + const NMPlatformIP6Address *addr; + + addr = NMP_OBJECT_CAST_IP6_ADDRESS( + nm_platform_lookup_obj(platform, NMP_CACHE_ID_TYPE_OBJECT_TYPE, obj)); + if (addr + && (NM_FLAGS_HAS(addr->n_ifa_flags, IFA_F_TEMPORARY) + || !NM_FLAGS_HAS(addr->n_ifa_flags, IFA_F_DADFAILED))) { + /* the address still/again exists and is not in DADFAILED state. Skip it. */ + return FALSE; + } + + return TRUE; +} + +/*****************************************************************************/ + +struct _NML3ConfigData; + +struct _NML3ConfigData *nm_ndisc_data_to_l3cd(NMDedupMultiIndex * multi_idx, + int ifindex, + const NMNDiscData * rdata, + NMSettingIP6ConfigPrivacy ip6_privacy, + guint32 route_table, + guint32 route_metric, + gboolean kernel_support_rta_pref, + gboolean kernel_support_extended_ifa_flags); + +#endif /* __NETWORKMANAGER_NDISC_H__ */ diff --git a/src/core/ndisc/tests/meson.build b/src/core/ndisc/tests/meson.build new file mode 100644 index 00000000..6a2e70f0 --- /dev/null +++ b/src/core/ndisc/tests/meson.build @@ -0,0 +1,26 @@ +# SPDX-License-Identifier: LGPL-2.1-or-later + +test_unit = 'test-ndisc-fake' + +exe = executable( + test_unit, + test_unit + '.c', + dependencies: libNetworkManagerTest_dep, + c_args: test_c_flags, +) + +test( + 'ndisc/' + test_unit, + test_script, + args: test_args + [exe.full_path()], + timeout: default_test_timeout, +) + +test = 'test-ndisc-linux' + +exe = executable( + test, + test + '.c', + dependencies: libNetworkManagerTest_dep, + c_args: test_c_flags, +) diff --git a/src/core/ndisc/tests/test-ndisc-fake.c b/src/core/ndisc/tests/test-ndisc-fake.c new file mode 100644 index 00000000..f201bc56 --- /dev/null +++ b/src/core/ndisc/tests/test-ndisc-fake.c @@ -0,0 +1,657 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2015 Red Hat, Inc. + */ + +#include "src/core/nm-default-daemon.h" + +#include <syslog.h> + +#include "ndisc/nm-ndisc.h" +#include "ndisc/nm-fake-ndisc.h" + +#include "platform/nm-fake-platform.h" + +#include "nm-test-utils-core.h" + +/*****************************************************************************/ + +static NMFakeNDisc * +ndisc_new(void) +{ + NMNDisc * ndisc; + const int ifindex = 1; + const char * ifname = nm_platform_link_get_name(NM_PLATFORM_GET, ifindex); + NMUtilsIPv6IfaceId iid = {}; + + ndisc = nm_fake_ndisc_new(ifindex, ifname); + iid.id_u8[7] = 1; + nm_ndisc_set_iid(ndisc, iid); + g_assert(ndisc); + + return NM_FAKE_NDISC(ndisc); +} + +/*****************************************************************************/ + +static void +match_gateway(const NMNDiscData *rdata, + guint idx, + const char * addr, + gint64 expiry_msec, + NMIcmpv6RouterPref pref) +{ + const NMNDiscGateway *gw; + + g_assert(rdata); + g_assert_cmpint(idx, <, rdata->gateways_n); + g_assert(rdata->gateways); + + gw = &rdata->gateways[idx]; + + nmtst_assert_ip6_address(&gw->address, addr); + g_assert_cmpint(gw->expiry_msec, ==, expiry_msec); + g_assert_cmpint(gw->preference, ==, pref); +} + +#define match_address(rdata, idx, addr, _expiry_msec, _expiry_preferred_msec) \ + G_STMT_START \ + { \ + const NMNDiscData * _rdata = (rdata); \ + guint _idx = (idx); \ + const NMNDiscAddress *_a; \ + \ + g_assert(_rdata); \ + g_assert_cmpint(_idx, <, _rdata->addresses_n); \ + g_assert(_rdata->addresses); \ + \ + _a = &_rdata->addresses[_idx]; \ + \ + nmtst_assert_ip6_address(&_a->address, (addr)); \ + g_assert_cmpint(_a->expiry_msec, ==, (_expiry_msec)); \ + g_assert_cmpint(_a->expiry_preferred_msec, ==, (_expiry_preferred_msec)); \ + } \ + G_STMT_END + +#define match_route(rdata, idx, nw, pl, gw, _expiry_msec, pref) \ + G_STMT_START \ + { \ + const NMNDiscData * _rdata = (rdata); \ + guint _idx = (idx); \ + const NMNDiscRoute *_r; \ + int _plen = (pl); \ + \ + g_assert(_rdata); \ + g_assert_cmpint(_idx, <, _rdata->routes_n); \ + g_assert(_rdata->routes); \ + g_assert(_plen > 0 && _plen <= 128); \ + \ + _r = &_rdata->routes[idx]; \ + \ + nmtst_assert_ip6_address(&_r->network, (nw)); \ + g_assert_cmpint((int) _r->plen, ==, _plen); \ + nmtst_assert_ip6_address(&_r->gateway, (gw)); \ + g_assert_cmpint(_r->expiry_msec, ==, (_expiry_msec)); \ + g_assert_cmpint(_r->preference, ==, (pref)); \ + } \ + G_STMT_END + +static void +match_dns_server(const NMNDiscData *rdata, guint idx, const char *addr, gint64 expiry_msec) +{ + const NMNDiscDNSServer *dns; + + g_assert(rdata); + g_assert_cmpint(idx, <, rdata->dns_servers_n); + g_assert(rdata->dns_servers); + + dns = &rdata->dns_servers[idx]; + + nmtst_assert_ip6_address(&dns->address, addr); + g_assert_cmpint(dns->expiry_msec, ==, expiry_msec); +} + +static void +match_dns_domain(const NMNDiscData *rdata, guint idx, const char *domain, gint64 expiry_msec) +{ + const NMNDiscDNSDomain *dns; + + g_assert(rdata); + g_assert_cmpint(idx, <, rdata->dns_domains_n); + g_assert(rdata->dns_domains); + + dns = &rdata->dns_domains[idx]; + + g_assert_cmpstr(dns->domain, ==, domain); + g_assert_cmpint(dns->expiry_msec, ==, expiry_msec); +} + +/*****************************************************************************/ + +typedef struct { + GMainLoop *loop; + gint64 timestamp_msec_1; + guint counter; + guint rs_counter; + gint64 first_solicit_msec; + guint32 timeout_id; +} TestData; + +/*****************************************************************************/ + +static void +test_simple_changed(NMNDisc *ndisc, const NMNDiscData *rdata, guint changed_int, TestData *data) +{ + NMNDiscConfigMap changed = changed_int; + + switch (data->counter++) { + case 0: + g_assert_cmpint(changed, + ==, + NM_NDISC_CONFIG_DHCP_LEVEL | NM_NDISC_CONFIG_GATEWAYS + | NM_NDISC_CONFIG_ADDRESSES | NM_NDISC_CONFIG_ROUTES + | NM_NDISC_CONFIG_DNS_SERVERS | NM_NDISC_CONFIG_DNS_DOMAINS + | NM_NDISC_CONFIG_HOP_LIMIT | NM_NDISC_CONFIG_MTU); + g_assert_cmpint(rdata->dhcp_level, ==, NM_NDISC_DHCP_LEVEL_OTHERCONF); + match_gateway(rdata, + 0, + "fe80::1", + data->timestamp_msec_1 + 10000, + NM_ICMPV6_ROUTER_PREF_MEDIUM); + match_address(rdata, + 0, + "2001:db8:a:a::1", + data->timestamp_msec_1 + 10000, + data->timestamp_msec_1 + 10000); + match_route(rdata, 0, "2001:db8:a:a::", 64, "fe80::1", data->timestamp_msec_1 + 10000, 10); + match_dns_server(rdata, 0, "2001:db8:c:c::1", data->timestamp_msec_1 + 10000); + match_dns_domain(rdata, 0, "foobar.com", data->timestamp_msec_1 + 3500); + + g_assert(nm_fake_ndisc_done(NM_FAKE_NDISC(ndisc))); + break; + case 1: + g_main_loop_quit(data->loop); + break; + default: + g_assert_not_reached(); + } +} + +static void +test_simple(void) +{ + nm_auto_unref_gmainloop GMainLoop *loop = g_main_loop_new(NULL, FALSE); + gs_unref_object NMFakeNDisc *ndisc = ndisc_new(); + const gint64 now_msec = nm_utils_get_monotonic_timestamp_msec(); + TestData data = { + .loop = loop, + .timestamp_msec_1 = now_msec, + }; + guint id; + + id = nm_fake_ndisc_add_ra(ndisc, 1, NM_NDISC_DHCP_LEVEL_OTHERCONF, 4, 1500); + g_assert(id); + + nm_fake_ndisc_add_gateway(ndisc, id, "fe80::1", now_msec + 10000, NM_ICMPV6_ROUTER_PREF_MEDIUM); + nm_fake_ndisc_add_prefix(ndisc, + id, + "2001:db8:a:a::", + 64, + "fe80::1", + now_msec + 10000, + now_msec + 10000, + 10); + nm_fake_ndisc_add_dns_server(ndisc, id, "2001:db8:c:c::1", now_msec + 10000); + nm_fake_ndisc_add_dns_domain(ndisc, id, "foobar.com", now_msec + 3500); + + g_signal_connect(ndisc, NM_NDISC_CONFIG_RECEIVED, G_CALLBACK(test_simple_changed), &data); + + nm_ndisc_start(NM_NDISC(ndisc)); + nmtst_main_loop_run_assert(data.loop, 15000); + g_assert_cmpint(data.counter, ==, 2); +} + +/*****************************************************************************/ + +static void +test_everything_rs_sent(NMNDisc *ndisc, TestData *data) +{ + g_assert_cmpint(data->rs_counter, ==, 0); + data->rs_counter++; +} + +static void +test_everything_changed(NMNDisc *ndisc, const NMNDiscData *rdata, guint changed_int, TestData *data) +{ + NMNDiscConfigMap changed = changed_int; + + if (data->counter == 0) { + g_assert_cmpint(data->rs_counter, ==, 1); + g_assert_cmpint(changed, + ==, + NM_NDISC_CONFIG_DHCP_LEVEL | NM_NDISC_CONFIG_GATEWAYS + | NM_NDISC_CONFIG_ADDRESSES | NM_NDISC_CONFIG_ROUTES + | NM_NDISC_CONFIG_DNS_SERVERS | NM_NDISC_CONFIG_DNS_DOMAINS + | NM_NDISC_CONFIG_HOP_LIMIT | NM_NDISC_CONFIG_MTU); + match_gateway(rdata, + 0, + "fe80::1", + data->timestamp_msec_1 + 10000, + NM_ICMPV6_ROUTER_PREF_MEDIUM); + match_address(rdata, + 0, + "2001:db8:a:a::1", + data->timestamp_msec_1 + 10000, + data->timestamp_msec_1 + 10000); + match_route(rdata, 0, "2001:db8:a:a::", 64, "fe80::1", data->timestamp_msec_1 + 10000, 10); + match_dns_server(rdata, 0, "2001:db8:c:c::1", data->timestamp_msec_1 + 10000); + match_dns_domain(rdata, 0, "foobar.com", data->timestamp_msec_1 + 10000); + } else if (data->counter == 1) { + g_assert_cmpint(changed, + ==, + NM_NDISC_CONFIG_GATEWAYS | NM_NDISC_CONFIG_ADDRESSES + | NM_NDISC_CONFIG_ROUTES | NM_NDISC_CONFIG_DNS_SERVERS + | NM_NDISC_CONFIG_DNS_DOMAINS); + + g_assert_cmpint(rdata->gateways_n, ==, 1); + match_gateway(rdata, + 0, + "fe80::2", + data->timestamp_msec_1 + 10000, + NM_ICMPV6_ROUTER_PREF_MEDIUM); + g_assert_cmpint(rdata->addresses_n, ==, 2); + match_address(rdata, + 0, + "2001:db8:a:a::1", + data->timestamp_msec_1 + 10000, + data->timestamp_msec_1); + match_address(rdata, + 1, + "2001:db8:a:b::1", + data->timestamp_msec_1 + 10000, + data->timestamp_msec_1 + 10000); + g_assert_cmpint(rdata->routes_n, ==, 1); + match_route(rdata, 0, "2001:db8:a:b::", 64, "fe80::2", data->timestamp_msec_1 + 10000, 10); + g_assert_cmpint(rdata->dns_servers_n, ==, 1); + match_dns_server(rdata, 0, "2001:db8:c:c::2", data->timestamp_msec_1 + 10000); + g_assert_cmpint(rdata->dns_domains_n, ==, 1); + match_dns_domain(rdata, 0, "foobar2.com", data->timestamp_msec_1 + 10000); + + g_assert(nm_fake_ndisc_done(NM_FAKE_NDISC(ndisc))); + g_main_loop_quit(data->loop); + } else + g_assert_not_reached(); + + data->counter++; +} + +static void +test_everything(void) +{ + nm_auto_unref_gmainloop GMainLoop *loop = g_main_loop_new(NULL, FALSE); + gs_unref_object NMFakeNDisc *ndisc = ndisc_new(); + const gint64 now_msec = nm_utils_get_monotonic_timestamp_msec(); + TestData data = { + .loop = loop, + .timestamp_msec_1 = now_msec, + }; + guint id; + + id = nm_fake_ndisc_add_ra(ndisc, 1, NM_NDISC_DHCP_LEVEL_NONE, 4, 1500); + g_assert(id); + nm_fake_ndisc_add_gateway(ndisc, id, "fe80::1", now_msec + 10000, NM_ICMPV6_ROUTER_PREF_MEDIUM); + nm_fake_ndisc_add_prefix(ndisc, + id, + "2001:db8:a:a::", + 64, + "fe80::1", + now_msec + 10000, + now_msec + 10000, + 10); + nm_fake_ndisc_add_dns_server(ndisc, id, "2001:db8:c:c::1", now_msec + 10000); + nm_fake_ndisc_add_dns_domain(ndisc, id, "foobar.com", now_msec + 10000); + + /* expire everything from the first RA in the second */ + id = nm_fake_ndisc_add_ra(ndisc, 1, NM_NDISC_DHCP_LEVEL_NONE, 4, 1500); + g_assert(id); + nm_fake_ndisc_add_gateway(ndisc, id, "fe80::1", now_msec, NM_ICMPV6_ROUTER_PREF_MEDIUM); + nm_fake_ndisc_add_prefix(ndisc, id, "2001:db8:a:a::", 64, "fe80::1", now_msec, now_msec, 0); + nm_fake_ndisc_add_dns_server(ndisc, id, "2001:db8:c:c::1", now_msec); + nm_fake_ndisc_add_dns_domain(ndisc, id, "foobar.com", now_msec); + + /* and add some new stuff */ + nm_fake_ndisc_add_gateway(ndisc, id, "fe80::2", now_msec + 10000, NM_ICMPV6_ROUTER_PREF_MEDIUM); + nm_fake_ndisc_add_prefix(ndisc, + id, + "2001:db8:a:b::", + 64, + "fe80::2", + now_msec + 10000, + now_msec + 10000, + 10); + nm_fake_ndisc_add_dns_server(ndisc, id, "2001:db8:c:c::2", now_msec + 10000); + nm_fake_ndisc_add_dns_domain(ndisc, id, "foobar2.com", now_msec + 10000); + + g_signal_connect(ndisc, NM_NDISC_CONFIG_RECEIVED, G_CALLBACK(test_everything_changed), &data); + g_signal_connect(ndisc, NM_FAKE_NDISC_RS_SENT, G_CALLBACK(test_everything_rs_sent), &data); + + nm_ndisc_start(NM_NDISC(ndisc)); + nmtst_main_loop_run_assert(data.loop, 15000); + g_assert_cmpint(data.counter, ==, 2); + g_assert_cmpint(data.rs_counter, ==, 1); +} + +static void +test_preference_order_cb(NMNDisc * ndisc, + const NMNDiscData *rdata, + guint changed_int, + TestData * data) +{ + NMNDiscConfigMap changed = changed_int; + + if (data->counter == 1) { + g_assert_cmpint(changed, + ==, + NM_NDISC_CONFIG_GATEWAYS | NM_NDISC_CONFIG_ADDRESSES + | NM_NDISC_CONFIG_ROUTES); + + g_assert_cmpint(rdata->gateways_n, ==, 2); + match_gateway(rdata, + 0, + "fe80::1", + data->timestamp_msec_1 + 10000, + NM_ICMPV6_ROUTER_PREF_HIGH); + match_gateway(rdata, + 1, + "fe80::2", + data->timestamp_msec_1 + 11000, + NM_ICMPV6_ROUTER_PREF_LOW); + g_assert_cmpint(rdata->addresses_n, ==, 2); + match_address(rdata, + 0, + "2001:db8:a:a::1", + data->timestamp_msec_1 + 10000, + data->timestamp_msec_1 + 10000); + match_address(rdata, + 1, + "2001:db8:a:b::1", + data->timestamp_msec_1 + 11000, + data->timestamp_msec_1 + 10000); + g_assert_cmpint(rdata->routes_n, ==, 2); + match_route(rdata, 0, "2001:db8:a:b::", 64, "fe80::2", data->timestamp_msec_1 + 11000, 10); + match_route(rdata, 1, "2001:db8:a:a::", 64, "fe80::1", data->timestamp_msec_1 + 10000, 5); + + g_assert(nm_fake_ndisc_done(NM_FAKE_NDISC(ndisc))); + g_main_loop_quit(data->loop); + } + + data->counter++; +} + +static void +test_preference_order(void) +{ + nm_auto_unref_gmainloop GMainLoop *loop = g_main_loop_new(NULL, FALSE); + gs_unref_object NMFakeNDisc *ndisc = ndisc_new(); + const gint64 now_msec = nm_utils_get_monotonic_timestamp_msec(); + TestData data = { + .loop = loop, + .timestamp_msec_1 = now_msec, + }; + guint id; + + /* Test insertion order of gateways */ + + id = nm_fake_ndisc_add_ra(ndisc, 1, NM_NDISC_DHCP_LEVEL_NONE, 4, 1500); + g_assert(id); + nm_fake_ndisc_add_gateway(ndisc, id, "fe80::1", now_msec + 10000, NM_ICMPV6_ROUTER_PREF_HIGH); + nm_fake_ndisc_add_prefix(ndisc, + id, + "2001:db8:a:a::", + 64, + "fe80::1", + now_msec + 10000, + now_msec + 10000, + 5); + + id = nm_fake_ndisc_add_ra(ndisc, 1, NM_NDISC_DHCP_LEVEL_NONE, 4, 1500); + g_assert(id); + nm_fake_ndisc_add_gateway(ndisc, id, "fe80::2", now_msec + 11000, NM_ICMPV6_ROUTER_PREF_LOW); + nm_fake_ndisc_add_prefix(ndisc, + id, + "2001:db8:a:b::", + 64, + "fe80::2", + now_msec + 11000, + now_msec + 10000, + 10); + + g_signal_connect(ndisc, NM_NDISC_CONFIG_RECEIVED, G_CALLBACK(test_preference_order_cb), &data); + + nm_ndisc_start(NM_NDISC(ndisc)); + nmtst_main_loop_run_assert(data.loop, 15000); + g_assert_cmpint(data.counter, ==, 2); +} + +static void +test_preference_changed_cb(NMNDisc * ndisc, + const NMNDiscData *rdata, + guint changed_int, + TestData * data) +{ + NMNDiscConfigMap changed = changed_int; + + if (data->counter == 1) { + g_assert_cmpint(changed, + ==, + NM_NDISC_CONFIG_GATEWAYS | NM_NDISC_CONFIG_ADDRESSES + | NM_NDISC_CONFIG_ROUTES); + g_assert_cmpint(rdata->gateways_n, ==, 2); + match_gateway(rdata, + 0, + "fe80::2", + data->timestamp_msec_1 + 11000, + NM_ICMPV6_ROUTER_PREF_MEDIUM); + match_gateway(rdata, + 1, + "fe80::1", + data->timestamp_msec_1 + 10000, + NM_ICMPV6_ROUTER_PREF_LOW); + g_assert_cmpint(rdata->addresses_n, ==, 2); + match_address(rdata, + 0, + "2001:db8:a:a::1", + data->timestamp_msec_1 + 10000, + data->timestamp_msec_1 + 10000); + match_address(rdata, + 1, + "2001:db8:a:b::1", + data->timestamp_msec_1 + 11000, + data->timestamp_msec_1 + 11000); + g_assert_cmpint(rdata->routes_n, ==, 2); + match_route(rdata, 0, "2001:db8:a:b::", 64, "fe80::2", data->timestamp_msec_1 + 11000, 10); + match_route(rdata, 1, "2001:db8:a:a::", 64, "fe80::1", data->timestamp_msec_1 + 10000, 5); + } else if (data->counter == 2) { + g_assert_cmpint(changed, + ==, + NM_NDISC_CONFIG_GATEWAYS | NM_NDISC_CONFIG_ADDRESSES + | NM_NDISC_CONFIG_ROUTES); + + g_assert_cmpint(rdata->gateways_n, ==, 2); + match_gateway(rdata, + 0, + "fe80::1", + data->timestamp_msec_1 + 12000, + NM_ICMPV6_ROUTER_PREF_HIGH); + match_gateway(rdata, + 1, + "fe80::2", + data->timestamp_msec_1 + 11000, + NM_ICMPV6_ROUTER_PREF_MEDIUM); + g_assert_cmpint(rdata->addresses_n, ==, 2); + match_address(rdata, + 0, + "2001:db8:a:a::1", + data->timestamp_msec_1 + 12000, + data->timestamp_msec_1 + 12000); + match_address(rdata, + 1, + "2001:db8:a:b::1", + data->timestamp_msec_1 + 11000, + data->timestamp_msec_1 + 11000); + g_assert_cmpint(rdata->routes_n, ==, 2); + match_route(rdata, 0, "2001:db8:a:a::", 64, "fe80::1", data->timestamp_msec_1 + 12000, 15); + match_route(rdata, 1, "2001:db8:a:b::", 64, "fe80::2", data->timestamp_msec_1 + 11000, 10); + + g_assert(nm_fake_ndisc_done(NM_FAKE_NDISC(ndisc))); + g_main_loop_quit(data->loop); + } + + data->counter++; +} + +static void +test_preference_changed(void) +{ + nm_auto_unref_gmainloop GMainLoop *loop = g_main_loop_new(NULL, FALSE); + gs_unref_object NMFakeNDisc *ndisc = ndisc_new(); + const gint64 now_msec = nm_utils_get_monotonic_timestamp_msec(); + TestData data = { + .loop = loop, + .timestamp_msec_1 = now_msec, + }; + guint id; + + /* Test that when a low-preference and medium gateway send advertisements, + * that if the low-preference gateway switches to high-preference, we do + * not get duplicates in the gateway list. + */ + + id = nm_fake_ndisc_add_ra(ndisc, 1, NM_NDISC_DHCP_LEVEL_NONE, 4, 1500); + g_assert(id); + nm_fake_ndisc_add_gateway(ndisc, id, "fe80::1", now_msec + 10000, NM_ICMPV6_ROUTER_PREF_LOW); + nm_fake_ndisc_add_prefix(ndisc, + id, + "2001:db8:a:a::", + 64, + "fe80::1", + now_msec + 10000, + now_msec + 10000, + 5); + + id = nm_fake_ndisc_add_ra(ndisc, 1, NM_NDISC_DHCP_LEVEL_NONE, 4, 1500); + g_assert(id); + nm_fake_ndisc_add_gateway(ndisc, id, "fe80::2", now_msec + 11000, NM_ICMPV6_ROUTER_PREF_MEDIUM); + nm_fake_ndisc_add_prefix(ndisc, + id, + "2001:db8:a:b::", + 64, + "fe80::2", + now_msec + 11000, + now_msec + 11000, + 10); + + id = nm_fake_ndisc_add_ra(ndisc, 1, NM_NDISC_DHCP_LEVEL_NONE, 4, 1500); + g_assert(id); + nm_fake_ndisc_add_gateway(ndisc, id, "fe80::1", now_msec + 12000, NM_ICMPV6_ROUTER_PREF_HIGH); + nm_fake_ndisc_add_prefix(ndisc, + id, + "2001:db8:a:a::", + 64, + "fe80::1", + now_msec + 12000, + now_msec + 12000, + 15); + + g_signal_connect(ndisc, + NM_NDISC_CONFIG_RECEIVED, + G_CALLBACK(test_preference_changed_cb), + &data); + + nm_ndisc_start(NM_NDISC(ndisc)); + nmtst_main_loop_run_assert(data.loop, 15000); + g_assert_cmpint(data.counter, ==, 3); +} + +/*****************************************************************************/ + +static void +_test_dns_solicit_loop_changed(NMNDisc * ndisc, + const NMNDiscData *rdata, + guint changed_int, + TestData * data) +{ + data->counter++; +} + +static void +_test_dns_solicit_loop_rs_sent(NMFakeNDisc *ndisc, TestData *data) +{ + data->rs_counter++; +} + +static void +test_dns_solicit_loop(void) +{ + nm_auto_unref_gmainloop GMainLoop *loop = g_main_loop_new(NULL, FALSE); + gs_unref_object NMFakeNDisc *ndisc = ndisc_new(); + const gint64 now_msec = nm_utils_get_monotonic_timestamp_msec(); + TestData data = { + .loop = loop, + .timestamp_msec_1 = now_msec, + }; + guint id; + + /* Ensure that no solicitation loop happens when DNS servers or domains + * stop being sent in advertisements. This can happen if two routers + * send RAs, but the one sending DNS info stops responding, or if one + * router removes the DNS info from the RA without zero-lifetiming them + * first. + */ + + id = nm_fake_ndisc_add_ra(ndisc, 1, NM_NDISC_DHCP_LEVEL_NONE, 4, 1500); + g_assert(id); + nm_fake_ndisc_add_gateway(ndisc, id, "fe80::1", now_msec + 10000, NM_ICMPV6_ROUTER_PREF_LOW); + nm_fake_ndisc_add_dns_server(ndisc, id, "2001:db8:c:c::1", now_msec + 6000); + + g_signal_connect(ndisc, + NM_NDISC_CONFIG_RECEIVED, + G_CALLBACK(_test_dns_solicit_loop_changed), + &data); + g_signal_connect(ndisc, + NM_FAKE_NDISC_RS_SENT, + G_CALLBACK(_test_dns_solicit_loop_rs_sent), + &data); + + nm_ndisc_start(NM_NDISC(ndisc)); + if (nmtst_main_loop_run(data.loop, 10000)) + g_error("we expect to run the loop until timeout. What is wrong?"); + g_assert_cmpint(data.counter, ==, 3); + g_assert_cmpint(data.rs_counter, ==, 1); +} + +/*****************************************************************************/ + +NMTST_DEFINE(); + +int +main(int argc, char **argv) +{ + nmtst_init_with_logging(&argc, &argv, NULL, "DEFAULT"); + + if (nmtst_test_quick()) { + g_print("Skipping test: don't run long running test %s (NMTST_DEBUG=slow)\n", + g_get_prgname() ?: "test-ndisc-fake"); + return g_test_run(); + } + + nm_fake_platform_setup(); + + g_test_add_func("/ndisc/simple", test_simple); + g_test_add_func("/ndisc/everything-changed", test_everything); + g_test_add_func("/ndisc/preference-order", test_preference_order); + g_test_add_func("/ndisc/preference-changed", test_preference_changed); + g_test_add_func("/ndisc/dns-solicit-loop", test_dns_solicit_loop); + + return g_test_run(); +} diff --git a/src/core/ndisc/tests/test-ndisc-linux.c b/src/core/ndisc/tests/test-ndisc-linux.c new file mode 100644 index 00000000..9a5df60b --- /dev/null +++ b/src/core/ndisc/tests/test-ndisc-linux.c @@ -0,0 +1,85 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2013 Red Hat, Inc. + */ + +#include "src/core/nm-default-daemon.h" + +#include <syslog.h> + +#include "ndisc/nm-ndisc.h" +#include "ndisc/nm-lndp-ndisc.h" + +#include "platform/nm-linux-platform.h" + +#include "nm-test-utils-core.h" + +NMTST_DEFINE(); + +int +main(int argc, char **argv) +{ + GMainLoop * loop; + NMNDisc * ndisc; + int ifindex = 1; + const char * ifname; + NMUtilsIPv6IfaceId iid = {}; + GError * error = NULL; + int max_addresses; + int router_solicitations; + int router_solicitation_interval; + guint32 ra_timeout; + + nmtst_init_with_logging(&argc, &argv, NULL, "DEFAULT"); + + if (getuid() != 0) { + g_print("Missing permission: must run as root\n"); + return EXIT_FAILURE; + } + + loop = g_main_loop_new(NULL, FALSE); + + nm_linux_platform_setup(); + + if (argv[1]) { + ifname = argv[1]; + ifindex = nm_platform_link_get_ifindex(NM_PLATFORM_GET, ifname); + } else { + g_print("Missing command line argument \"interface-name\"\n"); + return EXIT_FAILURE; + } + + nm_lndp_ndisc_get_sysctl(NM_PLATFORM_GET, + ifname, + &max_addresses, + &router_solicitations, + &router_solicitation_interval, + &ra_timeout); + + ndisc = nm_lndp_ndisc_new(NM_PLATFORM_GET, + ifindex, + ifname, + NM_UTILS_STABLE_TYPE_UUID, + "8ce666e8-d34d-4fb1-b858-f15a7al28086", + NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64, + NM_NDISC_NODE_TYPE_HOST, + max_addresses, + router_solicitations, + router_solicitation_interval, + ra_timeout, + &error); + if (!ndisc) { + g_print("Failed to create NMNDisc instance: %s\n", error->message); + g_error_free(error); + return EXIT_FAILURE; + } + + iid.id_u8[7] = 1; + nm_ndisc_set_iid(ndisc, iid); + nm_ndisc_start(ndisc); + g_main_loop_run(loop); + + g_clear_object(&ndisc); + + return EXIT_SUCCESS; +} |