Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/dvmrpd/rde_mfc.c	Lines:	0	201	0.0 %
Date:	2017-11-07	Branches:	0	274	0.0 %


/*	$OpenBSD: rde_mfc.c,v 1.10 2015/12/07 19:14:49 mmcc Exp $ */

/*
 * Copyright (c) 2009 Michele Marchetto <michele@openbsd.org>
 * Copyright (c) 2006 Esben Norby <norby@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/tree.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <err.h>
#include <stdlib.h>
#include <string.h>

#include "igmp.h"
#include "dvmrp.h"
#include "dvmrpd.h"
#include "log.h"
#include "dvmrpe.h"
#include "rde.h"

/* multicast forwarding cache */

void			 mfc_send_prune(struct rt_node *, struct mfc_node *);
void			 mfc_add_prune(struct mfc_node *, struct prune *);
struct prune_node	*mfc_find_prune(struct mfc_node *, struct prune *);
void			 mfc_delete_prune(struct mfc_node *,
			    struct prune_node *);

int	prune_compare(struct mfc_node *, struct rt_node *, int);
void	prune_expire_timer(int, short, void *);
int	mfc_reset_prune_expire_timer(struct prune_node *);


void	 mfc_expire_timer(int, short, void *);
int	 mfc_start_expire_timer(struct mfc_node *);
int	 mfc_reset_expire_timer(struct mfc_node *);
void	 mfc_prune_timer(int, short, void *);
int	 mfc_start_prune_timer(struct mfc_node *);
int	 mfc_reset_prune_timer(struct mfc_node *);

int	 mfc_compare(struct mfc_node *, struct mfc_node *);
void	 mfc_invalidate(void);

RB_HEAD(mfc_tree, mfc_node)	 mfc;
RB_PROTOTYPE(mfc_tree, mfc_node, entry, mfc_compare)
RB_GENERATE(mfc_tree, mfc_node, entry, mfc_compare)

extern struct dvmrpd_conf	*rdeconf;

/* timers */
void
mfc_expire_timer(int fd, short event, void *arg)
{
	struct mfc_node	*mn = arg;
	struct mfc	 nmfc;

	log_debug("mfc_expire_timer: group %s", inet_ntoa(mn->group));

	/* remove route entry */
	nmfc.origin = mn->origin;
	nmfc.group = mn->group;
	rde_imsg_compose_parent(IMSG_MFC_DEL, 0, &nmfc, sizeof(nmfc));

	event_del(&mn->expiration_timer);
	mfc_remove(mn);
}

int
mfc_reset_expire_timer(struct mfc_node *mn)
{
	struct timeval	tv;

	timerclear(&tv);
	tv.tv_sec = ROUTE_EXPIRATION_TIME;
	return (evtimer_add(&mn->expiration_timer, &tv));
}

int
mfc_start_expire_timer(struct mfc_node *mn)
{
	struct timeval	tv;

	log_debug("mfc_start_expire_timer: group %s", inet_ntoa(mn->group));

	timerclear(&tv);
	tv.tv_sec = ROUTE_EXPIRATION_TIME;
	return (evtimer_add(&mn->expiration_timer, &tv));
}

void
mfc_prune_timer(int fd, short event, void *arg)
{
	struct mfc_node	*mn = arg;

	log_debug("mfc_prune_timer: group %s", inet_ntoa(mn->group));

	event_del(&mn->prune_timer);
}

int
mfc_start_prune_timer(struct mfc_node *mn)
{
	struct timeval	tv;

	log_debug("mfc_start_prune_timer: group %s", inet_ntoa(mn->group));

	timerclear(&tv);
	tv.tv_sec = MAX_PRUNE_LIFETIME;
	return (evtimer_add(&mn->prune_timer, &tv));
}

int
mfc_reset_prune_timer(struct mfc_node *mn)
{
	struct timeval	tv;

	timerclear(&tv);
	tv.tv_sec = MAX_PRUNE_LIFETIME;
	return (evtimer_add(&mn->prune_timer, &tv));
}

/* route table */
void
mfc_init(void)
{
	RB_INIT(&mfc);
}

int
mfc_compare(struct mfc_node *a, struct mfc_node *b)
{
	if (ntohl(a->origin.s_addr) < ntohl(b->origin.s_addr))
		return (-1);
	if (ntohl(a->origin.s_addr) > ntohl(b->origin.s_addr))
		return (1);
	if (ntohl(a->group.s_addr) < ntohl(b->group.s_addr))
		return (-1);
	if (ntohl(a->group.s_addr) > ntohl(b->group.s_addr))
		return (1);
	return (0);
}

struct mfc_node *
mfc_find(in_addr_t origin, in_addr_t group)
{
	struct mfc_node	s;

	s.origin.s_addr = origin;
	s.group.s_addr = group;

	return (RB_FIND(mfc_tree, &mfc, &s));
}

int
mfc_insert(struct mfc_node *m)
{
	if (RB_INSERT(mfc_tree, &mfc, m) != NULL) {
		log_warnx("mfc_insert failed for group %s",
		    inet_ntoa(m->group));
		free(m);
		return (-1);
	}

	return (0);
}

int
mfc_remove(struct mfc_node *m)
{
	if (RB_REMOVE(mfc_tree, &mfc, m) == NULL) {
		log_warnx("mfc_remove failed for group %s",
		    inet_ntoa(m->group));
		return (-1);
	}

	free(m);
	return (0);
}

void
mfc_clear(void)
{
	struct mfc_node	*m;

	while ((m = RB_MIN(mfc_tree, &mfc)) != NULL)
		mfc_remove(m);
}

void
mfc_dump(pid_t pid)
{
	static struct ctl_mfc	 mfcctl;
	struct timespec		 now;
	struct timeval		 tv, now2, res;
	struct mfc_node		*mn;
	int			 i;

	clock_gettime(CLOCK_MONOTONIC, &now);

	RB_FOREACH(mn, mfc_tree, &mfc) {
		mfcctl.origin.s_addr = mn->origin.s_addr;
		mfcctl.group.s_addr = mn->group.s_addr;
		mfcctl.uptime = now.tv_sec - mn->uptime;
		mfcctl.ifindex = mn->ifindex;

		for (i = 0; i < MAXVIFS; i ++) {
			mfcctl.ttls[i] = mn->ttls[i];
		}

		gettimeofday(&now2, NULL);
		if (evtimer_pending(&mn->expiration_timer, &tv)) {
			timersub(&tv, &now2, &res);
			mfcctl.expire = res.tv_sec;
		} else
			mfcctl.expire = -1;

		rde_imsg_compose_dvmrpe(IMSG_CTL_SHOW_MFC, 0, pid, &mfcctl,
		    sizeof(mfcctl));
	}
}

struct rt_node *
mfc_find_origin(struct in_addr group)
{
	struct mfc_node	*mn;

	RB_FOREACH(mn, mfc_tree, &mfc)
		if (group.s_addr == mn->group.s_addr)
			return (rt_match_origin(mn->origin.s_addr));

	return (NULL);
}

void
mfc_send_prune(struct rt_node *rn, struct mfc_node *mn)
{
	struct prune	p;

	memset(&p, 0, sizeof(p));

	p.origin.s_addr = (mn->origin.s_addr &
	    htonl(prefixlen2mask(rn->prefixlen)));
	p.netmask.s_addr = htonl(prefixlen2mask(rn->prefixlen));
	p.group.s_addr = mn->group.s_addr;
	p.nexthop.s_addr = rn->nexthop.s_addr;
	p.ifindex = mn->ifindex;

	rde_imsg_compose_dvmrpe(IMSG_SEND_PRUNE, 0, 0, &p, sizeof(p));

	mfc_start_prune_timer(mn);
}

void
mfc_update_source(struct rt_node *rn)
{
	struct mfc_node		*mn;
	struct mfc		 m;
	int			 i;
	u_int8_t		 found;

	RB_FOREACH(mn, mfc_tree, &mfc) {
		if (rn->prefix.s_addr == (mn->origin.s_addr &
		    htonl(prefixlen2mask(rn->prefixlen)))) {
			mn->ifindex = rn->ifindex;

			found = 0;

			for (i = 0; i < MAXVIFS; i++) {
				mn->ttls[i] = rn->ttls[i];
				if (mn->ttls[i] != 0)
					found = 1;
			}

			m.origin.s_addr = mn->origin.s_addr;
			m.group.s_addr = mn->group.s_addr;
			m.ifindex = mn->ifindex;

			for (i = 0; i < MAXVIFS; i++)
				m.ttls[i] = mn->ttls[i];

			rde_imsg_compose_parent(IMSG_MFC_ADD, 0, &m, sizeof(m));

			mfc_reset_expire_timer(mn);

			if (!found && !rn->connected)
				mfc_send_prune(rn, mn);
		}
	}
}

void
mfc_update(struct mfc *nmfc)
{
	struct mfc_node		*mn;
	struct rt_node		*rn;
	struct timespec		 now;
	int			 i;
	u_int8_t		 found = 0;

	clock_gettime(CLOCK_MONOTONIC, &now);

	if ((mn = mfc_find(nmfc->origin.s_addr, nmfc->group.s_addr)) == NULL) {
		if ((mn = calloc(1, sizeof(struct mfc_node))) == NULL)
			fatalx("mfc_update");

		mn->origin.s_addr = nmfc->origin.s_addr;
		mn->group.s_addr = nmfc->group.s_addr;
		mn->ifindex = nmfc->ifindex;
		mn->uptime = now.tv_sec;
		for (i = 0; i < MAXVIFS; i++) {
			mn->ttls[i] = nmfc->ttls[i];
			if (mn->ttls[i] != 0)
				found = 1;
		}

		if (mfc_insert(mn) == 0) {
			rde_imsg_compose_parent(IMSG_MFC_ADD, 0, nmfc,
			    sizeof(*nmfc));
		}

		evtimer_set(&mn->expiration_timer, mfc_expire_timer, mn);
		evtimer_set(&mn->prune_timer, mfc_expire_timer, mn);
		mfc_start_expire_timer(mn);

		if (!found) {
			/* We removed all downstream interfaces,
			   start the pruning process */
			rn = rt_match_origin(mn->origin.s_addr);
			if (rn == NULL) {
				fatal("mfc_update: cannot find information "
				    " about source");
			}

			mfc_send_prune(rn, mn);
		}
	}
}

void
mfc_delete(struct mfc *nmfc)
{
	struct mfc_node	*mn;

	if ((mn = mfc_find(nmfc->origin.s_addr, nmfc->group.s_addr)) == NULL)
		return;

	/* XXX decide if it should really be removed */
	mfc_remove(mn);

	/* XXX notify parent */
}

int
mfc_check_members(struct rt_node *rn, struct iface *iface)
{
	struct mfc_node		*mn;

	RB_FOREACH(mn, mfc_tree, &mfc) {
		if (mn->origin.s_addr == rn->prefix.s_addr) {
			if (rde_group_list_find(iface, mn->group) != 0)
				return (1);
		}
	}

	return (0);
}

void
mfc_recv_prune(struct prune *p)
{
	struct rt_node		*rn;
	struct mfc_node		*mn;
	struct prune_node	*pn;
	struct iface		*iface;
	struct mfc		 m;

	iface = if_find_index(p->ifindex);
	if (iface == NULL) {
		log_debug("mfc_recv_prune: unknown interface");
		return;
	}

	rn = rt_match_origin(p->origin.s_addr);
	if (rn == NULL) {
		log_debug("mfc_recv_prune: no information for %s\n",
		    inet_ntoa(p->origin));
		return;
	}

	if (srt_find_ds(rn, p->nexthop.s_addr) == NULL) {
		log_debug("mfc_recv_prune: prune received from a "
		    "non downstream neighbor\n");
		return;
	}

	mn = mfc_find(p->origin.s_addr, p->group.s_addr);
	if (mn) {
		log_debug("mfc_recv_prune: no information for %s\n",
		    inet_ntoa(p->origin));
		return;
	}

	pn = mfc_find_prune(mn, p);
	if (pn == NULL) {
		mfc_add_prune(mn, p);
		if (prune_compare(mn, rn, p->ifindex) &&
		    !rde_group_list_find(iface, p->group)) {
			mn->ttls[p->ifindex] = 0;

			m.ifindex = p->ifindex;
			m.origin.s_addr = p->origin.s_addr;
			m.group.s_addr = p->group.s_addr;
			mfc_update(&m);
		}
	} else
		mfc_reset_prune_expire_timer(pn);
}

void
mfc_add_prune(struct mfc_node *mn, struct prune *p)
{
	struct prune_node	*pn;
	struct timeval		 tv;

	pn = calloc(1, sizeof(struct prune));
	if (pn == NULL)
		fatal("prune_add");

	timerclear(&tv);
	tv.tv_sec = MAX_PRUNE_LIFETIME;

	pn->nbr.s_addr = p->nexthop.s_addr;
	pn->ifindex = p->ifindex;
	pn->parent = mn;

	evtimer_set(&pn->lifetime_timer, prune_expire_timer, pn);
	evtimer_add(&pn->lifetime_timer, &tv);

	LIST_INSERT_HEAD(&mn->prune_list, pn, entry);

	mn->prune_cnt[p->ifindex]++;
}

struct prune_node *
mfc_find_prune(struct mfc_node *mn, struct prune *p)
{
	struct prune_node	*pn;

	LIST_FOREACH(pn, &mn->prune_list, entry) {
		if (p->nexthop.s_addr == pn->nbr.s_addr)
			return (pn);
	}

	return (NULL);
}

void
mfc_delete_prune(struct mfc_node *mn, struct prune_node *pn)
{
	unsigned int	ifindex = pn->ifindex;

	if (evtimer_pending(&pn->lifetime_timer, NULL))
		if (evtimer_del(&pn->lifetime_timer) == -1)
			fatal("mfc_delete_prune");

	LIST_REMOVE(pn, entry);
	free(pn);
	mn->prune_cnt[ifindex]--;
}

int
prune_compare(struct mfc_node *mn, struct rt_node *rn, int ifindex)
{
	if (mn->prune_cnt[ifindex] == rn->ds_cnt[ifindex])
		return (1);

	return (0);
}

int
mfc_reset_prune_expire_timer(struct prune_node *pn)
{
	struct timeval	tv;

	timerclear(&tv);
	tv.tv_sec = MAX_PRUNE_LIFETIME;

	return (evtimer_add(&pn->lifetime_timer, &tv));
}

void
prune_expire_timer(int fd, short event, void *arg)
{
	struct prune_node	*pn = arg;

	LIST_REMOVE(pn, entry);

	pn->parent->prune_cnt[pn->ifindex]--;
	pn->parent->ttls[pn->ifindex] = 1;

	free(pn);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: rde_mfc.c,v 1.10 2015/12/07 19:14:49 mmcc Exp $ */
2
3			/*
4			* Copyright (c) 2009 Michele Marchetto <michele@openbsd.org>
5			* Copyright (c) 2006 Esben Norby <norby@openbsd.org>
6			*
7			* Permission to use, copy, modify, and distribute this software for any
8			* purpose with or without fee is hereby granted, provided that the above
9			* copyright notice and this permission notice appear in all copies.
10			*
11			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18			*/
19
20			#include <sys/types.h>
21			#include <sys/socket.h>
22			#include <sys/tree.h>
23			#include <netinet/in.h>
24			#include <arpa/inet.h>
25			#include <err.h>
26			#include <stdlib.h>
27			#include <string.h>
28
29			#include "igmp.h"
30			#include "dvmrp.h"
31			#include "dvmrpd.h"
32			#include "log.h"
33			#include "dvmrpe.h"
34			#include "rde.h"
35
36			/* multicast forwarding cache */
37
38			void mfc_send_prune(struct rt_node , struct mfc_node );
39			void mfc_add_prune(struct mfc_node , struct prune );
40			struct prune_node mfc_find_prune(struct mfc_node , struct prune *);
41			void mfc_delete_prune(struct mfc_node *,
42			struct prune_node *);
43
44			int prune_compare(struct mfc_node , struct rt_node , int);
45			void prune_expire_timer(int, short, void *);
46			int mfc_reset_prune_expire_timer(struct prune_node *);
47
48
49			void mfc_expire_timer(int, short, void *);
50			int mfc_start_expire_timer(struct mfc_node *);
51			int mfc_reset_expire_timer(struct mfc_node *);
52			void mfc_prune_timer(int, short, void *);
53			int mfc_start_prune_timer(struct mfc_node *);
54			int mfc_reset_prune_timer(struct mfc_node *);
55
56			int mfc_compare(struct mfc_node , struct mfc_node );
57			void mfc_invalidate(void);
58
59			RB_HEAD(mfc_tree, mfc_node) mfc;
60			RB_PROTOTYPE(mfc_tree, mfc_node, entry, mfc_compare)
61			RB_GENERATE(mfc_tree, mfc_node, entry, mfc_compare)
62
63			extern struct dvmrpd_conf *rdeconf;
64
65			/* timers */
66			void
67			mfc_expire_timer(int fd, short event, void *arg)
68			{
69			struct mfc_node *mn = arg;
70			struct mfc nmfc;
71
72			log_debug("mfc_expire_timer: group %s", inet_ntoa(mn->group));
73
74			/* remove route entry */
75			nmfc.origin = mn->origin;
76			nmfc.group = mn->group;
77			rde_imsg_compose_parent(IMSG_MFC_DEL, 0, &nmfc, sizeof(nmfc));
78
79			event_del(&mn->expiration_timer);
80			mfc_remove(mn);
81			}
82
83			int
84			mfc_reset_expire_timer(struct mfc_node *mn)
85			{
86			struct timeval tv;
87
88			timerclear(&tv);
89			tv.tv_sec = ROUTE_EXPIRATION_TIME;
90			return (evtimer_add(&mn->expiration_timer, &tv));
91			}
92
93			int
94			mfc_start_expire_timer(struct mfc_node *mn)
95			{
96			struct timeval tv;
97
98			log_debug("mfc_start_expire_timer: group %s", inet_ntoa(mn->group));
99
100			timerclear(&tv);
101			tv.tv_sec = ROUTE_EXPIRATION_TIME;
102			return (evtimer_add(&mn->expiration_timer, &tv));
103			}
104
105			void
106			mfc_prune_timer(int fd, short event, void *arg)
107			{
108			struct mfc_node *mn = arg;
109
110			log_debug("mfc_prune_timer: group %s", inet_ntoa(mn->group));
111
112			event_del(&mn->prune_timer);
113			}
114
115			int
116			mfc_start_prune_timer(struct mfc_node *mn)
117			{
118			struct timeval tv;
119
120			log_debug("mfc_start_prune_timer: group %s", inet_ntoa(mn->group));
121
122			timerclear(&tv);
123			tv.tv_sec = MAX_PRUNE_LIFETIME;
124			return (evtimer_add(&mn->prune_timer, &tv));
125			}
126
127			int
128			mfc_reset_prune_timer(struct mfc_node *mn)
129			{
130			struct timeval tv;
131
132			timerclear(&tv);
133			tv.tv_sec = MAX_PRUNE_LIFETIME;
134			return (evtimer_add(&mn->prune_timer, &tv));
135			}
136
137			/* route table */
138			void
139			mfc_init(void)
140			{
141			RB_INIT(&mfc);
142			}
143
144			int
145			mfc_compare(struct mfc_node a, struct mfc_node b)
146			{
147			if (ntohl(a->origin.s_addr) < ntohl(b->origin.s_addr))
148			return (-1);
149			if (ntohl(a->origin.s_addr) > ntohl(b->origin.s_addr))
150			return (1);
151			if (ntohl(a->group.s_addr) < ntohl(b->group.s_addr))
152			return (-1);
153			if (ntohl(a->group.s_addr) > ntohl(b->group.s_addr))
154			return (1);
155			return (0);
156			}
157
158			struct mfc_node *
159			mfc_find(in_addr_t origin, in_addr_t group)
160			{
161			struct mfc_node s;
162
163			s.origin.s_addr = origin;
164			s.group.s_addr = group;
165
166			return (RB_FIND(mfc_tree, &mfc, &s));
167			}
168
169			int
170			mfc_insert(struct mfc_node *m)
171			{
172			if (RB_INSERT(mfc_tree, &mfc, m) != NULL) {
173			log_warnx("mfc_insert failed for group %s",
174			inet_ntoa(m->group));
175			free(m);
176			return (-1);
177			}
178
179			return (0);
180			}
181
182			int
183			mfc_remove(struct mfc_node *m)
184			{
185			if (RB_REMOVE(mfc_tree, &mfc, m) == NULL) {
186			log_warnx("mfc_remove failed for group %s",
187			inet_ntoa(m->group));
188			return (-1);
189			}
190
191			free(m);
192			return (0);
193			}
194
195			void
196			mfc_clear(void)
197			{
198			struct mfc_node *m;
199
200			while ((m = RB_MIN(mfc_tree, &mfc)) != NULL)
201			mfc_remove(m);
202			}
203
204			void
205			mfc_dump(pid_t pid)
206			{
207			static struct ctl_mfc mfcctl;
208			struct timespec now;
209			struct timeval tv, now2, res;
210			struct mfc_node *mn;
211			int i;
212
213			clock_gettime(CLOCK_MONOTONIC, &now);
214
215			RB_FOREACH(mn, mfc_tree, &mfc) {
216			mfcctl.origin.s_addr = mn->origin.s_addr;
217			mfcctl.group.s_addr = mn->group.s_addr;
218			mfcctl.uptime = now.tv_sec - mn->uptime;
219			mfcctl.ifindex = mn->ifindex;
220
221			for (i = 0; i < MAXVIFS; i ++) {
222			mfcctl.ttls[i] = mn->ttls[i];
223			}
224
225			gettimeofday(&now2, NULL);
226			if (evtimer_pending(&mn->expiration_timer, &tv)) {
227			timersub(&tv, &now2, &res);
228			mfcctl.expire = res.tv_sec;
229			} else
230			mfcctl.expire = -1;
231
232			rde_imsg_compose_dvmrpe(IMSG_CTL_SHOW_MFC, 0, pid, &mfcctl,
233			sizeof(mfcctl));
234			}
235			}
236
237			struct rt_node *
238			mfc_find_origin(struct in_addr group)
239			{
240			struct mfc_node *mn;
241
242			RB_FOREACH(mn, mfc_tree, &mfc)
243			if (group.s_addr == mn->group.s_addr)
244			return (rt_match_origin(mn->origin.s_addr));
245
246			return (NULL);
247			}
248
249			void
250			mfc_send_prune(struct rt_node rn, struct mfc_node mn)
251			{
252			struct prune p;
253
254			memset(&p, 0, sizeof(p));
255
256			p.origin.s_addr = (mn->origin.s_addr &
257			htonl(prefixlen2mask(rn->prefixlen)));
258			p.netmask.s_addr = htonl(prefixlen2mask(rn->prefixlen));
259			p.group.s_addr = mn->group.s_addr;
260			p.nexthop.s_addr = rn->nexthop.s_addr;
261			p.ifindex = mn->ifindex;
262
263			rde_imsg_compose_dvmrpe(IMSG_SEND_PRUNE, 0, 0, &p, sizeof(p));
264
265			mfc_start_prune_timer(mn);
266			}
267
268			void
269			mfc_update_source(struct rt_node *rn)
270			{
271			struct mfc_node *mn;
272			struct mfc m;
273			int i;
274			u_int8_t found;
275
276			RB_FOREACH(mn, mfc_tree, &mfc) {
277			if (rn->prefix.s_addr == (mn->origin.s_addr &
278			htonl(prefixlen2mask(rn->prefixlen)))) {
279			mn->ifindex = rn->ifindex;
280
281			found = 0;
282
283			for (i = 0; i < MAXVIFS; i++) {
284			mn->ttls[i] = rn->ttls[i];
285			if (mn->ttls[i] != 0)
286			found = 1;
287			}
288
289			m.origin.s_addr = mn->origin.s_addr;
290			m.group.s_addr = mn->group.s_addr;
291			m.ifindex = mn->ifindex;
292
293			for (i = 0; i < MAXVIFS; i++)
294			m.ttls[i] = mn->ttls[i];
295
296			rde_imsg_compose_parent(IMSG_MFC_ADD, 0, &m, sizeof(m));
297
298			mfc_reset_expire_timer(mn);
299
300			if (!found && !rn->connected)
301			mfc_send_prune(rn, mn);
302			}
303			}
304			}
305
306			void
307			mfc_update(struct mfc *nmfc)
308			{
309			struct mfc_node *mn;
310			struct rt_node *rn;
311			struct timespec now;
312			int i;
313			u_int8_t found = 0;
314
315			clock_gettime(CLOCK_MONOTONIC, &now);
316
317			if ((mn = mfc_find(nmfc->origin.s_addr, nmfc->group.s_addr)) == NULL) {
318			if ((mn = calloc(1, sizeof(struct mfc_node))) == NULL)
319			fatalx("mfc_update");
320
321			mn->origin.s_addr = nmfc->origin.s_addr;
322			mn->group.s_addr = nmfc->group.s_addr;
323			mn->ifindex = nmfc->ifindex;
324			mn->uptime = now.tv_sec;
325			for (i = 0; i < MAXVIFS; i++) {
326			mn->ttls[i] = nmfc->ttls[i];
327			if (mn->ttls[i] != 0)
328			found = 1;
329			}
330
331			if (mfc_insert(mn) == 0) {
332			rde_imsg_compose_parent(IMSG_MFC_ADD, 0, nmfc,
333			sizeof(*nmfc));
334			}
335
336			evtimer_set(&mn->expiration_timer, mfc_expire_timer, mn);
337			evtimer_set(&mn->prune_timer, mfc_expire_timer, mn);
338			mfc_start_expire_timer(mn);
339
340			if (!found) {
341			/* We removed all downstream interfaces,
342			start the pruning process */
343			rn = rt_match_origin(mn->origin.s_addr);
344			if (rn == NULL) {
345			fatal("mfc_update: cannot find information "
346			" about source");
347			}
348
349			mfc_send_prune(rn, mn);
350			}
351			}
352			}
353
354			void
355			mfc_delete(struct mfc *nmfc)
356			{
357			struct mfc_node *mn;
358
359			if ((mn = mfc_find(nmfc->origin.s_addr, nmfc->group.s_addr)) == NULL)
360			return;
361
362			/* XXX decide if it should really be removed */
363			mfc_remove(mn);
364
365			/* XXX notify parent */
366			}
367
368			int
369			mfc_check_members(struct rt_node rn, struct iface iface)
370			{
371			struct mfc_node *mn;
372
373			RB_FOREACH(mn, mfc_tree, &mfc) {
374			if (mn->origin.s_addr == rn->prefix.s_addr) {
375			if (rde_group_list_find(iface, mn->group) != 0)
376			return (1);
377			}
378			}
379
380			return (0);
381			}
382
383			void
384			mfc_recv_prune(struct prune *p)
385			{
386			struct rt_node *rn;
387			struct mfc_node *mn;
388			struct prune_node *pn;
389			struct iface *iface;
390			struct mfc m;
391
392			iface = if_find_index(p->ifindex);
393			if (iface == NULL) {
394			log_debug("mfc_recv_prune: unknown interface");
395			return;
396			}
397
398			rn = rt_match_origin(p->origin.s_addr);
399			if (rn == NULL) {
400			log_debug("mfc_recv_prune: no information for %s\n",
401			inet_ntoa(p->origin));
402			return;
403			}
404
405			if (srt_find_ds(rn, p->nexthop.s_addr) == NULL) {
406			log_debug("mfc_recv_prune: prune received from a "
407			"non downstream neighbor\n");
408			return;
409			}
410
411			mn = mfc_find(p->origin.s_addr, p->group.s_addr);
412			if (mn) {
413			log_debug("mfc_recv_prune: no information for %s\n",
414			inet_ntoa(p->origin));
415			return;
416			}
417
418			pn = mfc_find_prune(mn, p);
419			if (pn == NULL) {
420			mfc_add_prune(mn, p);
421			if (prune_compare(mn, rn, p->ifindex) &&
422			!rde_group_list_find(iface, p->group)) {
423			mn->ttls[p->ifindex] = 0;
424
425			m.ifindex = p->ifindex;
426			m.origin.s_addr = p->origin.s_addr;
427			m.group.s_addr = p->group.s_addr;
428			mfc_update(&m);
429			}
430			} else
431			mfc_reset_prune_expire_timer(pn);
432			}
433
434			void
435			mfc_add_prune(struct mfc_node mn, struct prune p)
436			{
437			struct prune_node *pn;
438			struct timeval tv;
439
440			pn = calloc(1, sizeof(struct prune));
441			if (pn == NULL)
442			fatal("prune_add");
443
444			timerclear(&tv);
445			tv.tv_sec = MAX_PRUNE_LIFETIME;
446
447			pn->nbr.s_addr = p->nexthop.s_addr;
448			pn->ifindex = p->ifindex;
449			pn->parent = mn;
450
451			evtimer_set(&pn->lifetime_timer, prune_expire_timer, pn);
452			evtimer_add(&pn->lifetime_timer, &tv);
453
454			LIST_INSERT_HEAD(&mn->prune_list, pn, entry);
455
456			mn->prune_cnt[p->ifindex]++;
457			}
458
459			struct prune_node *
460			mfc_find_prune(struct mfc_node mn, struct prune p)
461			{
462			struct prune_node *pn;
463
464			LIST_FOREACH(pn, &mn->prune_list, entry) {
465			if (p->nexthop.s_addr == pn->nbr.s_addr)
466			return (pn);
467			}
468
469			return (NULL);
470			}
471
472			void
473			mfc_delete_prune(struct mfc_node mn, struct prune_node pn)
474			{
475			unsigned int ifindex = pn->ifindex;
476
477			if (evtimer_pending(&pn->lifetime_timer, NULL))
478			if (evtimer_del(&pn->lifetime_timer) == -1)
479			fatal("mfc_delete_prune");
480
481			LIST_REMOVE(pn, entry);
482			free(pn);
483			mn->prune_cnt[ifindex]--;
484			}
485
486			int
487			prune_compare(struct mfc_node mn, struct rt_node rn, int ifindex)
488			{
489			if (mn->prune_cnt[ifindex] == rn->ds_cnt[ifindex])
490			return (1);
491
492			return (0);
493			}
494
495			int
496			mfc_reset_prune_expire_timer(struct prune_node *pn)
497			{
498			struct timeval tv;
499
500			timerclear(&tv);
501			tv.tv_sec = MAX_PRUNE_LIFETIME;
502
503			return (evtimer_add(&pn->lifetime_timer, &tv));
504			}
505
506			void
507			prune_expire_timer(int fd, short event, void *arg)
508			{
509			struct prune_node *pn = arg;
510
511			LIST_REMOVE(pn, entry);
512
513			pn->parent->prune_cnt[pn->ifindex]--;
514			pn->parent->ttls[pn->ifindex] = 1;
515
516			free(pn);
517			}