[mirror_frr.git] / pimd / pim_msg.c

/*
 * PIM for Quagga
 * Copyright (C) 2008  Everton da Silva Marques
 *
 * 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 "if.h"
#include "log.h"
#include "prefix.h"
#include "vty.h"
#include "plist.h"

#include "pimd.h"
#include "pim_vty.h"
#include "pim_pim.h"
#include "pim_msg.h"
#include "pim_util.h"
#include "pim_str.h"
#include "pim_iface.h"
#include "pim_rp.h"
#include "pim_rpf.h"
#include "pim_register.h"
#include "pim_jp_agg.h"
#include "pim_oil.h"

void pim_msg_build_header(uint8_t *pim_msg, size_t pim_msg_size,
			  uint8_t pim_msg_type, bool no_fwd)
{
	struct pim_msg_header *header = (struct pim_msg_header *)pim_msg;

	/*
	 * Write header
	 */
	header->ver = PIM_PROTO_VERSION;
	header->type = pim_msg_type;
	header->Nbit = no_fwd;
	header->reserved = 0;


	header->checksum = 0;
	/*
	 * The checksum for Registers is done only on the first 8 bytes of the
	 * packet,
	 * including the PIM header and the next 4 bytes, excluding the data
	 * packet portion
	 */
	if (pim_msg_type == PIM_MSG_TYPE_REGISTER)
		header->checksum = in_cksum(pim_msg, PIM_MSG_REGISTER_LEN);
	else
		header->checksum = in_cksum(pim_msg, pim_msg_size);
}

uint8_t *pim_msg_addr_encode_ipv4_ucast(uint8_t *buf, struct in_addr addr)
{
	buf[0] = PIM_MSG_ADDRESS_FAMILY_IPV4; /* addr family */
	buf[1] = '\0';			      /* native encoding */
	memcpy(buf + 2, &addr, sizeof(struct in_addr));

	return buf + PIM_ENCODED_IPV4_UCAST_SIZE;
}

uint8_t *pim_msg_addr_encode_ipv4_group(uint8_t *buf, struct in_addr addr)
{
	buf[0] = PIM_MSG_ADDRESS_FAMILY_IPV4; /* addr family */
	buf[1] = '\0';			      /* native encoding */
	buf[2] = '\0';			      /* reserved */
	buf[3] = 32;			      /* mask len */
	memcpy(buf + 4, &addr, sizeof(struct in_addr));

	return buf + PIM_ENCODED_IPV4_GROUP_SIZE;
}

uint8_t *pim_msg_addr_encode_ipv4_source(uint8_t *buf, struct in_addr addr,
					 uint8_t bits)
{
	buf[0] = PIM_MSG_ADDRESS_FAMILY_IPV4; /* addr family */
	buf[1] = '\0';			      /* native encoding */
	buf[2] = bits;
	buf[3] = 32; /* mask len */
	memcpy(buf + 4, &addr, sizeof(struct in_addr));

	return buf + PIM_ENCODED_IPV4_SOURCE_SIZE;
}

/*
 * For the given 'struct pim_jp_sources' list
 * determine the size_t it would take up.
 */
size_t pim_msg_get_jp_group_size(struct list *sources)
{
	struct pim_jp_sources *js;
	size_t size = 0;

	if (!sources)
		return 0;

	size += sizeof(struct pim_encoded_group_ipv4);
	size += 4; // Joined sources (2) + Pruned Sources (2)

	size += sizeof(struct pim_encoded_source_ipv4) * sources->count;

	js = listgetdata(listhead(sources));
	if (js && js->up->sg.src.s_addr == INADDR_ANY && js->is_join) {
		struct pim_upstream *child, *up;
		struct listnode *up_node;

		up = js->up;
		if (PIM_DEBUG_PIM_PACKETS)
			zlog_debug(
				"%s: Considering (%s) children for (S,G,rpt) prune",
				__PRETTY_FUNCTION__, up->sg_str);

		for (ALL_LIST_ELEMENTS_RO(up->sources, up_node, child)) {
			if (child->sptbit == PIM_UPSTREAM_SPTBIT_TRUE) {
				if (!pim_rpf_is_same(&up->rpf, &child->rpf)) {
					size += sizeof(
						struct pim_encoded_source_ipv4);
					PIM_UPSTREAM_FLAG_SET_SEND_SG_RPT_PRUNE(
						child->flags);
					if (PIM_DEBUG_PIM_PACKETS)
						zlog_debug(
							"%s: SPT Bit and RPF'(%s) != RPF'(S,G): Add Prune (%s,rpt) to compound message",
							__PRETTY_FUNCTION__,
							up->sg_str,
							child->sg_str);
				} else if (PIM_DEBUG_PIM_PACKETS)
					zlog_debug(
						"%s: SPT Bit and RPF'(%s) == RPF'(S,G): Not adding Prune for (%s,rpt)",
						__PRETTY_FUNCTION__, up->sg_str,
						child->sg_str);
			} else if (pim_upstream_is_sg_rpt(child)) {
				if (pim_upstream_empty_inherited_olist(child)) {
					size += sizeof(
						struct pim_encoded_source_ipv4);
					PIM_UPSTREAM_FLAG_SET_SEND_SG_RPT_PRUNE(
						child->flags);
					if (PIM_DEBUG_PIM_PACKETS)
						zlog_debug(
							"%s: inherited_olist(%s,rpt) is NULL, Add Prune to compound message",
							__PRETTY_FUNCTION__,
							child->sg_str);
				} else if (!pim_rpf_is_same(&up->rpf,
							    &child->rpf)) {
					size += sizeof(
						struct pim_encoded_source_ipv4);
					PIM_UPSTREAM_FLAG_SET_SEND_SG_RPT_PRUNE(
						child->flags);
					if (PIM_DEBUG_PIM_PACKETS)
						zlog_debug(
							"%s: RPF'(%s) != RPF'(%s,rpt), Add Prune to compound message",
							__PRETTY_FUNCTION__,
							up->sg_str,
							child->sg_str);
				} else if (PIM_DEBUG_PIM_PACKETS)
					zlog_debug(
						"%s: RPF'(%s) == RPF'(%s,rpt), Do not add Prune to compound message",
						__PRETTY_FUNCTION__, up->sg_str,
						child->sg_str);
			} else if (PIM_DEBUG_PIM_PACKETS)
				zlog_debug("%s: SPT bit is not set for (%s)",
					   __PRETTY_FUNCTION__, child->sg_str);
		}
	}
	return size;
}

size_t pim_msg_build_jp_groups(struct pim_jp_groups *grp,
			       struct pim_jp_agg_group *sgs, size_t size)
{
	struct listnode *node, *nnode;
	struct pim_jp_sources *source;
	struct pim_upstream *up = NULL;
	struct in_addr stosend;
	uint8_t bits;
	uint8_t tgroups = 0;

	memset(grp, 0, size);
	pim_msg_addr_encode_ipv4_group((uint8_t *)&grp->g, sgs->group);

	for (ALL_LIST_ELEMENTS(sgs->sources, node, nnode, source)) {
		/* number of joined/pruned sources */
		if (source->is_join)
			grp->joins++;
		else
			grp->prunes++;

		if (source->up->sg.src.s_addr == INADDR_ANY) {
			struct pim_instance *pim = source->up->channel_oil->pim;
			struct pim_rpf *rpf = pim_rp_g(pim, source->up->sg.grp);
			bits = PIM_ENCODE_SPARSE_BIT | PIM_ENCODE_WC_BIT
			       | PIM_ENCODE_RPT_BIT;
			stosend = rpf->rpf_addr.u.prefix4;
			/* Only Send SGRpt in case of *,G Join */
			if (source->is_join)
				up = source->up;
		} else {
			bits = PIM_ENCODE_SPARSE_BIT;
			stosend = source->up->sg.src;
		}

		pim_msg_addr_encode_ipv4_source((uint8_t *)&grp->s[tgroups],
						stosend, bits);
		tgroups++;
	}

	if (up) {
		struct pim_upstream *child;

		for (ALL_LIST_ELEMENTS(up->sources, node, nnode, child)) {
			if (PIM_UPSTREAM_FLAG_TEST_SEND_SG_RPT_PRUNE(
				    child->flags)) {
				pim_msg_addr_encode_ipv4_source(
					(uint8_t *)&grp->s[tgroups],
					child->sg.src,
					PIM_ENCODE_SPARSE_BIT
						| PIM_ENCODE_RPT_BIT);
				tgroups++;
				PIM_UPSTREAM_FLAG_UNSET_SEND_SG_RPT_PRUNE(
					child->flags);
				grp->prunes++;
			}
		}
	}

	grp->joins = htons(grp->joins);
	grp->prunes = htons(grp->prunes);

	return size;
}
Commit	Line	Data
12e41d03	1	/*
896014f4 DL	2	* PIM for Quagga
	3	* Copyright (C) 2008 Everton da Silva Marques
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful, but
	11	* WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License along
	16	* with this program; see the file COPYING; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18	*/
12e41d03 DL	19
	20	#include <zebra.h>
	21
744d91b3	22	#include "if.h"
346cffe3	23	#include "log.h"
dfe43e25 DW	24	#include "prefix.h"
	25	#include "vty.h"
	26	#include "plist.h"
744d91b3	27
12e41d03	28	#include "pimd.h"
75a26779	29	#include "pim_vty.h"
12e41d03 DL	30	#include "pim_pim.h"
	31	#include "pim_msg.h"
	32	#include "pim_util.h"
346cffe3	33	#include "pim_str.h"
7176984f	34	#include "pim_iface.h"
75a26779	35	#include "pim_rp.h"
d67f268e	36	#include "pim_rpf.h"
5637da05	37	#include "pim_register.h"
982bff89	38	#include "pim_jp_agg.h"
92b422f1	39	#include "pim_oil.h"
12e41d03	40
d62a17ae	41	void pim_msg_build_header(uint8_t *pim_msg, size_t pim_msg_size,
d57a8bbf	42	uint8_t pim_msg_type, bool no_fwd)
12e41d03	43	{
d62a17ae	44	struct pim_msg_header header = (struct pim_msg_header )pim_msg;
	45
	46	/*
	47	* Write header
	48	*/
	49	header->ver = PIM_PROTO_VERSION;
	50	header->type = pim_msg_type;
d57a8bbf	51	header->Nbit = no_fwd;
d62a17ae	52	header->reserved = 0;
	53
	54
	55	header->checksum = 0;
	56	/*
	57	* The checksum for Registers is done only on the first 8 bytes of the
	58	* packet,
	59	* including the PIM header and the next 4 bytes, excluding the data
	60	* packet portion
	61	*/
	62	if (pim_msg_type == PIM_MSG_TYPE_REGISTER)
	63	header->checksum = in_cksum(pim_msg, PIM_MSG_REGISTER_LEN);
	64	else
	65	header->checksum = in_cksum(pim_msg, pim_msg_size);
12e41d03 DL	66	}
12e41d03 DL	67
f8e7d799	68	uint8_t pim_msg_addr_encode_ipv4_ucast(uint8_t buf, struct in_addr addr)
12e41d03	69	{
d62a17ae	70	buf[0] = PIM_MSG_ADDRESS_FAMILY_IPV4; /* addr family */
	71	buf[1] = '\0'; /* native encoding */
	72	memcpy(buf + 2, &addr, sizeof(struct in_addr));
12e41d03	73
d62a17ae	74	return buf + PIM_ENCODED_IPV4_UCAST_SIZE;
12e41d03 DL	75	}
12e41d03 DL	76
f8e7d799	77	uint8_t pim_msg_addr_encode_ipv4_group(uint8_t buf, struct in_addr addr)
12e41d03	78	{
d62a17ae	79	buf[0] = PIM_MSG_ADDRESS_FAMILY_IPV4; /* addr family */
	80	buf[1] = '\0'; /* native encoding */
	81	buf[2] = '\0'; /* reserved */
	82	buf[3] = 32; /* mask len */
	83	memcpy(buf + 4, &addr, sizeof(struct in_addr));
12e41d03	84
d62a17ae	85	return buf + PIM_ENCODED_IPV4_GROUP_SIZE;
12e41d03 DL	86	}
12e41d03 DL	87
d62a17ae	88	uint8_t pim_msg_addr_encode_ipv4_source(uint8_t buf, struct in_addr addr,
d62a17ae	89	uint8_t bits)
12e41d03	90	{
d62a17ae	91	buf[0] = PIM_MSG_ADDRESS_FAMILY_IPV4; /* addr family */
	92	buf[1] = '\0'; /* native encoding */
	93	buf[2] = bits;
	94	buf[3] = 32; /* mask len */
	95	memcpy(buf + 4, &addr, sizeof(struct in_addr));
12e41d03	96
d62a17ae	97	return buf + PIM_ENCODED_IPV4_SOURCE_SIZE;
12e41d03	98	}
346cffe3	99
982bff89 DS	100	/*
	101	* For the given 'struct pim_jp_sources' list
	102	* determine the size_t it would take up.
	103	*/
d62a17ae	104	size_t pim_msg_get_jp_group_size(struct list *sources)
982bff89	105	{
d62a17ae	106	struct pim_jp_sources *js;
	107	size_t size = 0;
	108
9403d285 DS	109	if (!sources)
	110	return 0;
	111
d62a17ae	112	size += sizeof(struct pim_encoded_group_ipv4);
	113	size += 4; // Joined sources (2) + Pruned Sources (2)
	114
	115	size += sizeof(struct pim_encoded_source_ipv4) * sources->count;
	116
	117	js = listgetdata(listhead(sources));
be523269	118	if (js && js->up->sg.src.s_addr == INADDR_ANY && js->is_join) {
d62a17ae	119	struct pim_upstream child, up;
	120	struct listnode *up_node;
	121
	122	up = js->up;
	123	if (PIM_DEBUG_PIM_PACKETS)
	124	zlog_debug(
	125	"%s: Considering (%s) children for (S,G,rpt) prune",
	126	__PRETTY_FUNCTION__, up->sg_str);
	127
	128	for (ALL_LIST_ELEMENTS_RO(up->sources, up_node, child)) {
	129	if (child->sptbit == PIM_UPSTREAM_SPTBIT_TRUE) {
	130	if (!pim_rpf_is_same(&up->rpf, &child->rpf)) {
	131	size += sizeof(
	132	struct pim_encoded_source_ipv4);
	133	PIM_UPSTREAM_FLAG_SET_SEND_SG_RPT_PRUNE(
	134	child->flags);
	135	if (PIM_DEBUG_PIM_PACKETS)
	136	zlog_debug(
	137	"%s: SPT Bit and RPF'(%s) != RPF'(S,G): Add Prune (%s,rpt) to compound message",
	138	__PRETTY_FUNCTION__,
	139	up->sg_str,
	140	child->sg_str);
	141	} else if (PIM_DEBUG_PIM_PACKETS)
	142	zlog_debug(
	143	"%s: SPT Bit and RPF'(%s) == RPF'(S,G): Not adding Prune for (%s,rpt)",
	144	__PRETTY_FUNCTION__, up->sg_str,
	145	child->sg_str);
	146	} else if (pim_upstream_is_sg_rpt(child)) {
	147	if (pim_upstream_empty_inherited_olist(child)) {
	148	size += sizeof(
	149	struct pim_encoded_source_ipv4);
	150	PIM_UPSTREAM_FLAG_SET_SEND_SG_RPT_PRUNE(
	151	child->flags);
	152	if (PIM_DEBUG_PIM_PACKETS)
	153	zlog_debug(
	154	"%s: inherited_olist(%s,rpt) is NULL, Add Prune to compound message",
	155	__PRETTY_FUNCTION__,
	156	child->sg_str);
	157	} else if (!pim_rpf_is_same(&up->rpf,
	158	&child->rpf)) {
	159	size += sizeof(
	160	struct pim_encoded_source_ipv4);
	161	PIM_UPSTREAM_FLAG_SET_SEND_SG_RPT_PRUNE(
	162	child->flags);
	163	if (PIM_DEBUG_PIM_PACKETS)
	164	zlog_debug(
	165	"%s: RPF'(%s) != RPF'(%s,rpt), Add Prune to compound message",
	166	__PRETTY_FUNCTION__,
	167	up->sg_str,
	168	child->sg_str);
	169	} else if (PIM_DEBUG_PIM_PACKETS)
	170	zlog_debug(
	171	"%s: RPF'(%s) == RPF'(%s,rpt), Do not add Prune to compound message",
	172	__PRETTY_FUNCTION__, up->sg_str,
	173	child->sg_str);
	174	} else if (PIM_DEBUG_PIM_PACKETS)
	175	zlog_debug("%s: SPT bit is not set for (%s)",
	176	__PRETTY_FUNCTION__, child->sg_str);
	177	}
	178	}
	179	return size;
982bff89 DS	180	}
982bff89 DS	181
d62a17ae	182	size_t pim_msg_build_jp_groups(struct pim_jp_groups *grp,
d62a17ae	183	struct pim_jp_agg_group *sgs, size_t size)
79bdcd99	184	{
d62a17ae	185	struct listnode node, nnode;
	186	struct pim_jp_sources *source;
	187	struct pim_upstream *up = NULL;
	188	struct in_addr stosend;
	189	uint8_t bits;
	190	uint8_t tgroups = 0;
	191
	192	memset(grp, 0, size);
	193	pim_msg_addr_encode_ipv4_group((uint8_t *)&grp->g, sgs->group);
	194
	195	for (ALL_LIST_ELEMENTS(sgs->sources, node, nnode, source)) {
	196	/* number of joined/pruned sources */
	197	if (source->is_join)
	198	grp->joins++;
	199	else
	200	grp->prunes++;
	201
	202	if (source->up->sg.src.s_addr == INADDR_ANY) {
92b422f1 DS	203	struct pim_instance *pim = source->up->channel_oil->pim;
92b422f1 DS	204	struct pim_rpf *rpf = pim_rp_g(pim, source->up->sg.grp);
d62a17ae	205	bits = PIM_ENCODE_SPARSE_BIT \| PIM_ENCODE_WC_BIT
	206	\| PIM_ENCODE_RPT_BIT;
	207	stosend = rpf->rpf_addr.u.prefix4;
	208	/* Only Send SGRpt in case of ,G Join /
	209	if (source->is_join)
	210	up = source->up;
	211	} else {
	212	bits = PIM_ENCODE_SPARSE_BIT;
	213	stosend = source->up->sg.src;
	214	}
	215
	216	pim_msg_addr_encode_ipv4_source((uint8_t *)&grp->s[tgroups],
	217	stosend, bits);
	218	tgroups++;
	219	}
	220
	221	if (up) {
	222	struct pim_upstream *child;
	223
	224	for (ALL_LIST_ELEMENTS(up->sources, node, nnode, child)) {
	225	if (PIM_UPSTREAM_FLAG_TEST_SEND_SG_RPT_PRUNE(
	226	child->flags)) {
	227	pim_msg_addr_encode_ipv4_source(
	228	(uint8_t *)&grp->s[tgroups],
	229	child->sg.src,
	230	PIM_ENCODE_SPARSE_BIT
	231	\| PIM_ENCODE_RPT_BIT);
	232	tgroups++;
	233	PIM_UPSTREAM_FLAG_UNSET_SEND_SG_RPT_PRUNE(
	234	child->flags);
	235	grp->prunes++;
	236	}
	237	}
	238	}
	239
	240	grp->joins = htons(grp->joins);
	241	grp->prunes = htons(grp->prunes);
	242
	243	return size;
346cffe3	244	}