fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-05-03 12:28:03 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions
NetworkManager/src/core/ndisc/nm-fake-ndisc.c
Thomas Haller da371f8108
ndisc/tests: fix reference counting in nm_fake_ndisc_new() 
This adjusts the change from commit ffbcf01589 ('test-ndisc-fake:
free l3cfg after creating fake-ndisc').

ndisc_new() already correctly handles the reference count of l3cfg via
"gs_unref_object". The party that took the wrong reference was
nm_fake_ndisc_new().

Fixes: 58287cbcc0 ('core: rework IP configuration in NetworkManager using layer 3 configuration')
2023-01-05 12:13:39 +01:00

411 lines
12 KiB
C
Raw Blame History

/* 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"
#include "nm-l3cfg.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 = &nm_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 = &nm_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 = &nm_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 = &nm_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(NML3Cfg *l3cfg)
{
const NMNDiscConfig config = {
.l3cfg = NM_L3CFG(l3cfg),
.ifname = nm_l3cfg_get_ifname(l3cfg, TRUE),
.node_type = NM_NDISC_NODE_TYPE_HOST,
.stable_type = NM_UTILS_STABLE_TYPE_UUID,
.network_id = "fake",
.max_addresses = NM_NDISC_MAX_ADDRESSES_DEFAULT,
.router_solicitations = NM_NDISC_ROUTER_SOLICITATIONS_DEFAULT,
.router_solicitation_interval = NM_NDISC_RFC4861_RTR_SOLICITATION_INTERVAL,
.ra_timeout = 30u,
.addr_gen_mode = NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64,
.ip6_privacy = NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_TEMP_ADDR,
};
return g_object_new(NM_TYPE_FAKE_NDISC, NM_NDISC_CONFIG, &config, 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);
}
Reference in a new issue View git blame Copy permalink