[mirror_frr.git] / pimd / pim_join.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 "log.h"
#include "prefix.h"
#include "if.h"
#include "vty.h"
#include "plist.h"

#include "pimd.h"
#include "pim_str.h"
#include "pim_tlv.h"
#include "pim_msg.h"
#include "pim_pim.h"
#include "pim_join.h"
#include "pim_oil.h"
#include "pim_iface.h"
#include "pim_hello.h"
#include "pim_ifchannel.h"
#include "pim_rpf.h"
#include "pim_rp.h"
#include "pim_jp_agg.h"
#include "pim_util.h"

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

static void recv_join(struct interface *ifp, struct pim_neighbor *neigh,
		      uint16_t holdtime, struct in_addr upstream,
		      struct prefix_sg *sg, uint8_t source_flags)
{
	struct pim_interface *pim_ifp = NULL;

	if (PIM_DEBUG_PIM_TRACE) {
		char up_str[INET_ADDRSTRLEN];
		char neigh_str[INET_ADDRSTRLEN];
		pim_inet4_dump("<upstream?>", upstream, up_str, sizeof(up_str));
		pim_inet4_dump("<neigh?>", neigh->source_addr, neigh_str,
			       sizeof(neigh_str));
		zlog_debug(
			"%s: join (S,G)=%s rpt=%d wc=%d upstream=%s holdtime=%d from %s on %s",
			__PRETTY_FUNCTION__, pim_str_sg_dump(sg),
			!!(source_flags & PIM_RPT_BIT_MASK),
			!!(source_flags & PIM_WILDCARD_BIT_MASK), up_str,
			holdtime, neigh_str, ifp->name);
	}

	pim_ifp = ifp->info;
	zassert(pim_ifp);

	++pim_ifp->pim_ifstat_join_recv;

	/*
	 * If the RPT and WC are set it's a (*,G)
	 * and the source is the RP
	 */
	if ((source_flags & PIM_RPT_BIT_MASK)
	    && (source_flags & PIM_WILDCARD_BIT_MASK)) {
		struct pim_rpf *rp = RP(pim_ifp->pim, sg->grp);

		if (!rp) {
			zlog_warn("%s: Lookup of RP failed for %pSG4",
				  __PRETTY_FUNCTION__, sg);
			return;
		}
		/*
		 * If the RP sent in the message is not
		 * our RP for the group, drop the message
		 */
		if (sg->src.s_addr != rp->rpf_addr.u.prefix4.s_addr) {
			char received_rp[INET_ADDRSTRLEN];
			char local_rp[INET_ADDRSTRLEN];
			pim_inet4_dump("<received?>", sg->src, received_rp,
				       sizeof(received_rp));
			pim_inet4_dump("<local?>", rp->rpf_addr.u.prefix4,
				       local_rp, sizeof(local_rp));
			zlog_warn("%s: Specified RP(%s) in join is different than our configured RP(%s)",
				  __PRETTY_FUNCTION__, received_rp, local_rp);
			return;
		}

		sg->src.s_addr = INADDR_ANY;
	}

	/* Restart join expiry timer */
	pim_ifchannel_join_add(ifp, neigh->source_addr, upstream, sg,
			       source_flags, holdtime);
}

static void recv_prune(struct interface *ifp, struct pim_neighbor *neigh,
		       uint16_t holdtime, struct in_addr upstream,
		       struct prefix_sg *sg, uint8_t source_flags)
{
	struct pim_interface *pim_ifp = NULL;

	if (PIM_DEBUG_PIM_TRACE) {
		char up_str[INET_ADDRSTRLEN];
		char neigh_str[INET_ADDRSTRLEN];
		pim_inet4_dump("<upstream?>", upstream, up_str, sizeof(up_str));
		pim_inet4_dump("<neigh?>", neigh->source_addr, neigh_str,
			       sizeof(neigh_str));
		zlog_debug(
			"%s: prune (S,G)=%s rpt=%d wc=%d upstream=%s holdtime=%d from %s on %s",
			__PRETTY_FUNCTION__, pim_str_sg_dump(sg),
			source_flags & PIM_RPT_BIT_MASK,
			source_flags & PIM_WILDCARD_BIT_MASK, up_str, holdtime,
			neigh_str, ifp->name);
	}

	pim_ifp = ifp->info;
	zassert(pim_ifp);

	++pim_ifp->pim_ifstat_prune_recv;

	if ((source_flags & PIM_RPT_BIT_MASK)
	    && (source_flags & PIM_WILDCARD_BIT_MASK)) {
		struct pim_rpf *rp = RP(pim_ifp->pim, sg->grp);

		if (!rp) {
			if (PIM_DEBUG_PIM_TRACE)
				zlog_debug("%s: RP for %pSG4 completely failed lookup",
					   __PRETTY_FUNCTION__, sg);
			return;
		}
		// Ignoring Prune *,G's at the moment.
		if (sg->src.s_addr != rp->rpf_addr.u.prefix4.s_addr)
			return;

		sg->src.s_addr = INADDR_ANY;
	}

	pim_ifchannel_prune(ifp, upstream, sg, source_flags, holdtime);
}

int pim_joinprune_recv(struct interface *ifp, struct pim_neighbor *neigh,
		       struct in_addr src_addr, uint8_t *tlv_buf,
		       int tlv_buf_size)
{
	struct prefix msg_upstream_addr;
	struct pim_interface *pim_ifp;
	uint8_t msg_num_groups;
	uint16_t msg_holdtime;
	int addr_offset;
	uint8_t *buf;
	uint8_t *pastend;
	int remain;
	int group;

	buf = tlv_buf;
	pastend = tlv_buf + tlv_buf_size;
	pim_ifp = ifp->info;

	/*
	  Parse ucast addr
	*/
	addr_offset =
		pim_parse_addr_ucast(&msg_upstream_addr, buf, pastend - buf);
	if (addr_offset < 1) {
		char src_str[INET_ADDRSTRLEN];
		pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
		zlog_warn("%s: pim_parse_addr_ucast() failure: from %s on %s",
			  __PRETTY_FUNCTION__, src_str, ifp->name);
		return -1;
	}
	buf += addr_offset;

	/*
	  Check upstream address family
	 */
	if (msg_upstream_addr.family != AF_INET) {
		char src_str[INET_ADDRSTRLEN];
		pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
		zlog_warn("%s: ignoring join/prune directed to unexpected addr family=%d from %s on %s",
			  __PRETTY_FUNCTION__, msg_upstream_addr.family,
			  src_str, ifp->name);
		return -2;
	}

	remain = pastend - buf;
	if (remain < 4) {
		char src_str[INET_ADDRSTRLEN];
		pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
		zlog_warn(
			"%s: short join/prune message buffer for group list: size=%d minimum=%d from %s on %s",
			__PRETTY_FUNCTION__, remain, 4, src_str, ifp->name);
		return -4;
	}

	++buf; /* skip reserved byte */
	msg_num_groups = *(const uint8_t *)buf;
	++buf;
	msg_holdtime = ntohs(*(const uint16_t *)buf);
	++buf;
	++buf;

	if (PIM_DEBUG_PIM_J_P) {
		char src_str[INET_ADDRSTRLEN];
		char upstream_str[INET_ADDRSTRLEN];
		pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
		pim_inet4_dump("<addr?>", msg_upstream_addr.u.prefix4,
			       upstream_str, sizeof(upstream_str));
		zlog_debug(
			"%s: join/prune upstream=%s groups=%d holdtime=%d from %s on %s",
			__PRETTY_FUNCTION__, upstream_str, msg_num_groups,
			msg_holdtime, src_str, ifp->name);
	}

	/* Scan groups */
	for (group = 0; group < msg_num_groups; ++group) {
		struct prefix_sg sg;
		uint8_t msg_source_flags;
		uint16_t msg_num_joined_sources;
		uint16_t msg_num_pruned_sources;
		int source;
		struct pim_ifchannel *starg_ch = NULL, *sg_ch = NULL;
		bool filtered = false;

		memset(&sg, 0, sizeof(struct prefix_sg));
		addr_offset = pim_parse_addr_group(&sg, buf, pastend - buf);
		if (addr_offset < 1) {
			return -5;
		}
		buf += addr_offset;

		remain = pastend - buf;
		if (remain < 4) {
			char src_str[INET_ADDRSTRLEN];
			pim_inet4_dump("<src?>", src_addr, src_str,
				       sizeof(src_str));
			zlog_warn(
				"%s: short join/prune buffer for source list: size=%d minimum=%d from %s on %s",
				__PRETTY_FUNCTION__, remain, 4, src_str,
				ifp->name);
			return -6;
		}

		msg_num_joined_sources = ntohs(*(const uint16_t *)buf);
		buf += 2;
		msg_num_pruned_sources = ntohs(*(const uint16_t *)buf);
		buf += 2;

		if (PIM_DEBUG_PIM_J_P) {
			char src_str[INET_ADDRSTRLEN];
			char upstream_str[INET_ADDRSTRLEN];
			char group_str[INET_ADDRSTRLEN];
			pim_inet4_dump("<src?>", src_addr, src_str,
				       sizeof(src_str));
			pim_inet4_dump("<addr?>", msg_upstream_addr.u.prefix4,
				       upstream_str, sizeof(upstream_str));
			pim_inet4_dump("<grp?>", sg.grp, group_str,
				       sizeof(group_str));
			zlog_debug(
				"%s: join/prune upstream=%s group=%s/32 join_src=%d prune_src=%d from %s on %s",
				__PRETTY_FUNCTION__, upstream_str, group_str,
				msg_num_joined_sources, msg_num_pruned_sources,
				src_str, ifp->name);
		}

		/* boundary check */
		filtered = pim_is_group_filtered(pim_ifp, &sg.grp);

		/* Scan joined sources */
		for (source = 0; source < msg_num_joined_sources; ++source) {
			addr_offset = pim_parse_addr_source(
				&sg, &msg_source_flags, buf, pastend - buf);
			if (addr_offset < 1) {
				return -7;
			}

			buf += addr_offset;

			/* if we are filtering this group, skip the join */
			if (filtered)
				continue;

			recv_join(ifp, neigh, msg_holdtime,
				  msg_upstream_addr.u.prefix4, &sg,
				  msg_source_flags);

			if (sg.src.s_addr == INADDR_ANY) {
				starg_ch = pim_ifchannel_find(ifp, &sg);
				if (starg_ch)
					pim_ifchannel_set_star_g_join_state(
						starg_ch, 0, 1);
			}
		}

		/* Scan pruned sources */
		for (source = 0; source < msg_num_pruned_sources; ++source) {
			addr_offset = pim_parse_addr_source(
				&sg, &msg_source_flags, buf, pastend - buf);
			if (addr_offset < 1) {
				return -8;
			}

			buf += addr_offset;

			/* if we are filtering this group, skip the prune */
			if (filtered)
				continue;

			recv_prune(ifp, neigh, msg_holdtime,
				   msg_upstream_addr.u.prefix4, &sg,
				   msg_source_flags);
			/*
			 * So if we are receiving a S,G,RPT prune
			 * before we have any data for that S,G
			 * We need to retrieve the sg_ch after
			 * we parse the prune.
			 */
			sg_ch = pim_ifchannel_find(ifp, &sg);

			/* Received SG-RPT Prune delete oif from specific S,G */
			if (starg_ch && sg_ch
			    && (msg_source_flags & PIM_RPT_BIT_MASK)
			    && !(msg_source_flags & PIM_WILDCARD_BIT_MASK)) {
				struct pim_upstream *up = sg_ch->upstream;
				PIM_IF_FLAG_SET_S_G_RPT(sg_ch->flags);
				if (up) {
					if (PIM_DEBUG_PIM_TRACE)
						zlog_debug(
							"%s: SGRpt flag is set, del inherit oif from up %s",
							__PRETTY_FUNCTION__,
							up->sg_str);
					pim_channel_del_inherited_oif(
						up->channel_oil,
						starg_ch->interface,
						__func__);
				}
			}
		}
		if (starg_ch && !filtered)
			pim_ifchannel_set_star_g_join_state(starg_ch, 1, 0);
		starg_ch = NULL;
	} /* scan groups */

	return 0;
}

/*
 * J/P Message Format
 *
 * While the RFC clearly states that this is 32 bits wide, it
 * is cheating.  These fields:
 * Encoded-Unicast format   (6 bytes MIN)
 * Encoded-Group format     (8 bytes MIN)
 * Encoded-Source format    (8 bytes MIN)
 * are *not* 32 bits wide.
 *
 * Nor does the RFC explicitly call out the size for:
 * Reserved                 (1 byte)
 * Num Groups               (1 byte)
 * Holdtime                 (2 bytes)
 * Number of Joined Sources (2 bytes)
 * Number of Pruned Sources (2 bytes)
 *
 * This leads to a missleading representation from casual
 * reading and making assumptions.  Be careful!
 *
 *   0                   1                   2                   3
 *   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |PIM Ver| Type  |   Reserved    |           Checksum            |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |        Upstream Neighbor Address (Encoded-Unicast format)     |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |  Reserved     | Num groups    |          Holdtime             |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |         Multicast Group Address 1 (Encoded-Group format)      |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |   Number of Joined Sources    |   Number of Pruned Sources    |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |        Joined Source Address 1 (Encoded-Source format)        |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |                             .                                 |
 *  |                             .                                 |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |        Joined Source Address n (Encoded-Source format)        |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |        Pruned Source Address 1 (Encoded-Source format)        |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |                             .                                 |
 *  |                             .                                 |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |        Pruned Source Address n (Encoded-Source format)        |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |         Multicast Group Address m (Encoded-Group format)      |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |   Number of Joined Sources    |   Number of Pruned Sources    |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |        Joined Source Address 1 (Encoded-Source format)        |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |                             .                                 |
 *  |                             .                                 |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |        Joined Source Address n (Encoded-Source format)        |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |        Pruned Source Address 1 (Encoded-Source format)        |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |                             .                                 |
 *  |                             .                                 |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |        Pruned Source Address n (Encoded-Source format)        |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 */
int pim_joinprune_send(struct pim_rpf *rpf, struct list *groups)
{
	struct pim_jp_agg_group *group;
	struct pim_interface *pim_ifp = NULL;
	struct pim_jp_groups *grp = NULL;
	struct pim_jp *msg = NULL;
	struct listnode *node, *nnode;
	uint8_t pim_msg[10000];
	uint8_t *curr_ptr = pim_msg;
	bool new_packet = true;
	size_t packet_left = 0;
	size_t packet_size = 0;
	size_t group_size = 0;

	if (rpf->source_nexthop.interface)
		pim_ifp = rpf->source_nexthop.interface->info;
	else {
		zlog_warn("%s: RPF interface is not present",
			  __PRETTY_FUNCTION__);
		return -1;
	}

	on_trace(__PRETTY_FUNCTION__, rpf->source_nexthop.interface,
		rpf->rpf_addr.u.prefix4);

	if (!pim_ifp) {
		zlog_warn("%s: multicast not enabled on interface %s",
			  __PRETTY_FUNCTION__,
			  rpf->source_nexthop.interface->name);
		return -1;
	}

	if (PIM_INADDR_IS_ANY(rpf->rpf_addr.u.prefix4)) {
		if (PIM_DEBUG_PIM_J_P) {
			char dst_str[INET_ADDRSTRLEN];
			pim_inet4_dump("<dst?>", rpf->rpf_addr.u.prefix4,
				       dst_str, sizeof(dst_str));
			zlog_debug("%s: upstream=%s is myself on interface %s",
				   __PRETTY_FUNCTION__, dst_str,
				   rpf->source_nexthop.interface->name);
		}
		return 0;
	}

	/*
	  RFC 4601: 4.3.1.  Sending Hello Messages

	  Thus, if a router needs to send a Join/Prune or Assert message on
	  an interface on which it has not yet sent a Hello message with the
	  currently configured IP address, then it MUST immediately send the
	  relevant Hello message without waiting for the Hello Timer to
	  expire, followed by the Join/Prune or Assert message.
	*/
	pim_hello_require(rpf->source_nexthop.interface);

	for (ALL_LIST_ELEMENTS(groups, node, nnode, group)) {
		if (new_packet) {
			msg = (struct pim_jp *)pim_msg;

			memset(msg, 0, sizeof(*msg));

			pim_msg_addr_encode_ipv4_ucast((uint8_t *)&msg->addr,
						       rpf->rpf_addr.u.prefix4);
			msg->reserved = 0;
			msg->holdtime = htons(PIM_JP_HOLDTIME);

			new_packet = false;

			grp = &msg->groups[0];
			curr_ptr = (uint8_t *)grp;
			packet_size = sizeof(struct pim_msg_header);
			packet_size += sizeof(struct pim_encoded_ipv4_unicast);
			packet_size +=
				4; // reserved (1) + groups (1) + holdtime (2)

			packet_left = rpf->source_nexthop.interface->mtu - 24;
			packet_left -= packet_size;
		}
		if (PIM_DEBUG_PIM_J_P) {
			char dst_str[INET_ADDRSTRLEN];
			char grp_str[INET_ADDRSTRLEN];
			pim_inet4_dump("<dst?>", rpf->rpf_addr.u.prefix4,
				       dst_str, sizeof(dst_str));
			pim_inet4_dump("<grp?>", group->group, grp_str,
				       sizeof(grp_str));
			zlog_debug(
				"%s: sending (G)=%s to upstream=%s on interface %s",
				__PRETTY_FUNCTION__, grp_str, dst_str,
				rpf->source_nexthop.interface->name);
		}

		group_size = pim_msg_get_jp_group_size(group->sources);
		if (group_size > packet_left) {
			pim_msg_build_header(pim_msg, packet_size,
					     PIM_MSG_TYPE_JOIN_PRUNE, false);
			if (pim_msg_send(pim_ifp->pim_sock_fd,
					 pim_ifp->primary_address,
					 qpim_all_pim_routers_addr, pim_msg,
					 packet_size,
					 rpf->source_nexthop.interface->name)) {
				zlog_warn(
					"%s: could not send PIM message on interface %s",
					__PRETTY_FUNCTION__,
					rpf->source_nexthop.interface->name);
			}

			msg = (struct pim_jp *)pim_msg;
			memset(msg, 0, sizeof(*msg));

			pim_msg_addr_encode_ipv4_ucast((uint8_t *)&msg->addr,
						       rpf->rpf_addr.u.prefix4);
			msg->reserved = 0;
			msg->holdtime = htons(PIM_JP_HOLDTIME);

			new_packet = false;

			grp = &msg->groups[0];
			curr_ptr = (uint8_t *)grp;
			packet_size = sizeof(struct pim_msg_header);
			packet_size += sizeof(struct pim_encoded_ipv4_unicast);
			packet_size +=
				4; // reserved (1) + groups (1) + holdtime (2)

			packet_left = rpf->source_nexthop.interface->mtu - 24;
			packet_left -= packet_size;
		}

		msg->num_groups++;
		/*
		  Build PIM message
		*/

		curr_ptr += group_size;
		packet_left -= group_size;
		packet_size += group_size;
		pim_msg_build_jp_groups(grp, group, group_size);

		pim_ifp->pim_ifstat_join_send += ntohs(grp->joins);
		pim_ifp->pim_ifstat_prune_send += ntohs(grp->prunes);

		if (PIM_DEBUG_PIM_TRACE)
			zlog_debug(
				"%s: interface %s num_joins %u num_prunes %u",
				__PRETTY_FUNCTION__,
				rpf->source_nexthop.interface->name,
				ntohs(grp->joins), ntohs(grp->prunes));

		grp = (struct pim_jp_groups *)curr_ptr;
		if (packet_left < sizeof(struct pim_jp_groups)
		    || msg->num_groups == 255) {
			pim_msg_build_header(pim_msg, packet_size,
					     PIM_MSG_TYPE_JOIN_PRUNE, false);
			if (pim_msg_send(pim_ifp->pim_sock_fd,
					 pim_ifp->primary_address,
					 qpim_all_pim_routers_addr, pim_msg,
					 packet_size,
					 rpf->source_nexthop.interface->name)) {
				zlog_warn(
					"%s: could not send PIM message on interface %s",
					__PRETTY_FUNCTION__,
					rpf->source_nexthop.interface->name);
			}

			new_packet = true;
		}
	}


	if (!new_packet) {
		// msg->num_groups = htons (msg->num_groups);
		pim_msg_build_header(pim_msg, packet_size,
				     PIM_MSG_TYPE_JOIN_PRUNE, false);
		if (pim_msg_send(pim_ifp->pim_sock_fd, pim_ifp->primary_address,
				 qpim_all_pim_routers_addr, pim_msg,
				 packet_size,
				 rpf->source_nexthop.interface->name)) {
			zlog_warn(
				"%s: could not send PIM message on interface %s",
				__PRETTY_FUNCTION__,
				rpf->source_nexthop.interface->name);
		}
	}
	return 0;
}
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
	22	#include "log.h"
	23	#include "prefix.h"
744d91b3	24	#include "if.h"
dfe43e25 DW	25	#include "vty.h"
dfe43e25 DW	26	#include "plist.h"
12e41d03 DL	27
	28	#include "pimd.h"
	29	#include "pim_str.h"
	30	#include "pim_tlv.h"
	31	#include "pim_msg.h"
	32	#include "pim_pim.h"
	33	#include "pim_join.h"
3667b0bc	34	#include "pim_oil.h"
12e41d03 DL	35	#include "pim_iface.h"
	36	#include "pim_hello.h"
	37	#include "pim_ifchannel.h"
6c629103 DS	38	#include "pim_rpf.h"
6c629103 DS	39	#include "pim_rp.h"
982bff89	40	#include "pim_jp_agg.h"
b0f525a8	41	#include "pim_util.h"
12e41d03	42
d62a17ae	43	static void on_trace(const char label, struct interface ifp,
d62a17ae	44	struct in_addr src)
12e41d03	45	{
d62a17ae	46	if (PIM_DEBUG_PIM_TRACE) {
	47	char src_str[INET_ADDRSTRLEN];
	48	pim_inet4_dump("<src?>", src, src_str, sizeof(src_str));
	49	zlog_debug("%s: from %s on %s", label, src_str, ifp->name);
	50	}
12e41d03 DL	51	}
12e41d03 DL	52
d62a17ae	53	static void recv_join(struct interface ifp, struct pim_neighbor neigh,
	54	uint16_t holdtime, struct in_addr upstream,
	55	struct prefix_sg *sg, uint8_t source_flags)
12e41d03	56	{
d62a17ae	57	struct pim_interface *pim_ifp = NULL;
	58
	59	if (PIM_DEBUG_PIM_TRACE) {
	60	char up_str[INET_ADDRSTRLEN];
	61	char neigh_str[INET_ADDRSTRLEN];
	62	pim_inet4_dump("<upstream?>", upstream, up_str, sizeof(up_str));
	63	pim_inet4_dump("<neigh?>", neigh->source_addr, neigh_str,
	64	sizeof(neigh_str));
fb9670aa	65	zlog_debug(
d62a17ae	66	"%s: join (S,G)=%s rpt=%d wc=%d upstream=%s holdtime=%d from %s on %s",
d62a17ae	67	__PRETTY_FUNCTION__, pim_str_sg_dump(sg),
a57103e9 DS	68	!!(source_flags & PIM_RPT_BIT_MASK),
	69	!!(source_flags & PIM_WILDCARD_BIT_MASK), up_str,
	70	holdtime, neigh_str, ifp->name);
d62a17ae	71	}
	72
	73	pim_ifp = ifp->info;
	74	zassert(pim_ifp);
	75
	76	++pim_ifp->pim_ifstat_join_recv;
	77
	78	/*
	79	* If the RPT and WC are set it's a (*,G)
	80	* and the source is the RP
	81	*/
	82	if ((source_flags & PIM_RPT_BIT_MASK)
	83	&& (source_flags & PIM_WILDCARD_BIT_MASK)) {
fec883d9	84	struct pim_rpf *rp = RP(pim_ifp->pim, sg->grp);
d62a17ae	85
b1945363 DS	86	if (!rp) {
	87	zlog_warn("%s: Lookup of RP failed for %pSG4",
	88	__PRETTY_FUNCTION__, sg);
	89	return;
	90	}
d62a17ae	91	/*
	92	* If the RP sent in the message is not
	93	* our RP for the group, drop the message
	94	*/
a57103e9 DS	95	if (sg->src.s_addr != rp->rpf_addr.u.prefix4.s_addr) {
	96	char received_rp[INET_ADDRSTRLEN];
	97	char local_rp[INET_ADDRSTRLEN];
	98	pim_inet4_dump("<received?>", sg->src, received_rp,
	99	sizeof(received_rp));
	100	pim_inet4_dump("<local?>", rp->rpf_addr.u.prefix4,
	101	local_rp, sizeof(local_rp));
fb9670aa DS	102	zlog_warn("%s: Specified RP(%s) in join is different than our configured RP(%s)",
fb9670aa DS	103	__PRETTY_FUNCTION__, received_rp, local_rp);
d62a17ae	104	return;
a57103e9	105	}
d62a17ae	106
	107	sg->src.s_addr = INADDR_ANY;
	108	}
	109
	110	/* Restart join expiry timer */
	111	pim_ifchannel_join_add(ifp, neigh->source_addr, upstream, sg,
	112	source_flags, holdtime);
12e41d03 DL	113	}
12e41d03 DL	114
d62a17ae	115	static void recv_prune(struct interface ifp, struct pim_neighbor neigh,
	116	uint16_t holdtime, struct in_addr upstream,
	117	struct prefix_sg *sg, uint8_t source_flags)
12e41d03	118	{
d62a17ae	119	struct pim_interface *pim_ifp = NULL;
	120
	121	if (PIM_DEBUG_PIM_TRACE) {
	122	char up_str[INET_ADDRSTRLEN];
	123	char neigh_str[INET_ADDRSTRLEN];
	124	pim_inet4_dump("<upstream?>", upstream, up_str, sizeof(up_str));
	125	pim_inet4_dump("<neigh?>", neigh->source_addr, neigh_str,
	126	sizeof(neigh_str));
fb9670aa	127	zlog_debug(
d62a17ae	128	"%s: prune (S,G)=%s rpt=%d wc=%d upstream=%s holdtime=%d from %s on %s",
	129	__PRETTY_FUNCTION__, pim_str_sg_dump(sg),
	130	source_flags & PIM_RPT_BIT_MASK,
	131	source_flags & PIM_WILDCARD_BIT_MASK, up_str, holdtime,
	132	neigh_str, ifp->name);
	133	}
	134
	135	pim_ifp = ifp->info;
	136	zassert(pim_ifp);
	137
	138	++pim_ifp->pim_ifstat_prune_recv;
	139
	140	if ((source_flags & PIM_RPT_BIT_MASK)
	141	&& (source_flags & PIM_WILDCARD_BIT_MASK)) {
fec883d9	142	struct pim_rpf *rp = RP(pim_ifp->pim, sg->grp);
d62a17ae	143
b1945363 DS	144	if (!rp) {
	145	if (PIM_DEBUG_PIM_TRACE)
	146	zlog_debug("%s: RP for %pSG4 completely failed lookup",
	147	__PRETTY_FUNCTION__, sg);
	148	return;
	149	}
d62a17ae	150	// Ignoring Prune *,G's at the moment.
	151	if (sg->src.s_addr != rp->rpf_addr.u.prefix4.s_addr)
	152	return;
	153
	154	sg->src.s_addr = INADDR_ANY;
	155	}
	156
	157	pim_ifchannel_prune(ifp, upstream, sg, source_flags, holdtime);
12e41d03 DL	158	}
12e41d03 DL	159
d62a17ae	160	int pim_joinprune_recv(struct interface ifp, struct pim_neighbor neigh,
	161	struct in_addr src_addr, uint8_t *tlv_buf,
	162	int tlv_buf_size)
12e41d03	163	{
d62a17ae	164	struct prefix msg_upstream_addr;
b0f525a8	165	struct pim_interface *pim_ifp;
d62a17ae	166	uint8_t msg_num_groups;
	167	uint16_t msg_holdtime;
	168	int addr_offset;
	169	uint8_t *buf;
	170	uint8_t *pastend;
	171	int remain;
	172	int group;
	173
	174	buf = tlv_buf;
	175	pastend = tlv_buf + tlv_buf_size;
b0f525a8	176	pim_ifp = ifp->info;
d62a17ae	177
	178	/*
	179	Parse ucast addr
	180	*/
	181	addr_offset =
	182	pim_parse_addr_ucast(&msg_upstream_addr, buf, pastend - buf);
	183	if (addr_offset < 1) {
	184	char src_str[INET_ADDRSTRLEN];
	185	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	186	zlog_warn("%s: pim_parse_addr_ucast() failure: from %s on %s",
	187	__PRETTY_FUNCTION__, src_str, ifp->name);
	188	return -1;
	189	}
	190	buf += addr_offset;
	191
	192	/*
	193	Check upstream address family
	194	*/
	195	if (msg_upstream_addr.family != AF_INET) {
fb9670aa DS	196	char src_str[INET_ADDRSTRLEN];
	197	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	198	zlog_warn("%s: ignoring join/prune directed to unexpected addr family=%d from %s on %s",
	199	__PRETTY_FUNCTION__, msg_upstream_addr.family,
	200	src_str, ifp->name);
d62a17ae	201	return -2;
	202	}
	203
	204	remain = pastend - buf;
	205	if (remain < 4) {
	206	char src_str[INET_ADDRSTRLEN];
	207	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	208	zlog_warn(
	209	"%s: short join/prune message buffer for group list: size=%d minimum=%d from %s on %s",
	210	__PRETTY_FUNCTION__, remain, 4, src_str, ifp->name);
	211	return -4;
	212	}
	213
	214	++buf; /* skip reserved byte */
	215	msg_num_groups = (const uint8_t )buf;
	216	++buf;
	217	msg_holdtime = ntohs((const uint16_t )buf);
	218	++buf;
	219	++buf;
	220
	221	if (PIM_DEBUG_PIM_J_P) {
	222	char src_str[INET_ADDRSTRLEN];
	223	char upstream_str[INET_ADDRSTRLEN];
	224	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	225	pim_inet4_dump("<addr?>", msg_upstream_addr.u.prefix4,
	226	upstream_str, sizeof(upstream_str));
	227	zlog_debug(
	228	"%s: join/prune upstream=%s groups=%d holdtime=%d from %s on %s",
	229	__PRETTY_FUNCTION__, upstream_str, msg_num_groups,
	230	msg_holdtime, src_str, ifp->name);
	231	}
	232
	233	/* Scan groups */
	234	for (group = 0; group < msg_num_groups; ++group) {
	235	struct prefix_sg sg;
	236	uint8_t msg_source_flags;
	237	uint16_t msg_num_joined_sources;
	238	uint16_t msg_num_pruned_sources;
	239	int source;
	240	struct pim_ifchannel starg_ch = NULL, sg_ch = NULL;
b0f525a8	241	bool filtered = false;
d62a17ae	242
	243	memset(&sg, 0, sizeof(struct prefix_sg));
	244	addr_offset = pim_parse_addr_group(&sg, buf, pastend - buf);
	245	if (addr_offset < 1) {
	246	return -5;
	247	}
	248	buf += addr_offset;
	249
	250	remain = pastend - buf;
	251	if (remain < 4) {
	252	char src_str[INET_ADDRSTRLEN];
	253	pim_inet4_dump("<src?>", src_addr, src_str,
	254	sizeof(src_str));
	255	zlog_warn(
	256	"%s: short join/prune buffer for source list: size=%d minimum=%d from %s on %s",
	257	__PRETTY_FUNCTION__, remain, 4, src_str,
	258	ifp->name);
	259	return -6;
	260	}
	261
	262	msg_num_joined_sources = ntohs((const uint16_t )buf);
	263	buf += 2;
	264	msg_num_pruned_sources = ntohs((const uint16_t )buf);
	265	buf += 2;
	266
	267	if (PIM_DEBUG_PIM_J_P) {
	268	char src_str[INET_ADDRSTRLEN];
	269	char upstream_str[INET_ADDRSTRLEN];
	270	char group_str[INET_ADDRSTRLEN];
	271	pim_inet4_dump("<src?>", src_addr, src_str,
	272	sizeof(src_str));
	273	pim_inet4_dump("<addr?>", msg_upstream_addr.u.prefix4,
	274	upstream_str, sizeof(upstream_str));
	275	pim_inet4_dump("<grp?>", sg.grp, group_str,
	276	sizeof(group_str));
fb9670aa	277	zlog_debug(
d62a17ae	278	"%s: join/prune upstream=%s group=%s/32 join_src=%d prune_src=%d from %s on %s",
	279	__PRETTY_FUNCTION__, upstream_str, group_str,
	280	msg_num_joined_sources, msg_num_pruned_sources,
	281	src_str, ifp->name);
	282	}
	283
b0f525a8 QY	284	/* boundary check */
	285	filtered = pim_is_group_filtered(pim_ifp, &sg.grp);
	286
d62a17ae	287	/* Scan joined sources */
	288	for (source = 0; source < msg_num_joined_sources; ++source) {
	289	addr_offset = pim_parse_addr_source(
	290	&sg, &msg_source_flags, buf, pastend - buf);
	291	if (addr_offset < 1) {
	292	return -7;
	293	}
	294
	295	buf += addr_offset;
	296
b0f525a8 QY	297	/* if we are filtering this group, skip the join */
	298	if (filtered)
	299	continue;
	300
d62a17ae	301	recv_join(ifp, neigh, msg_holdtime,
	302	msg_upstream_addr.u.prefix4, &sg,
	303	msg_source_flags);
	304
	305	if (sg.src.s_addr == INADDR_ANY) {
d62a17ae	306	starg_ch = pim_ifchannel_find(ifp, &sg);
	307	if (starg_ch)
	308	pim_ifchannel_set_star_g_join_state(
c206937b	309	starg_ch, 0, 1);
d62a17ae	310	}
	311	}
	312
	313	/* Scan pruned sources */
	314	for (source = 0; source < msg_num_pruned_sources; ++source) {
	315	addr_offset = pim_parse_addr_source(
	316	&sg, &msg_source_flags, buf, pastend - buf);
	317	if (addr_offset < 1) {
	318	return -8;
	319	}
	320
d62a17ae	321	buf += addr_offset;
b0f525a8 QY	322
	323	/* if we are filtering this group, skip the prune */
	324	if (filtered)
	325	continue;
	326
d62a17ae	327	recv_prune(ifp, neigh, msg_holdtime,
	328	msg_upstream_addr.u.prefix4, &sg,
	329	msg_source_flags);
8e7a4c6e DS	330	/*
	331	* So if we are receiving a S,G,RPT prune
	332	* before we have any data for that S,G
	333	* We need to retrieve the sg_ch after
	334	* we parse the prune.
	335	*/
	336	sg_ch = pim_ifchannel_find(ifp, &sg);
	337
d62a17ae	338	/* Received SG-RPT Prune delete oif from specific S,G */
	339	if (starg_ch && sg_ch
	340	&& (msg_source_flags & PIM_RPT_BIT_MASK)
	341	&& !(msg_source_flags & PIM_WILDCARD_BIT_MASK)) {
	342	struct pim_upstream *up = sg_ch->upstream;
	343	PIM_IF_FLAG_SET_S_G_RPT(sg_ch->flags);
	344	if (up) {
23fc858a	345	if (PIM_DEBUG_PIM_TRACE)
d62a17ae	346	zlog_debug(
	347	"%s: SGRpt flag is set, del inherit oif from up %s",
	348	__PRETTY_FUNCTION__,
	349	up->sg_str);
1537a668	350	pim_channel_del_inherited_oif(
d62a17ae	351	up->channel_oil,
d62a17ae	352	starg_ch->interface,
1b249e70	353	__func__);
d62a17ae	354	}
	355	}
	356	}
b0f525a8	357	if (starg_ch && !filtered)
c206937b	358	pim_ifchannel_set_star_g_join_state(starg_ch, 1, 0);
d62a17ae	359	starg_ch = NULL;
	360	} /* scan groups */
	361
	362	return 0;
12e41d03 DL	363	}
12e41d03 DL	364
982bff89 DS	365	/*
	366	* J/P Message Format
	367	*
	368	* While the RFC clearly states that this is 32 bits wide, it
	369	* is cheating. These fields:
	370	* Encoded-Unicast format (6 bytes MIN)
	371	* Encoded-Group format (8 bytes MIN)
	372	* Encoded-Source format (8 bytes MIN)
	373	* are not 32 bits wide.
	374	*
	375	* Nor does the RFC explicitly call out the size for:
	376	* Reserved (1 byte)
	377	* Num Groups (1 byte)
	378	* Holdtime (2 bytes)
	379	* Number of Joined Sources (2 bytes)
	380	* Number of Pruned Sources (2 bytes)
	381	*
	382	* This leads to a missleading representation from casual
	383	* reading and making assumptions. Be careful!
	384	*
	385	* 0 1 2 3
	386	* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
	387	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	388	* \|PIM Ver\| Type \| Reserved \| Checksum \|
	389	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	390	* \| Upstream Neighbor Address (Encoded-Unicast format) \|
	391	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	392	* \| Reserved \| Num groups \| Holdtime \|
	393	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	394	* \| Multicast Group Address 1 (Encoded-Group format) \|
	395	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	396	* \| Number of Joined Sources \| Number of Pruned Sources \|
	397	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	398	* \| Joined Source Address 1 (Encoded-Source format) \|
	399	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	400	* \| . \|
	401	* \| . \|
	402	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	403	* \| Joined Source Address n (Encoded-Source format) \|
	404	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	405	* \| Pruned Source Address 1 (Encoded-Source format) \|
	406	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	407	* \| . \|
	408	* \| . \|
	409	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	410	* \| Pruned Source Address n (Encoded-Source format) \|
	411	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	412	* \| Multicast Group Address m (Encoded-Group format) \|
	413	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	414	* \| Number of Joined Sources \| Number of Pruned Sources \|
	415	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	416	* \| Joined Source Address 1 (Encoded-Source format) \|
	417	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	418	* \| . \|
	419	* \| . \|
	420	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	421	* \| Joined Source Address n (Encoded-Source format) \|
	422	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	423	* \| Pruned Source Address 1 (Encoded-Source format) \|
	424	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	425	* \| . \|
	426	* \| . \|
	427	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	428	* \| Pruned Source Address n (Encoded-Source format) \|
429	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
430	*/
d62a17ae	431	int pim_joinprune_send(struct pim_rpf rpf, struct list groups)
12e41d03	432	{
d62a17ae	433	struct pim_jp_agg_group *group;
	434	struct pim_interface *pim_ifp = NULL;
	435	struct pim_jp_groups *grp = NULL;
a97986ff	436	struct pim_jp *msg = NULL;
d62a17ae	437	struct listnode node, nnode;
	438	uint8_t pim_msg[10000];
	439	uint8_t *curr_ptr = pim_msg;
	440	bool new_packet = true;
	441	size_t packet_left = 0;
	442	size_t packet_size = 0;
	443	size_t group_size = 0;
	444
d62a17ae	445	if (rpf->source_nexthop.interface)
	446	pim_ifp = rpf->source_nexthop.interface->info;
	447	else {
	448	zlog_warn("%s: RPF interface is not present",
	449	__PRETTY_FUNCTION__);
	450	return -1;
	451	}
	452
957d93ea SP	453	on_trace(__PRETTY_FUNCTION__, rpf->source_nexthop.interface,
	454	rpf->rpf_addr.u.prefix4);
	455
d62a17ae	456	if (!pim_ifp) {
	457	zlog_warn("%s: multicast not enabled on interface %s",
	458	__PRETTY_FUNCTION__,
	459	rpf->source_nexthop.interface->name);
	460	return -1;
	461	}
	462
	463	if (PIM_INADDR_IS_ANY(rpf->rpf_addr.u.prefix4)) {
	464	if (PIM_DEBUG_PIM_J_P) {
	465	char dst_str[INET_ADDRSTRLEN];
	466	pim_inet4_dump("<dst?>", rpf->rpf_addr.u.prefix4,
	467	dst_str, sizeof(dst_str));
	468	zlog_debug("%s: upstream=%s is myself on interface %s",
	469	__PRETTY_FUNCTION__, dst_str,
	470	rpf->source_nexthop.interface->name);
	471	}
	472	return 0;
	473	}
	474
	475	/*
	476	RFC 4601: 4.3.1. Sending Hello Messages
	477
	478	Thus, if a router needs to send a Join/Prune or Assert message on
	479	an interface on which it has not yet sent a Hello message with the
	480	currently configured IP address, then it MUST immediately send the
	481	relevant Hello message without waiting for the Hello Timer to
	482	expire, followed by the Join/Prune or Assert message.
	483	*/
	484	pim_hello_require(rpf->source_nexthop.interface);
	485
	486	for (ALL_LIST_ELEMENTS(groups, node, nnode, group)) {
	487	if (new_packet) {
	488	msg = (struct pim_jp *)pim_msg;
	489
	490	memset(msg, 0, sizeof(*msg));
	491
	492	pim_msg_addr_encode_ipv4_ucast((uint8_t *)&msg->addr,
	493	rpf->rpf_addr.u.prefix4);
	494	msg->reserved = 0;
	495	msg->holdtime = htons(PIM_JP_HOLDTIME);
	496
	497	new_packet = false;
	498
	499	grp = &msg->groups[0];
	500	curr_ptr = (uint8_t *)grp;
	501	packet_size = sizeof(struct pim_msg_header);
	502	packet_size += sizeof(struct pim_encoded_ipv4_unicast);
	503	packet_size +=
	504	4; // reserved (1) + groups (1) + holdtime (2)
	505
	506	packet_left = rpf->source_nexthop.interface->mtu - 24;
	507	packet_left -= packet_size;
	508	}
	509	if (PIM_DEBUG_PIM_J_P) {
	510	char dst_str[INET_ADDRSTRLEN];
	511	char grp_str[INET_ADDRSTRLEN];
	512	pim_inet4_dump("<dst?>", rpf->rpf_addr.u.prefix4,
	513	dst_str, sizeof(dst_str));
	514	pim_inet4_dump("<grp?>", group->group, grp_str,
	515	sizeof(grp_str));
	516	zlog_debug(
	517	"%s: sending (G)=%s to upstream=%s on interface %s",
	518	__PRETTY_FUNCTION__, grp_str, dst_str,
	519	rpf->source_nexthop.interface->name);
520	}
521
522	group_size = pim_msg_get_jp_group_size(group->sources);
523	if (group_size > packet_left) {
524	pim_msg_build_header(pim_msg, packet_size,
d57a8bbf	525	PIM_MSG_TYPE_JOIN_PRUNE, false);
d62a17ae	526	if (pim_msg_send(pim_ifp->pim_sock_fd,
	527	pim_ifp->primary_address,
	528	qpim_all_pim_routers_addr, pim_msg,
	529	packet_size,
	530	rpf->source_nexthop.interface->name)) {
	531	zlog_warn(
	532	"%s: could not send PIM message on interface %s",
	533	__PRETTY_FUNCTION__,
	534	rpf->source_nexthop.interface->name);
	535	}
	536
	537	msg = (struct pim_jp *)pim_msg;
	538	memset(msg, 0, sizeof(*msg));
	539
	540	pim_msg_addr_encode_ipv4_ucast((uint8_t *)&msg->addr,
	541	rpf->rpf_addr.u.prefix4);
	542	msg->reserved = 0;
	543	msg->holdtime = htons(PIM_JP_HOLDTIME);
	544
	545	new_packet = false;
	546
	547	grp = &msg->groups[0];
	548	curr_ptr = (uint8_t *)grp;
	549	packet_size = sizeof(struct pim_msg_header);
	550	packet_size += sizeof(struct pim_encoded_ipv4_unicast);
	551	packet_size +=
	552	4; // reserved (1) + groups (1) + holdtime (2)
	553
	554	packet_left = rpf->source_nexthop.interface->mtu - 24;
	555	packet_left -= packet_size;
	556	}
	557
	558	msg->num_groups++;
	559	/*
	560	Build PIM message
	561	*/
	562
	563	curr_ptr += group_size;
	564	packet_left -= group_size;
	565	packet_size += group_size;
	566	pim_msg_build_jp_groups(grp, group, group_size);
	567
	568	pim_ifp->pim_ifstat_join_send += ntohs(grp->joins);
	569	pim_ifp->pim_ifstat_prune_send += ntohs(grp->prunes);
	570
	571	if (PIM_DEBUG_PIM_TRACE)
	572	zlog_debug(
	573	"%s: interface %s num_joins %u num_prunes %u",
	574	__PRETTY_FUNCTION__,
	575	rpf->source_nexthop.interface->name,
	576	ntohs(grp->joins), ntohs(grp->prunes));
	577
	578	grp = (struct pim_jp_groups *)curr_ptr;
	579	if (packet_left < sizeof(struct pim_jp_groups)
	580	\|\| msg->num_groups == 255) {
	581	pim_msg_build_header(pim_msg, packet_size,
d57a8bbf	582	PIM_MSG_TYPE_JOIN_PRUNE, false);
d62a17ae	583	if (pim_msg_send(pim_ifp->pim_sock_fd,
	584	pim_ifp->primary_address,
	585	qpim_all_pim_routers_addr, pim_msg,
	586	packet_size,
	587	rpf->source_nexthop.interface->name)) {
	588	zlog_warn(
	589	"%s: could not send PIM message on interface %s",
	590	__PRETTY_FUNCTION__,
	591	rpf->source_nexthop.interface->name);
	592	}
	593
	594	new_packet = true;
	595	}
	596	}
	597
	598
	599	if (!new_packet) {
	600	// msg->num_groups = htons (msg->num_groups);
	601	pim_msg_build_header(pim_msg, packet_size,
d57a8bbf	602	PIM_MSG_TYPE_JOIN_PRUNE, false);
d62a17ae	603	if (pim_msg_send(pim_ifp->pim_sock_fd, pim_ifp->primary_address,
	604	qpim_all_pim_routers_addr, pim_msg,
	605	packet_size,
	606	rpf->source_nexthop.interface->name)) {
	607	zlog_warn(
	608	"%s: could not send PIM message on interface %s",
	609	__PRETTY_FUNCTION__,
	610	rpf->source_nexthop.interface->name);
	611	}
	612	}
	613	return 0;
12e41d03	614	}