[mirror_frr.git] / pimd / pim_igmpv2.c

/*
 * PIM for Quagga
 * Copyright (C) 2016 Cumulus Networks, Inc.
 * Daniel Walton
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "zebra.h"

#include "pimd.h"
#include "pim_igmp.h"
#include "pim_igmpv2.h"
#include "pim_igmpv3.h"
#include "pim_str.h"
#include "pim_time.h"
#include "pim_util.h"


static void on_trace(const char *label, struct interface *ifp,
		     struct in_addr from)
{
	if (PIM_DEBUG_IGMP_TRACE) {
		char from_str[INET_ADDRSTRLEN];
		pim_inet4_dump("<from?>", from, from_str, sizeof(from_str));
		zlog_debug("%s: from %s on %s", label, from_str, ifp->name);
	}
}

void igmp_v2_send_query(struct igmp_group *group, int fd, const char *ifname,
			char *query_buf, struct in_addr dst_addr,
			struct in_addr group_addr,
			int query_max_response_time_dsec)
{
	ssize_t msg_size = 8;
	uint8_t max_resp_code;
	ssize_t sent;
	struct sockaddr_in to;
	socklen_t tolen;
	uint16_t checksum;

	/* max_resp_code must be non-zero else this will look like an IGMP v1
	 * query */
	max_resp_code = igmp_msg_encode16to8(query_max_response_time_dsec);
	zassert(max_resp_code > 0);

	query_buf[0] = PIM_IGMP_MEMBERSHIP_QUERY;
	query_buf[1] = max_resp_code;
	*(uint16_t *)(query_buf + IGMP_CHECKSUM_OFFSET) =
		0; /* for computing checksum */
	memcpy(query_buf + 4, &group_addr, sizeof(struct in_addr));

	checksum = in_cksum(query_buf, msg_size);
	*(uint16_t *)(query_buf + IGMP_CHECKSUM_OFFSET) = checksum;

	if (PIM_DEBUG_IGMP_PACKETS) {
		char dst_str[INET_ADDRSTRLEN];
		char group_str[INET_ADDRSTRLEN];
		pim_inet4_dump("<dst?>", dst_addr, dst_str, sizeof(dst_str));
		pim_inet4_dump("<group?>", group_addr, group_str,
			       sizeof(group_str));
		zlog_debug("Send IGMPv2 QUERY to %s on %s for group %s",
			   dst_str, ifname, group_str);
	}

	memset(&to, 0, sizeof(to));
	to.sin_family = AF_INET;
	to.sin_addr = dst_addr;
	tolen = sizeof(to);

	sent = sendto(fd, query_buf, msg_size, MSG_DONTWAIT,
		      (struct sockaddr *)&to, tolen);
	if (sent != (ssize_t)msg_size) {
		char dst_str[INET_ADDRSTRLEN];
		char group_str[INET_ADDRSTRLEN];
		pim_inet4_dump("<dst?>", dst_addr, dst_str, sizeof(dst_str));
		pim_inet4_dump("<group?>", group_addr, group_str,
			       sizeof(group_str));
		if (sent < 0) {
			zlog_warn(
				"Send IGMPv2 QUERY failed due to %s on %s: group=%s msg_size=%zd: errno=%d: %s",
				dst_str, ifname, group_str, msg_size, errno,
				safe_strerror(errno));
		} else {
			zlog_warn(
				"Send IGMPv2 QUERY failed due to %s on %s: group=%s msg_size=%zd: sent=%zd",
				dst_str, ifname, group_str, msg_size, sent);
		}
		return;
	}
}

int igmp_v2_recv_report(struct igmp_sock *igmp, struct in_addr from,
			const char *from_str, char *igmp_msg, int igmp_msg_len)
{
	struct interface *ifp = igmp->interface;
	struct in_addr group_addr;
	char group_str[INET_ADDRSTRLEN];

	on_trace(__PRETTY_FUNCTION__, igmp->interface, from);

	if (igmp->mtrace_only)
		return 0;

	if (igmp_msg_len != IGMP_V12_MSG_SIZE) {
		zlog_warn(
			"Recv IGMPv2 REPORT from %s on %s: size=%d other than correct=%d",
			from_str, ifp->name, igmp_msg_len, IGMP_V12_MSG_SIZE);
		return -1;
	}

	/* Collecting IGMP Rx stats */
	igmp->rx_stats.report_v2++;

	memcpy(&group_addr, igmp_msg + 4, sizeof(struct in_addr));

	if (PIM_DEBUG_IGMP_PACKETS) {
		pim_inet4_dump("<dst?>", group_addr, group_str,
			       sizeof(group_str));
		zlog_debug("Recv IGMPv2 REPORT from %s on %s for %s", from_str,
			   ifp->name, group_str);
	}

	/*
	 * RFC 3376
	 * 7.3.2. In the Presence of Older Version Group Members
	 *
	 * When Group Compatibility Mode is IGMPv2, a router internally
	 * translates the following IGMPv2 messages for that group to their
	 * IGMPv3 equivalents:
	 *
	 * IGMPv2 Message                IGMPv3 Equivalent
	 * --------------                -----------------
	 * Report                        IS_EX( {} )
	 * Leave                         TO_IN( {} )
	 */
	igmpv3_report_isex(igmp, from, group_addr, 0, NULL, 1);

	return 0;
}

int igmp_v2_recv_leave(struct igmp_sock *igmp, struct in_addr from,
		       const char *from_str, char *igmp_msg, int igmp_msg_len)
{
	struct interface *ifp = igmp->interface;
	struct in_addr group_addr;
	char group_str[INET_ADDRSTRLEN];

	on_trace(__PRETTY_FUNCTION__, igmp->interface, from);

	if (igmp->mtrace_only)
		return 0;

	if (igmp_msg_len != IGMP_V12_MSG_SIZE) {
		zlog_warn(
			"Recv IGMPv2 LEAVE from %s on %s: size=%d other than correct=%d",
			from_str, ifp->name, igmp_msg_len, IGMP_V12_MSG_SIZE);
		return -1;
	}

	/* Collecting IGMP Rx stats */
	igmp->rx_stats.leave_v2++;

	memcpy(&group_addr, igmp_msg + 4, sizeof(struct in_addr));

	if (PIM_DEBUG_IGMP_PACKETS) {
		pim_inet4_dump("<dst?>", group_addr, group_str,
			       sizeof(group_str));
		zlog_debug("Recv IGMPv2 LEAVE from %s on %s for %s", from_str,
			   ifp->name, group_str);
	}

	/*
	 * RFC 3376
	 * 7.3.2. In the Presence of Older Version Group Members
	 *
	 * When Group Compatibility Mode is IGMPv2, a router internally
	 * translates the following IGMPv2 messages for that group to their
	 * IGMPv3 equivalents:
	 *
	 * IGMPv2 Message                IGMPv3 Equivalent
	 * --------------                -----------------
	 * Report                        IS_EX( {} )
	 * Leave                         TO_IN( {} )
	 */
	igmpv3_report_toin(igmp, from, group_addr, 0, NULL);

	return 0;
}
Commit	Line	Data
b05b72e8 DW	1	/*
	2	* PIM for Quagga
	3	* Copyright (C) 2016 Cumulus Networks, Inc.
	4	* Daniel Walton
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* General Public License for more details.
	15	*
896014f4 DL	16	* You should have received a copy of the GNU General Public License along
	17	* with this program; see the file COPYING; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
b05b72e8 DW	19	*/
b05b72e8 DW	20
fcd6282c DS	21	#include "zebra.h"
fcd6282c DS	22
b05b72e8 DW	23	#include "pimd.h"
	24	#include "pim_igmp.h"
	25	#include "pim_igmpv2.h"
	26	#include "pim_igmpv3.h"
	27	#include "pim_str.h"
	28	#include "pim_time.h"
	29	#include "pim_util.h"
	30
	31
d62a17ae	32	static void on_trace(const char label, struct interface ifp,
d62a17ae	33	struct in_addr from)
b05b72e8	34	{
d62a17ae	35	if (PIM_DEBUG_IGMP_TRACE) {
	36	char from_str[INET_ADDRSTRLEN];
	37	pim_inet4_dump("<from?>", from, from_str, sizeof(from_str));
	38	zlog_debug("%s: from %s on %s", label, from_str, ifp->name);
	39	}
b05b72e8 DW	40	}
b05b72e8 DW	41
d62a17ae	42	void igmp_v2_send_query(struct igmp_group group, int fd, const char ifname,
	43	char *query_buf, struct in_addr dst_addr,
	44	struct in_addr group_addr,
	45	int query_max_response_time_dsec)
b05b72e8	46	{
d62a17ae	47	ssize_t msg_size = 8;
	48	uint8_t max_resp_code;
	49	ssize_t sent;
	50	struct sockaddr_in to;
	51	socklen_t tolen;
	52	uint16_t checksum;
	53
	54	/* max_resp_code must be non-zero else this will look like an IGMP v1
	55	* query */
	56	max_resp_code = igmp_msg_encode16to8(query_max_response_time_dsec);
	57	zassert(max_resp_code > 0);
	58
	59	query_buf[0] = PIM_IGMP_MEMBERSHIP_QUERY;
	60	query_buf[1] = max_resp_code;
	61	(uint16_t )(query_buf + IGMP_CHECKSUM_OFFSET) =
	62	0; /* for computing checksum */
	63	memcpy(query_buf + 4, &group_addr, sizeof(struct in_addr));
	64
	65	checksum = in_cksum(query_buf, msg_size);
	66	(uint16_t )(query_buf + IGMP_CHECKSUM_OFFSET) = checksum;
	67
	68	if (PIM_DEBUG_IGMP_PACKETS) {
	69	char dst_str[INET_ADDRSTRLEN];
	70	char group_str[INET_ADDRSTRLEN];
	71	pim_inet4_dump("<dst?>", dst_addr, dst_str, sizeof(dst_str));
	72	pim_inet4_dump("<group?>", group_addr, group_str,
	73	sizeof(group_str));
	74	zlog_debug("Send IGMPv2 QUERY to %s on %s for group %s",
	75	dst_str, ifname, group_str);
	76	}
	77
	78	memset(&to, 0, sizeof(to));
	79	to.sin_family = AF_INET;
	80	to.sin_addr = dst_addr;
	81	tolen = sizeof(to);
	82
	83	sent = sendto(fd, query_buf, msg_size, MSG_DONTWAIT,
	84	(struct sockaddr *)&to, tolen);
	85	if (sent != (ssize_t)msg_size) {
	86	char dst_str[INET_ADDRSTRLEN];
	87	char group_str[INET_ADDRSTRLEN];
	88	pim_inet4_dump("<dst?>", dst_addr, dst_str, sizeof(dst_str));
	89	pim_inet4_dump("<group?>", group_addr, group_str,
	90	sizeof(group_str));
	91	if (sent < 0) {
	92	zlog_warn(
	93	"Send IGMPv2 QUERY failed due to %s on %s: group=%s msg_size=%zd: errno=%d: %s",
	94	dst_str, ifname, group_str, msg_size, errno,
	95	safe_strerror(errno));
	96	} else {
	97	zlog_warn(
	98	"Send IGMPv2 QUERY failed due to %s on %s: group=%s msg_size=%zd: sent=%zd",
	99	dst_str, ifname, group_str, msg_size, sent);
	100	}
	101	return;
	102	}
b05b72e8 DW	103	}
b05b72e8 DW	104
d62a17ae	105	int igmp_v2_recv_report(struct igmp_sock *igmp, struct in_addr from,
d62a17ae	106	const char from_str, char igmp_msg, int igmp_msg_len)
b05b72e8	107	{
d62a17ae	108	struct interface *ifp = igmp->interface;
	109	struct in_addr group_addr;
	110	char group_str[INET_ADDRSTRLEN];
	111
	112	on_trace(__PRETTY_FUNCTION__, igmp->interface, from);
	113
f83f3966 MS	114	if (igmp->mtrace_only)
	115	return 0;
	116
d62a17ae	117	if (igmp_msg_len != IGMP_V12_MSG_SIZE) {
	118	zlog_warn(
	119	"Recv IGMPv2 REPORT from %s on %s: size=%d other than correct=%d",
	120	from_str, ifp->name, igmp_msg_len, IGMP_V12_MSG_SIZE);
	121	return -1;
	122	}
	123
21313cbf MS	124	/* Collecting IGMP Rx stats */
	125	igmp->rx_stats.report_v2++;
	126
d62a17ae	127	memcpy(&group_addr, igmp_msg + 4, sizeof(struct in_addr));
	128
	129	if (PIM_DEBUG_IGMP_PACKETS) {
	130	pim_inet4_dump("<dst?>", group_addr, group_str,
	131	sizeof(group_str));
	132	zlog_debug("Recv IGMPv2 REPORT from %s on %s for %s", from_str,
	133	ifp->name, group_str);
	134	}
	135
	136	/*
	137	* RFC 3376
	138	* 7.3.2. In the Presence of Older Version Group Members
	139	*
	140	* When Group Compatibility Mode is IGMPv2, a router internally
	141	* translates the following IGMPv2 messages for that group to their
	142	* IGMPv3 equivalents:
	143	*
	144	* IGMPv2 Message IGMPv3 Equivalent
	145	* -------------- -----------------
	146	* Report IS_EX( {} )
	147	* Leave TO_IN( {} )
	148	*/
	149	igmpv3_report_isex(igmp, from, group_addr, 0, NULL, 1);
	150
	151	return 0;
b05b72e8 DW	152	}
b05b72e8 DW	153
d62a17ae	154	int igmp_v2_recv_leave(struct igmp_sock *igmp, struct in_addr from,
d62a17ae	155	const char from_str, char igmp_msg, int igmp_msg_len)
b05b72e8	156	{
d62a17ae	157	struct interface *ifp = igmp->interface;
	158	struct in_addr group_addr;
	159	char group_str[INET_ADDRSTRLEN];
	160
	161	on_trace(__PRETTY_FUNCTION__, igmp->interface, from);
	162
f83f3966 MS	163	if (igmp->mtrace_only)
	164	return 0;
	165
d62a17ae	166	if (igmp_msg_len != IGMP_V12_MSG_SIZE) {
	167	zlog_warn(
	168	"Recv IGMPv2 LEAVE from %s on %s: size=%d other than correct=%d",
	169	from_str, ifp->name, igmp_msg_len, IGMP_V12_MSG_SIZE);
	170	return -1;
	171	}
	172
21313cbf MS	173	/* Collecting IGMP Rx stats */
	174	igmp->rx_stats.leave_v2++;
	175
d62a17ae	176	memcpy(&group_addr, igmp_msg + 4, sizeof(struct in_addr));
	177
	178	if (PIM_DEBUG_IGMP_PACKETS) {
	179	pim_inet4_dump("<dst?>", group_addr, group_str,
	180	sizeof(group_str));
	181	zlog_debug("Recv IGMPv2 LEAVE from %s on %s for %s", from_str,
	182	ifp->name, group_str);
	183	}
	184
	185	/*
	186	* RFC 3376
	187	* 7.3.2. In the Presence of Older Version Group Members
	188	*
	189	* When Group Compatibility Mode is IGMPv2, a router internally
	190	* translates the following IGMPv2 messages for that group to their
	191	* IGMPv3 equivalents:
	192	*
	193	* IGMPv2 Message IGMPv3 Equivalent
	194	* -------------- -----------------
	195	* Report IS_EX( {} )
	196	* Leave TO_IN( {} )
	197	*/
	198	igmpv3_report_toin(igmp, from, group_addr, 0, NULL);
	199
	200	return 0;
b05b72e8	201	}