Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/dvmrpd/group.c	Lines:	0	151	0.0 %
Date:	2017-11-07	Branches:	0	55	0.0 %


/*	$OpenBSD: group.c,v 1.4 2014/11/18 20:54:28 krw Exp $ */

/*
 * 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 <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>
#include <stdlib.h>
#include <string.h>
#include <event.h>

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

void	dead_timer(int, short, void *);
int	start_dead_timer(struct group *);
int	start_dead_timer_all(struct group *);
int	stop_dead_timer(struct group *);

void	v1_host_timer(int, short, void *);
int	start_v1_host_timer(struct group *);
int	stop_v1_host_timer(struct group *);

void	retrans_timer(int, short, void *);
int	start_retrans_timer(struct group *);
int	stop_retrans_timer(struct group *);

extern struct dvmrpd_conf	*deconf;

#define MAX_ACTIONS	4

struct {
	int			state;
	enum group_event	event;
	enum group_action	action[MAX_ACTIONS];
	int			new_state;
} grp_fsm[] = {
    /* current state		event that happened	action(s) to take		resulting state */
    /* querier fsm */
    {GRP_STA_NO_MEMB_PRSNT,	GRP_EVT_V2_REPORT_RCVD,	{GRP_ACT_ADD_GROUP,
							 GRP_ACT_START_TMR,
							 GRP_ACT_END},			GRP_STA_MEMB_PRSNT},
    {GRP_STA_NO_MEMB_PRSNT,	GRP_EVT_V1_REPORT_RCVD,	{GRP_ACT_ADD_GROUP,
							 GRP_ACT_START_TMR,
							 GRP_ACT_START_V1_HOST_TMR,
							 GRP_ACT_END},			GRP_STA_MEMB_PRSNT},

    {GRP_STA_MEMB_PRSNT,	GRP_EVT_TMR_EXPIRED,	{GRP_ACT_DEL_GROUP,
							 GRP_ACT_END},			GRP_STA_NO_MEMB_PRSNT},
    {GRP_STA_MEMB_PRSNT,	GRP_EVT_V2_REPORT_RCVD,	{GRP_ACT_START_TMR,
							 GRP_ACT_END},			0},
    {GRP_STA_MEMB_PRSNT,	GRP_EVT_V1_REPORT_RCVD,	{GRP_ACT_START_TMR,
							 GRP_ACT_START_V1_HOST_TMR,
							 GRP_ACT_END},			GRP_STA_V1_MEMB_PRSNT},
    {GRP_STA_MEMB_PRSNT,	GRP_EVT_LEAVE_RCVD,	{GRP_ACT_START_TMR_ALL,
							 GRP_ACT_START_RETRANS_TMR,
							 GRP_ACT_SEND_GRP_QUERY,
							 GRP_ACT_END},			GRP_STA_CHECK_MEMB},

    {GRP_STA_CHECK_MEMB,	GRP_EVT_V2_REPORT_RCVD,	{GRP_ACT_START_TMR,
							 GRP_ACT_END},			GRP_STA_MEMB_PRSNT},
    {GRP_STA_CHECK_MEMB,	GRP_EVT_TMR_EXPIRED,	{GRP_ACT_DEL_GROUP,
							 GRP_ACT_CLR_RETRANS_TMR,
							 GRP_ACT_END},			GRP_STA_NO_MEMB_PRSNT},
    {GRP_STA_CHECK_MEMB,	GRP_EVT_RETRANS_TMR_EXP,{GRP_ACT_SEND_GRP_QUERY,
							 GRP_ACT_START_RETRANS_TMR,
							 GRP_ACT_END},			0},
    {GRP_STA_CHECK_MEMB,	GRP_EVT_V1_REPORT_RCVD,	{GRP_ACT_START_TMR,
							 GRP_ACT_START_V1_HOST_TMR,
							 GRP_ACT_END},			GRP_STA_V1_MEMB_PRSNT},

    {GRP_STA_V1_MEMB_PRSNT,	GRP_EVT_V1_HOST_TMR_EXP,{GRP_ACT_NOTHING,
							 GRP_ACT_END},			GRP_STA_MEMB_PRSNT},
    {GRP_STA_V1_MEMB_PRSNT,	GRP_EVT_V1_REPORT_RCVD,	{GRP_ACT_START_TMR,
							 GRP_ACT_START_V1_HOST_TMR,
							 GRP_ACT_END},			0},
    {GRP_STA_V1_MEMB_PRSNT,	GRP_EVT_V2_REPORT_RCVD,	{GRP_ACT_START_TMR,
							 GRP_ACT_END},			0},
    {GRP_STA_V1_MEMB_PRSNT,	GRP_EVT_TMR_EXPIRED,	{GRP_ACT_DEL_GROUP,
							 GRP_ACT_END},			GRP_STA_NO_MEMB_PRSNT},

    /* non querier fsm */
    {GRP_STA_NO_MEMB_PRSNT,	GRP_EVT_REPORT_RCVD,	{GRP_ACT_ADD_GROUP,
							 GRP_ACT_START_TMR,
							 GRP_ACT_END},			GRP_STA_MEMB_PRSNT},
    {GRP_STA_MEMB_PRSNT,	GRP_EVT_REPORT_RCVD,	{GRP_ACT_START_TMR,
							 GRP_ACT_END},			0},
    {GRP_STA_MEMB_PRSNT,	GRP_EVT_QUERY_RCVD,	{GRP_ACT_START_TMR_ALL,
							 GRP_ACT_END},			GRP_STA_CHECK_MEMB},

    {GRP_STA_CHECK_MEMB,	GRP_EVT_REPORT_RCVD,	{GRP_ACT_START_TMR,
							 GRP_ACT_END},			GRP_STA_MEMB_PRSNT},
    {-1,			GRP_EVT_NOTHING,	{GRP_ACT_NOTHING,
							 GRP_ACT_END},			0},
};

const char * const group_action_names[] = {
	"END MARKER",
	"START TIMER",
	"START ALL TIMER",
	"START RETRANSMISSION TIMER",
	"START V1 HOST TIMER",
	"SEND GROUP QUERY",
	"ADD GROUP",
	"DEL GROUP",
	"CLEAR RETRANSMISSION TIMER",
	"NOTHING"
};

static const char * const group_event_names[] = {
	"V2 REPORT RCVD",
	"V1 REPORT RCVD",
	"LEAVE RCVD",
	"TIMER EXPIRED",
	"RETRANS TIMER EXPIRED",
	"V1 HOST TIMER EXPIRED",
	"REPORT RCVD",
	"QUERY RCVD",
	"NOTHING"
};

int
group_fsm(struct group *group, enum group_event event)
{
	struct mfc	mfc;
	int		old_state;
	int		new_state = 0;
	int		i, j, ret = 0;

	old_state = group->state;

	for (i = 0; grp_fsm[i].state != -1; i++)
		if ((grp_fsm[i].state & old_state) &&
		    (grp_fsm[i].event == event)) {
			new_state = grp_fsm[i].new_state;
			break;
		}

	if (grp_fsm[i].state == -1) {
		/* XXX event outside of the defined fsm, ignore it. */
		log_debug("group_fsm: group %s, event '%s' not expected in "
		    "state '%s'", inet_ntoa(group->addr),
		    group_event_name(event), group_state_name(old_state));
		return (0);
	}

	for (j = 0; grp_fsm[i].action[j] != GRP_ACT_END; j++) {
		switch (grp_fsm[i].action[j]) {
		case GRP_ACT_START_TMR:
			ret = start_dead_timer(group);
			break;
		case GRP_ACT_START_TMR_ALL:
			ret = start_dead_timer_all(group);
			break;
		case GRP_ACT_START_RETRANS_TMR:
			ret = start_retrans_timer(group);
			break;
		case GRP_ACT_START_V1_HOST_TMR:
			ret = start_v1_host_timer(group);
			break;
		case GRP_ACT_SEND_GRP_QUERY:
			ret = send_igmp_query(group->iface, group);
			break;
		case GRP_ACT_ADD_GROUP:
			mfc.origin.s_addr = 0;
			mfc.group = group->addr;
			mfc.ifindex = group->iface->ifindex;
			dvmrpe_imsg_compose_rde(IMSG_GROUP_ADD, 0, 0, &mfc,
			    sizeof(mfc));
			break;
		case GRP_ACT_DEL_GROUP:
			mfc.origin.s_addr = 0;
			mfc.group = group->addr;
			mfc.ifindex = group->iface->ifindex;
			dvmrpe_imsg_compose_rde(IMSG_GROUP_DEL, 0, 0, &mfc,
			    sizeof(mfc));
			break;
		case GRP_ACT_CLR_RETRANS_TMR:
			ret = stop_retrans_timer(group);
			break;
		case GRP_ACT_NOTHING:
		case GRP_ACT_END:
			/* do nothing */
			break;
		}

		if (ret) {
			log_debug("group_fsm: error changing state for "
			    "group %s, event '%s', state '%s'",
			    inet_ntoa(group->addr), group_event_name(event),
			    group_state_name(old_state));
			return (-1);
		}
	}

	if (new_state != 0)
		group->state = new_state;

	for (j = 0; grp_fsm[i].action[j] != GRP_ACT_END; j++)
		log_debug("group_fsm: event '%s' resulted in action '%s' and "
		    "changing state for group %s from '%s' to '%s'",
		    group_event_name(event),
		    group_action_name(grp_fsm[i].action[j]),
		    inet_ntoa(group->addr), group_state_name(old_state),
		    group_state_name(group->state));

	return (ret);
}

/* timers */
void
dead_timer(int fd, short event, void *arg)
{
	struct group *group = arg;

	log_debug("dead_timer: %s", inet_ntoa(group->addr));

	group_fsm(group, GRP_EVT_TMR_EXPIRED);
}

int
start_dead_timer(struct group *group)
{
	struct timeval	tv;

	log_debug("start_dead_timer: %s", inet_ntoa(group->addr));

	/* Group Membership Interval */
	timerclear(&tv);
	tv.tv_sec = group->iface->robustness * group->iface->query_interval +
	    (group->iface->query_resp_interval / 2);

	return (evtimer_add(&group->dead_timer, &tv));
}

int
start_dead_timer_all(struct group *group)
{
	struct timeval	tv;

	log_debug("start_dead_timer_all: %s", inet_ntoa(group->addr));

	timerclear(&tv);
	if (group->iface->state == IF_STA_QUERIER) {
		/* querier */
		tv.tv_sec = group->iface->last_member_query_interval *
		    group->iface->last_member_query_cnt;
	} else {
		/* non querier */
		/* XXX max response time received in packet */
		tv.tv_sec = group->iface->recv_query_resp_interval *
		    group->iface->last_member_query_cnt;
	}

	return (evtimer_add(&group->dead_timer, &tv));
}

int
stop_dead_timer(struct group *group)
{
	log_debug("stop_dead_timer: %s", inet_ntoa(group->addr));

	return (evtimer_del(&group->dead_timer));
}

void
v1_host_timer(int fd, short event, void *arg)
{
	struct group *group = arg;

	log_debug("v1_host_timer: %s", inet_ntoa(group->addr));

	group_fsm(group, GRP_EVT_V1_HOST_TMR_EXP);
}

int
start_v1_host_timer(struct group *group)
{
	struct timeval	tv;

	log_debug("start_v1_host_timer: %s", inet_ntoa(group->addr));

	/* Group Membership Interval */
	timerclear(&tv);
	tv.tv_sec = group->iface->robustness * group->iface->query_interval +
	    (group->iface->query_resp_interval / 2);

	return (evtimer_add(&group->v1_host_timer, &tv));
}

int
stop_v1_host_timer(struct group *group)
{
	log_debug("stop_v1_host_timer: %s", inet_ntoa(group->addr));

	return (evtimer_del(&group->v1_host_timer));
}

void
retrans_timer(int fd, short event, void *arg)
{
	struct group *group = arg;
	struct timeval tv;

	log_debug("retrans_timer: %s", inet_ntoa(group->addr));

	send_igmp_query(group->iface, group);

	/* reschedule retrans_timer */
	if (group->state == GRP_STA_CHECK_MEMB) {
		timerclear(&tv);
		tv.tv_sec = group->iface->last_member_query_interval;
		evtimer_add(&group->retrans_timer, &tv);
	}
}

int
start_retrans_timer(struct group *group)
{
	struct timeval	tv;

	log_debug("start_retrans_timer: %s", inet_ntoa(group->addr));

	timerclear(&tv);
	tv.tv_sec = group->iface->last_member_query_interval;

	return (evtimer_add(&group->retrans_timer, &tv));
}

int
stop_retrans_timer(struct group *group)
{
	log_debug("stop_retrans_timer: %s", inet_ntoa(group->addr));

	return (evtimer_del(&group->retrans_timer));
}

/* group list */
struct group *
group_list_add(struct iface *iface, u_int32_t group)
{
	struct group	*ge;
	struct timeval	 now;

	/* validate group id */
	if (!IN_MULTICAST(htonl(group)))
		fatalx("group_list_add: invalid group");

	if ((ge = group_list_find(iface, group)) != NULL) {
		return (ge);
	}

	if ((ge = calloc(1, sizeof(*ge))) == NULL)
		fatal("group_list_add");

	ge->addr.s_addr = group;
	ge->state = GRP_STA_NO_MEMB_PRSNT;
	evtimer_set(&ge->dead_timer, dead_timer, ge);
	evtimer_set(&ge->v1_host_timer, v1_host_timer, ge);
	evtimer_set(&ge->retrans_timer, retrans_timer, ge);

	gettimeofday(&now, NULL);
	ge->uptime = now.tv_sec;

	TAILQ_INSERT_TAIL(&iface->group_list, ge, entry);
	iface->group_cnt++;

	ge->iface = iface;

	log_debug("group_list_add: interface %s, group %s", iface->name,
	    inet_ntoa(ge->addr));

	return (ge);
}

void
group_list_remove(struct iface *iface, struct group *group)
{
	log_debug("group_list_remove: interface %s, group %s", iface->name,
	    inet_ntoa(group->addr));

	/* stop timers */
	stop_dead_timer(group);
	start_v1_host_timer(group);
	stop_retrans_timer(group);

	TAILQ_REMOVE(&iface->group_list, group, entry);
	free(group);
	iface->group_cnt--;
}

struct group *
group_list_find(struct iface *iface, u_int32_t group)
{
	struct group	*ge = NULL;

	/* validate group id */
	if (!IN_MULTICAST(htonl(group)))
		fatalx("group_list_find: invalid group");

	TAILQ_FOREACH(ge, &iface->group_list, entry) {
		if (ge->addr.s_addr == group)
			return (ge);
	}

	return (ge);
}

void
group_list_clr(struct iface *iface)
{
	struct group	*ge;

	while ((ge = TAILQ_FIRST(&iface->group_list)) != NULL) {
		TAILQ_REMOVE(&iface->group_list, ge, entry);
		free(ge);
	}
	iface->group_cnt = 0;
}

int
group_list_empty(struct iface *iface)
{
	return (TAILQ_EMPTY(&iface->group_list));
}

void
group_list_dump(struct iface *iface, struct ctl_conn *c)
{
	struct group		*ge;
	struct ctl_group	*gctl;

	TAILQ_FOREACH(ge, &iface->group_list, entry) {
		gctl = group_to_ctl(ge);
		imsg_compose_event(&c->iev, IMSG_CTL_SHOW_IGMP, 0, 0,
		    -1, gctl, sizeof(struct ctl_group));
	}
}

/* names */
const char *
group_event_name(int event)
{
	return (group_event_names[event]);
}

const char *
group_action_name(int action)
{
	return (group_action_names[action]);
}

struct ctl_group *
group_to_ctl(struct group *group)
{
	static struct ctl_group	 gctl;
	struct timeval		 tv, now, res;

	memcpy(&gctl.addr, &group->addr, sizeof(gctl.addr));

	gctl.state = group->state;

	gettimeofday(&now, NULL);
	if (evtimer_pending(&group->dead_timer, &tv)) {
		timersub(&tv, &now, &res);
		gctl.dead_timer = res.tv_sec;
	} else
		gctl.dead_timer = 0;

	if (group->state != GRP_STA_NO_MEMB_PRSNT) {
		gctl.uptime = now.tv_sec - group->uptime;
	} else
		gctl.uptime = 0;

	return (&gctl);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: group.c,v 1.4 2014/11/18 20:54:28 krw Exp $ */
2
3			/*
4			* Copyright (c) 2006 Esben Norby <norby@openbsd.org>
5			*
6			* Permission to use, copy, modify, and distribute this software for any
7			* purpose with or without fee is hereby granted, provided that the above
8			* copyright notice and this permission notice appear in all copies.
9			*
10			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17			*/
18
19			#include <sys/types.h>
20			#include <sys/socket.h>
21			#include <netinet/in.h>
22			#include <arpa/inet.h>
23			#include <sys/time.h>
24			#include <stdlib.h>
25			#include <string.h>
26			#include <event.h>
27
28			#include "igmp.h"
29			#include "dvmrpd.h"
30			#include "dvmrp.h"
31			#include "dvmrpe.h"
32			#include "log.h"
33			#include "control.h"
34
35			void dead_timer(int, short, void *);
36			int start_dead_timer(struct group *);
37			int start_dead_timer_all(struct group *);
38			int stop_dead_timer(struct group *);
39
40			void v1_host_timer(int, short, void *);
41			int start_v1_host_timer(struct group *);
42			int stop_v1_host_timer(struct group *);
43
44			void retrans_timer(int, short, void *);
45			int start_retrans_timer(struct group *);
46			int stop_retrans_timer(struct group *);
47
48			extern struct dvmrpd_conf *deconf;
49
50			#define MAX_ACTIONS 4
51
52			struct {
53			int state;
54			enum group_event event;
55			enum group_action action[MAX_ACTIONS];
56			int new_state;
57			} grp_fsm[] = {
58			/* current state event that happened action(s) to take resulting state */
59			/* querier fsm */
60			{GRP_STA_NO_MEMB_PRSNT, GRP_EVT_V2_REPORT_RCVD, {GRP_ACT_ADD_GROUP,
61			GRP_ACT_START_TMR,
62			GRP_ACT_END}, GRP_STA_MEMB_PRSNT},
63			{GRP_STA_NO_MEMB_PRSNT, GRP_EVT_V1_REPORT_RCVD, {GRP_ACT_ADD_GROUP,
64			GRP_ACT_START_TMR,
65			GRP_ACT_START_V1_HOST_TMR,
66			GRP_ACT_END}, GRP_STA_MEMB_PRSNT},
67
68			{GRP_STA_MEMB_PRSNT, GRP_EVT_TMR_EXPIRED, {GRP_ACT_DEL_GROUP,
69			GRP_ACT_END}, GRP_STA_NO_MEMB_PRSNT},
70			{GRP_STA_MEMB_PRSNT, GRP_EVT_V2_REPORT_RCVD, {GRP_ACT_START_TMR,
71			GRP_ACT_END}, 0},
72			{GRP_STA_MEMB_PRSNT, GRP_EVT_V1_REPORT_RCVD, {GRP_ACT_START_TMR,
73			GRP_ACT_START_V1_HOST_TMR,
74			GRP_ACT_END}, GRP_STA_V1_MEMB_PRSNT},
75			{GRP_STA_MEMB_PRSNT, GRP_EVT_LEAVE_RCVD, {GRP_ACT_START_TMR_ALL,
76			GRP_ACT_START_RETRANS_TMR,
77			GRP_ACT_SEND_GRP_QUERY,
78			GRP_ACT_END}, GRP_STA_CHECK_MEMB},
79
80			{GRP_STA_CHECK_MEMB, GRP_EVT_V2_REPORT_RCVD, {GRP_ACT_START_TMR,
81			GRP_ACT_END}, GRP_STA_MEMB_PRSNT},
82			{GRP_STA_CHECK_MEMB, GRP_EVT_TMR_EXPIRED, {GRP_ACT_DEL_GROUP,
83			GRP_ACT_CLR_RETRANS_TMR,
84			GRP_ACT_END}, GRP_STA_NO_MEMB_PRSNT},
85			{GRP_STA_CHECK_MEMB, GRP_EVT_RETRANS_TMR_EXP,{GRP_ACT_SEND_GRP_QUERY,
86			GRP_ACT_START_RETRANS_TMR,
87			GRP_ACT_END}, 0},
88			{GRP_STA_CHECK_MEMB, GRP_EVT_V1_REPORT_RCVD, {GRP_ACT_START_TMR,
89			GRP_ACT_START_V1_HOST_TMR,
90			GRP_ACT_END}, GRP_STA_V1_MEMB_PRSNT},
91
92			{GRP_STA_V1_MEMB_PRSNT, GRP_EVT_V1_HOST_TMR_EXP,{GRP_ACT_NOTHING,
93			GRP_ACT_END}, GRP_STA_MEMB_PRSNT},
94			{GRP_STA_V1_MEMB_PRSNT, GRP_EVT_V1_REPORT_RCVD, {GRP_ACT_START_TMR,
95			GRP_ACT_START_V1_HOST_TMR,
96			GRP_ACT_END}, 0},
97			{GRP_STA_V1_MEMB_PRSNT, GRP_EVT_V2_REPORT_RCVD, {GRP_ACT_START_TMR,
98			GRP_ACT_END}, 0},
99			{GRP_STA_V1_MEMB_PRSNT, GRP_EVT_TMR_EXPIRED, {GRP_ACT_DEL_GROUP,
100			GRP_ACT_END}, GRP_STA_NO_MEMB_PRSNT},
101
102			/* non querier fsm */
103			{GRP_STA_NO_MEMB_PRSNT, GRP_EVT_REPORT_RCVD, {GRP_ACT_ADD_GROUP,
104			GRP_ACT_START_TMR,
105			GRP_ACT_END}, GRP_STA_MEMB_PRSNT},
106			{GRP_STA_MEMB_PRSNT, GRP_EVT_REPORT_RCVD, {GRP_ACT_START_TMR,
107			GRP_ACT_END}, 0},
108			{GRP_STA_MEMB_PRSNT, GRP_EVT_QUERY_RCVD, {GRP_ACT_START_TMR_ALL,
109			GRP_ACT_END}, GRP_STA_CHECK_MEMB},
110
111			{GRP_STA_CHECK_MEMB, GRP_EVT_REPORT_RCVD, {GRP_ACT_START_TMR,
112			GRP_ACT_END}, GRP_STA_MEMB_PRSNT},
113			{-1, GRP_EVT_NOTHING, {GRP_ACT_NOTHING,
114			GRP_ACT_END}, 0},
115			};
116
117			const char * const group_action_names[] = {
118			"END MARKER",
119			"START TIMER",
120			"START ALL TIMER",
121			"START RETRANSMISSION TIMER",
122			"START V1 HOST TIMER",
123			"SEND GROUP QUERY",
124			"ADD GROUP",
125			"DEL GROUP",
126			"CLEAR RETRANSMISSION TIMER",
127			"NOTHING"
128			};
129
130			static const char * const group_event_names[] = {
131			"V2 REPORT RCVD",
132			"V1 REPORT RCVD",
133			"LEAVE RCVD",
134			"TIMER EXPIRED",
135			"RETRANS TIMER EXPIRED",
136			"V1 HOST TIMER EXPIRED",
137			"REPORT RCVD",
138			"QUERY RCVD",
139			"NOTHING"
140			};
141
142			int
143			group_fsm(struct group *group, enum group_event event)
144			{
145			struct mfc mfc;
146			int old_state;
147			int new_state = 0;
148			int i, j, ret = 0;
149
150			old_state = group->state;
151
152			for (i = 0; grp_fsm[i].state != -1; i++)
153			if ((grp_fsm[i].state & old_state) &&
154			(grp_fsm[i].event == event)) {
155			new_state = grp_fsm[i].new_state;
156			break;
157			}
158
159			if (grp_fsm[i].state == -1) {
160			/* XXX event outside of the defined fsm, ignore it. */
161			log_debug("group_fsm: group %s, event '%s' not expected in "
162			"state '%s'", inet_ntoa(group->addr),
163			group_event_name(event), group_state_name(old_state));
164			return (0);
165			}
166
167			for (j = 0; grp_fsm[i].action[j] != GRP_ACT_END; j++) {
168			switch (grp_fsm[i].action[j]) {
169			case GRP_ACT_START_TMR:
170			ret = start_dead_timer(group);
171			break;
172			case GRP_ACT_START_TMR_ALL:
173			ret = start_dead_timer_all(group);
174			break;
175			case GRP_ACT_START_RETRANS_TMR:
176			ret = start_retrans_timer(group);
177			break;
178			case GRP_ACT_START_V1_HOST_TMR:
179			ret = start_v1_host_timer(group);
180			break;
181			case GRP_ACT_SEND_GRP_QUERY:
182			ret = send_igmp_query(group->iface, group);
183			break;
184			case GRP_ACT_ADD_GROUP:
185			mfc.origin.s_addr = 0;
186			mfc.group = group->addr;
187			mfc.ifindex = group->iface->ifindex;
188			dvmrpe_imsg_compose_rde(IMSG_GROUP_ADD, 0, 0, &mfc,
189			sizeof(mfc));
190			break;
191			case GRP_ACT_DEL_GROUP:
192			mfc.origin.s_addr = 0;
193			mfc.group = group->addr;
194			mfc.ifindex = group->iface->ifindex;
195			dvmrpe_imsg_compose_rde(IMSG_GROUP_DEL, 0, 0, &mfc,
196			sizeof(mfc));
197			break;
198			case GRP_ACT_CLR_RETRANS_TMR:
199			ret = stop_retrans_timer(group);
200			break;
201			case GRP_ACT_NOTHING:
202			case GRP_ACT_END:
203			/* do nothing */
204			break;
205			}
206
207			if (ret) {
208			log_debug("group_fsm: error changing state for "
209			"group %s, event '%s', state '%s'",
210			inet_ntoa(group->addr), group_event_name(event),
211			group_state_name(old_state));
212			return (-1);
213			}
214			}
215
216			if (new_state != 0)
217			group->state = new_state;
218
219			for (j = 0; grp_fsm[i].action[j] != GRP_ACT_END; j++)
220			log_debug("group_fsm: event '%s' resulted in action '%s' and "
221			"changing state for group %s from '%s' to '%s'",
222			group_event_name(event),
223			group_action_name(grp_fsm[i].action[j]),
224			inet_ntoa(group->addr), group_state_name(old_state),
225			group_state_name(group->state));
226
227			return (ret);
228			}
229
230			/* timers */
231			void
232			dead_timer(int fd, short event, void *arg)
233			{
234			struct group *group = arg;
235
236			log_debug("dead_timer: %s", inet_ntoa(group->addr));
237
238			group_fsm(group, GRP_EVT_TMR_EXPIRED);
239			}
240
241			int
242			start_dead_timer(struct group *group)
243			{
244			struct timeval tv;
245
246			log_debug("start_dead_timer: %s", inet_ntoa(group->addr));
247
248			/* Group Membership Interval */
249			timerclear(&tv);
250			tv.tv_sec = group->iface->robustness * group->iface->query_interval +
251			(group->iface->query_resp_interval / 2);
252
253			return (evtimer_add(&group->dead_timer, &tv));
254			}
255
256			int
257			start_dead_timer_all(struct group *group)
258			{
259			struct timeval tv;
260
261			log_debug("start_dead_timer_all: %s", inet_ntoa(group->addr));
262
263			timerclear(&tv);
264			if (group->iface->state == IF_STA_QUERIER) {
265			/* querier */
266			tv.tv_sec = group->iface->last_member_query_interval *
267			group->iface->last_member_query_cnt;
268			} else {
269			/* non querier */
270			/* XXX max response time received in packet */
271			tv.tv_sec = group->iface->recv_query_resp_interval *
272			group->iface->last_member_query_cnt;
273			}
274
275			return (evtimer_add(&group->dead_timer, &tv));
276			}
277
278			int
279			stop_dead_timer(struct group *group)
280			{
281			log_debug("stop_dead_timer: %s", inet_ntoa(group->addr));
282
283			return (evtimer_del(&group->dead_timer));
284			}
285
286			void
287			v1_host_timer(int fd, short event, void *arg)
288			{
289			struct group *group = arg;
290
291			log_debug("v1_host_timer: %s", inet_ntoa(group->addr));
292
293			group_fsm(group, GRP_EVT_V1_HOST_TMR_EXP);
294			}
295
296			int
297			start_v1_host_timer(struct group *group)
298			{
299			struct timeval tv;
300
301			log_debug("start_v1_host_timer: %s", inet_ntoa(group->addr));
302
303			/* Group Membership Interval */
304			timerclear(&tv);
305			tv.tv_sec = group->iface->robustness * group->iface->query_interval +
306			(group->iface->query_resp_interval / 2);
307
308			return (evtimer_add(&group->v1_host_timer, &tv));
309			}
310
311			int
312			stop_v1_host_timer(struct group *group)
313			{
314			log_debug("stop_v1_host_timer: %s", inet_ntoa(group->addr));
315
316			return (evtimer_del(&group->v1_host_timer));
317			}
318
319			void
320			retrans_timer(int fd, short event, void *arg)
321			{
322			struct group *group = arg;
323			struct timeval tv;
324
325			log_debug("retrans_timer: %s", inet_ntoa(group->addr));
326
327			send_igmp_query(group->iface, group);
328
329			/* reschedule retrans_timer */
330			if (group->state == GRP_STA_CHECK_MEMB) {
331			timerclear(&tv);
332			tv.tv_sec = group->iface->last_member_query_interval;
333			evtimer_add(&group->retrans_timer, &tv);
334			}
335			}
336
337			int
338			start_retrans_timer(struct group *group)
339			{
340			struct timeval tv;
341
342			log_debug("start_retrans_timer: %s", inet_ntoa(group->addr));
343
344			timerclear(&tv);
345			tv.tv_sec = group->iface->last_member_query_interval;
346
347			return (evtimer_add(&group->retrans_timer, &tv));
348			}
349
350			int
351			stop_retrans_timer(struct group *group)
352			{
353			log_debug("stop_retrans_timer: %s", inet_ntoa(group->addr));
354
355			return (evtimer_del(&group->retrans_timer));
356			}
357
358			/* group list */
359			struct group *
360			group_list_add(struct iface *iface, u_int32_t group)
361			{
362			struct group *ge;
363			struct timeval now;
364
365			/* validate group id */
366			if (!IN_MULTICAST(htonl(group)))
367			fatalx("group_list_add: invalid group");
368
369			if ((ge = group_list_find(iface, group)) != NULL) {
370			return (ge);
371			}
372
373			if ((ge = calloc(1, sizeof(*ge))) == NULL)
374			fatal("group_list_add");
375
376			ge->addr.s_addr = group;
377			ge->state = GRP_STA_NO_MEMB_PRSNT;
378			evtimer_set(&ge->dead_timer, dead_timer, ge);
379			evtimer_set(&ge->v1_host_timer, v1_host_timer, ge);
380			evtimer_set(&ge->retrans_timer, retrans_timer, ge);
381
382			gettimeofday(&now, NULL);
383			ge->uptime = now.tv_sec;
384
385			TAILQ_INSERT_TAIL(&iface->group_list, ge, entry);
386			iface->group_cnt++;
387
388			ge->iface = iface;
389
390			log_debug("group_list_add: interface %s, group %s", iface->name,
391			inet_ntoa(ge->addr));
392
393			return (ge);
394			}
395
396			void
397			group_list_remove(struct iface iface, struct group group)
398			{
399			log_debug("group_list_remove: interface %s, group %s", iface->name,
400			inet_ntoa(group->addr));
401
402			/* stop timers */
403			stop_dead_timer(group);
404			start_v1_host_timer(group);
405			stop_retrans_timer(group);
406
407			TAILQ_REMOVE(&iface->group_list, group, entry);
408			free(group);
409			iface->group_cnt--;
410			}
411
412			struct group *
413			group_list_find(struct iface *iface, u_int32_t group)
414			{
415			struct group *ge = NULL;
416
417			/* validate group id */
418			if (!IN_MULTICAST(htonl(group)))
419			fatalx("group_list_find: invalid group");
420
421			TAILQ_FOREACH(ge, &iface->group_list, entry) {
422			if (ge->addr.s_addr == group)
423			return (ge);
424			}
425
426			return (ge);
427			}
428
429			void
430			group_list_clr(struct iface *iface)
431			{
432			struct group *ge;
433
434			while ((ge = TAILQ_FIRST(&iface->group_list)) != NULL) {
435			TAILQ_REMOVE(&iface->group_list, ge, entry);
436			free(ge);
437			}
438			iface->group_cnt = 0;
439			}
440
441			int
442			group_list_empty(struct iface *iface)
443			{
444			return (TAILQ_EMPTY(&iface->group_list));
445			}
446
447			void
448			group_list_dump(struct iface iface, struct ctl_conn c)
449			{
450			struct group *ge;
451			struct ctl_group *gctl;
452
453			TAILQ_FOREACH(ge, &iface->group_list, entry) {
454			gctl = group_to_ctl(ge);
455			imsg_compose_event(&c->iev, IMSG_CTL_SHOW_IGMP, 0, 0,
456			-1, gctl, sizeof(struct ctl_group));
457			}
458			}
459
460			/* names */
461			const char *
462			group_event_name(int event)
463			{
464			return (group_event_names[event]);
465			}
466
467			const char *
468			group_action_name(int action)
469			{
470			return (group_action_names[action]);
471			}
472
473			struct ctl_group *
474			group_to_ctl(struct group *group)
475			{
476			static struct ctl_group gctl;
477			struct timeval tv, now, res;
478
479			memcpy(&gctl.addr, &group->addr, sizeof(gctl.addr));
480
481			gctl.state = group->state;
482
483			gettimeofday(&now, NULL);
484			if (evtimer_pending(&group->dead_timer, &tv)) {
485			timersub(&tv, &now, &res);
486			gctl.dead_timer = res.tv_sec;
487			} else
488			gctl.dead_timer = 0;
489
490			if (group->state != GRP_STA_NO_MEMB_PRSNT) {
491			gctl.uptime = now.tv_sec - group->uptime;
492			} else
493			gctl.uptime = 0;
494
495			return (&gctl);
496			}