// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (C) 2013 Red Hat, Inc.
*/
#include "nm-default.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;
int plen;
struct in6_addr gateway;
guint32 timestamp;
guint32 lifetime;
guint32 preferred;
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,
guint32 timestamp,
guint32 lifetime,
NMIcmpv6RouterPref preference)
{
NMFakeNDiscPrivate *priv = NM_FAKE_NDISC_GET_PRIVATE (self);
FakeRa *ra = find_ra (priv->ras, ra_id);
NMNDiscGateway *gw;
g_assert (ra);
g_array_set_size (ra->gateways, ra->gateways->len + 1);
gw = &g_array_index (ra->gateways, NMNDiscGateway, ra->gateways->len - 1);
g_assert (inet_pton (AF_INET6, addr, &gw->address) == 1);
gw->timestamp = timestamp;
gw->lifetime = lifetime;
gw->preference = preference;
}
void
nm_fake_ndisc_add_prefix (NMFakeNDisc *self,
guint ra_id,
const char *network,
guint plen,
const char *gateway,
guint32 timestamp,
guint32 lifetime,
guint32 preferred,
NMIcmpv6RouterPref preference)
{
NMFakeNDiscPrivate *priv = NM_FAKE_NDISC_GET_PRIVATE (self);
FakeRa *ra = find_ra (priv->ras, ra_id);
FakePrefix *prefix;
g_assert (ra);
g_array_set_size (ra->prefixes, ra->prefixes->len + 1);
prefix = &g_array_index (ra->prefixes, FakePrefix, ra->prefixes->len - 1);
memset (prefix, 0, sizeof (*prefix));
g_assert (inet_pton (AF_INET6, network, &prefix->network) == 1);
g_assert (inet_pton (AF_INET6, gateway, &prefix->gateway) == 1);
prefix->plen = plen;
prefix->timestamp = timestamp;
prefix->lifetime = lifetime;
prefix->preferred = preferred;
prefix->preference = preference;
}
void
nm_fake_ndisc_add_dns_server (NMFakeNDisc *self,
guint ra_id,
const char *address,
guint32 timestamp,
guint32 lifetime)
{
NMFakeNDiscPrivate *priv = NM_FAKE_NDISC_GET_PRIVATE (self);
FakeRa *ra = find_ra (priv->ras, ra_id);
NMNDiscDNSServer *dns;
g_assert (ra);
g_array_set_size (ra->dns_servers, ra->dns_servers->len + 1);
dns = &g_array_index (ra->dns_servers, NMNDiscDNSServer, ra->dns_servers->len - 1);
g_assert (inet_pton (AF_INET6, address, &dns->address) == 1);
dns->timestamp = timestamp;
dns->lifetime = lifetime;
}
void
nm_fake_ndisc_add_dns_domain (NMFakeNDisc *self,
guint ra_id,
const char *domain,
guint32 timestamp,
guint32 lifetime)
{
NMFakeNDiscPrivate *priv = NM_FAKE_NDISC_GET_PRIVATE (self);
FakeRa *ra = find_ra (priv->ras, ra_id);
NMNDiscDNSDomain *dns;
g_assert (ra);
g_array_set_size (ra->dns_domains, ra->dns_domains->len + 1);
dns = &g_array_index (ra->dns_domains, NMNDiscDNSDomain, ra->dns_domains->len - 1);
dns->domain = g_strdup (domain);
dns->timestamp = timestamp;
dns->lifetime = lifetime;
}
gboolean
nm_fake_ndisc_done (NMFakeNDisc *self)
{
return !NM_FAKE_NDISC_GET_PRIVATE (self)->ras;
}
/*****************************************************************************/
static gboolean
send_rs (NMNDisc *ndisc, GError **error)
{
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;
gint32 now = nm_utils_get_monotonic_timestamp_sec ();
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++) {
NMNDiscGateway *item = &g_array_index (ra->gateways, NMNDiscGateway, i);
if (nm_ndisc_add_gateway (ndisc, item))
changed |= NM_NDISC_CONFIG_GATEWAYS;
}
for (i = 0; i < ra->prefixes->len; i++) {
FakePrefix *item = &g_array_index (ra->prefixes, FakePrefix, i);
NMNDiscRoute route = {
.network = item->network,
.plen = item->plen,
.gateway = item->gateway,
.timestamp = item->timestamp,
.lifetime = item->lifetime,
.preference = item->preference,
};
g_assert (route.plen > 0 && route.plen <= 128);
if (nm_ndisc_add_route (ndisc, &route))
changed |= NM_NDISC_CONFIG_ROUTES;
if (item->plen == 64) {
NMNDiscAddress address = {
.address = item->network,
.timestamp = item->timestamp,
.lifetime = item->lifetime,
.preferred = item->preferred,
.dad_counter = 0,
};
if (nm_ndisc_complete_and_add_address (ndisc, &address, now))
changed |= NM_NDISC_CONFIG_ADDRESSES;
}
}
for (i = 0; i < ra->dns_servers->len; i++) {
NMNDiscDNSServer *item = &g_array_index (ra->dns_servers, NMNDiscDNSServer, i);
if (nm_ndisc_add_dns_server (ndisc, item))
changed |= NM_NDISC_CONFIG_DNS_SERVERS;
}
for (i = 0; i < ra->dns_domains->len; i++) {
NMNDiscDNSDomain *item = &g_array_index (ra->dns_domains, NMNDiscDNSDomain, i);
if (nm_ndisc_add_dns_domain (ndisc, item))
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, 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);
}
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",
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->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);
}