Adding upstream version 9.1.upstream/9.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1366 insertions, 0 deletions

diff --git a/pimd/pim_mroute.c b/pimd/pim_mroute.c
new file mode 100644
index 0000000..7ea6ed9
--- /dev/null
+++ b/pimd/pim_mroute.c
@@ -0,0 +1,1366 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * PIM for Quagga
+ * Copyright (C) 2008  Everton da Silva Marques
+ */
+
+#include <zebra.h>
+#include "log.h"
+#include "privs.h"
+#include "if.h"
+#include "prefix.h"
+#include "vty.h"
+#include "plist.h"
+#include "sockopt.h"
+#include "lib_errors.h"
+#include "lib/network.h"
+
+#include "pimd.h"
+#include "pim_rpf.h"
+#include "pim_mroute.h"
+#include "pim_oil.h"
+#include "pim_str.h"
+#include "pim_time.h"
+#include "pim_iface.h"
+#include "pim_macro.h"
+#include "pim_rp.h"
+#include "pim_oil.h"
+#include "pim_register.h"
+#include "pim_ifchannel.h"
+#include "pim_zlookup.h"
+#include "pim_ssm.h"
+#include "pim_sock.h"
+#include "pim_vxlan.h"
+#include "pim_msg.h"
+
+static void mroute_read_on(struct pim_instance *pim);
+static int pim_upstream_mroute_update(struct channel_oil *c_oil,
+				      const char *name);
+
+int pim_mroute_set(struct pim_instance *pim, int enable)
+{
+	int err;
+	int opt, data;
+	socklen_t data_len = sizeof(data);
+
+	/*
+	 * We need to create the VRF table for the pim mroute_socket
+	 */
+	if (enable && pim->vrf->vrf_id != VRF_DEFAULT) {
+		frr_with_privs (&pimd_privs) {
+
+			data = pim->vrf->data.l.table_id;
+			err = setsockopt(pim->mroute_socket, PIM_IPPROTO,
+					 MRT_TABLE, &data, data_len);
+			if (err) {
+				zlog_warn(
+					"%s %s: failure: setsockopt(fd=%d,PIM_IPPROTO, MRT_TABLE=%d): errno=%d: %s",
+					__FILE__, __func__, pim->mroute_socket,
+					data, errno, safe_strerror(errno));
+				return -1;
+			}
+		}
+	}
+
+	frr_with_privs (&pimd_privs) {
+		opt = enable ? MRT_INIT : MRT_DONE;
+		/*
+		 * *BSD *cares* about what value we pass down
+		 * here
+		 */
+		data = 1;
+		err = setsockopt(pim->mroute_socket, PIM_IPPROTO, opt, &data,
+				 data_len);
+		if (err) {
+			zlog_warn(
+				"%s %s: failure: setsockopt(fd=%d,PIM_IPPROTO,%s=%d): errno=%d: %s",
+				__FILE__, __func__, pim->mroute_socket,
+				enable ? "MRT_INIT" : "MRT_DONE", data, errno,
+				safe_strerror(errno));
+			return -1;
+		}
+	}
+
+#if defined(HAVE_IP_PKTINFO)
+	if (enable) {
+		/* Linux and Solaris IP_PKTINFO */
+		data = 1;
+		if (setsockopt(pim->mroute_socket, PIM_IPPROTO, IP_PKTINFO,
+			       &data, data_len)) {
+			zlog_warn(
+				"Could not set IP_PKTINFO on socket fd=%d: errno=%d: %s",
+				pim->mroute_socket, errno,
+				safe_strerror(errno));
+		}
+	}
+#endif
+
+#if PIM_IPV == 6
+	if (enable) {
+		/* Linux and Solaris IPV6_PKTINFO */
+		data = 1;
+		if (setsockopt(pim->mroute_socket, PIM_IPPROTO,
+			       IPV6_RECVPKTINFO, &data, data_len)) {
+			zlog_warn(
+				"Could not set IPV6_RECVPKTINFO on socket fd=%d: errno=%d: %s",
+				pim->mroute_socket, errno,
+				safe_strerror(errno));
+		}
+	}
+#endif
+	setsockopt_so_recvbuf(pim->mroute_socket, 1024 * 1024 * 8);
+
+	if (set_nonblocking(pim->mroute_socket) < 0) {
+		zlog_warn(
+			"Could not set non blocking on socket fd=%d: errno=%d: %s",
+			pim->mroute_socket, errno, safe_strerror(errno));
+		return -1;
+	}
+
+	if (enable) {
+#if defined linux
+		int upcalls = GMMSG_WRVIFWHOLE;
+		opt = MRT_PIM;
+
+		err = setsockopt(pim->mroute_socket, PIM_IPPROTO, opt, &upcalls,
+				 sizeof(upcalls));
+		if (err) {
+			zlog_warn(
+				"Failure to register for VIFWHOLE and WRONGVIF upcalls %d %s",
+				errno, safe_strerror(errno));
+			return -1;
+		}
+#else
+		zlog_warn(
+			"PIM-SM will not work properly on this platform, until the ability to receive the WRVIFWHOLE upcall");
+#endif
+	}
+
+	return 0;
+}
+
+static const char *const gmmsgtype2str[GMMSG_WRVIFWHOLE + 1] = {
+	"<unknown_upcall?>", "NOCACHE", "WRONGVIF", "WHOLEPKT", "WRVIFWHOLE"};
+
+
+int pim_mroute_msg_nocache(int fd, struct interface *ifp, const kernmsg *msg)
+{
+	struct pim_interface *pim_ifp = ifp->info;
+	struct pim_upstream *up;
+	pim_sgaddr sg;
+	bool desync = false;
+
+	memset(&sg, 0, sizeof(sg));
+	sg.src = msg->msg_im_src;
+	sg.grp = msg->msg_im_dst;
+
+
+	if (!pim_ifp || !pim_ifp->pim_enable) {
+		if (PIM_DEBUG_MROUTE)
+			zlog_debug(
+				"%s: %s on interface, dropping packet to %pSG",
+				ifp->name,
+				!pim_ifp ? "Multicast not enabled"
+					 : "PIM not enabled",
+				&sg);
+		return 0;
+	}
+
+	if (!pim_is_grp_ssm(pim_ifp->pim, sg.grp)) {
+		/* for ASM, check that we have enough information (i.e. path
+		 * to RP) to make a decision on what to do with this packet.
+		 *
+		 * for SSM, this is meaningless, everything is join-driven,
+		 * and for NOCACHE we need to install an empty OIL MFC entry
+		 * so the kernel doesn't keep nagging us.
+		 */
+		struct pim_rpf *rpg;
+
+		rpg = RP(pim_ifp->pim, msg->msg_im_dst);
+		if (!rpg) {
+			if (PIM_DEBUG_MROUTE)
+				zlog_debug("%s: no RPF for packet to %pSG",
+					   ifp->name, &sg);
+			return 0;
+		}
+		if (pim_rpf_addr_is_inaddr_any(rpg)) {
+			if (PIM_DEBUG_MROUTE)
+				zlog_debug("%s: null RPF for packet to %pSG",
+					   ifp->name, &sg);
+			return 0;
+		}
+	}
+
+	/*
+	 * If we've received a multicast packet that isn't connected to
+	 * us
+	 */
+	if (!pim_if_connected_to_source(ifp, msg->msg_im_src)) {
+		if (PIM_DEBUG_MROUTE)
+			zlog_debug(
+				"%s: incoming packet to %pSG from non-connected source",
+				ifp->name, &sg);
+		return 0;
+	}
+
+	if (!(PIM_I_am_DR(pim_ifp))) {
+		/* unlike the other debug messages, this one is further in the
+		 * "normal operation" category and thus under _DETAIL
+		 */
+		if (PIM_DEBUG_MROUTE_DETAIL)
+			zlog_debug(
+				"%s: not DR on interface, not forwarding traffic for %pSG",
+				ifp->name, &sg);
+
+		/*
+		 * We are not the DR, but we are still receiving packets
+		 * Let's blackhole those packets for the moment
+		 * As that they will be coming up to the cpu
+		 * and causing us to consider them.
+		 *
+		 * This *will* create a dangling channel_oil
+		 * that I see no way to get rid of.  Just noting
+		 * this for future reference.
+		 */
+		up = pim_upstream_find_or_add(
+			&sg, ifp, PIM_UPSTREAM_FLAG_MASK_SRC_NOCACHE, __func__);
+		pim_upstream_mroute_add(up->channel_oil, __func__);
+
+		return 0;
+	}
+
+	up = pim_upstream_find_or_add(&sg, ifp, PIM_UPSTREAM_FLAG_MASK_FHR,
+				      __func__);
+	if (up->channel_oil->installed) {
+		zlog_warn(
+			"%s: NOCACHE for %pSG, MFC entry disappeared - reinstalling",
+			ifp->name, &sg);
+		desync = true;
+	}
+
+	/*
+	 * I moved this debug till after the actual add because
+	 * I want to take advantage of the up->sg_str being filled in.
+	 */
+	if (PIM_DEBUG_MROUTE) {
+		zlog_debug("%s: Adding a Route %s for WHOLEPKT consumption",
+			   __func__, up->sg_str);
+	}
+
+	PIM_UPSTREAM_FLAG_SET_SRC_STREAM(up->flags);
+	pim_upstream_keep_alive_timer_start(up, pim_ifp->pim->keep_alive_time);
+
+	up->channel_oil->cc.pktcnt++;
+	// resolve mfcc_parent prior to mroute_add in channel_add_oif
+	if (up->rpf.source_nexthop.interface &&
+	    *oil_incoming_vif(up->channel_oil) >= MAXVIFS) {
+		pim_upstream_mroute_iif_update(up->channel_oil, __func__);
+	}
+	pim_register_join(up);
+	/* if we have receiver, inherit from parent */
+	pim_upstream_inherited_olist_decide(pim_ifp->pim, up);
+
+	/* we just got NOCACHE from the kernel, so...  MFC is not in the
+	 * kernel for some reason or another.  Try installing again.
+	 */
+	if (desync)
+		pim_upstream_mroute_update(up->channel_oil, __func__);
+	return 0;
+}
+
+int pim_mroute_msg_wholepkt(int fd, struct interface *ifp, const char *buf,
+			    size_t len)
+{
+	struct pim_interface *pim_ifp;
+	pim_sgaddr sg;
+	struct pim_rpf *rpg;
+	const ipv_hdr *ip_hdr;
+	struct pim_upstream *up;
+
+	pim_ifp = ifp->info;
+
+	ip_hdr = (const ipv_hdr *)buf;
+
+	memset(&sg, 0, sizeof(sg));
+	sg.src = IPV_SRC(ip_hdr);
+	sg.grp = IPV_DST(ip_hdr);
+
+	up = pim_upstream_find(pim_ifp->pim, &sg);
+	if (!up) {
+		pim_sgaddr star = sg;
+		star.src = PIMADDR_ANY;
+
+		up = pim_upstream_find(pim_ifp->pim, &star);
+
+		if (up && PIM_UPSTREAM_FLAG_TEST_CAN_BE_LHR(up->flags)) {
+			up = pim_upstream_add(pim_ifp->pim, &sg, ifp,
+					      PIM_UPSTREAM_FLAG_MASK_SRC_LHR,
+					      __func__, NULL);
+			if (!up) {
+				if (PIM_DEBUG_MROUTE)
+					zlog_debug(
+						"%s: Unable to create upstream information for %pSG",
+						__func__, &sg);
+				return 0;
+			}
+			pim_upstream_keep_alive_timer_start(
+				up, pim_ifp->pim->keep_alive_time);
+			pim_upstream_inherited_olist(pim_ifp->pim, up);
+			pim_upstream_update_join_desired(pim_ifp->pim, up);
+
+			if (PIM_DEBUG_MROUTE)
+				zlog_debug("%s: Creating %s upstream on LHR",
+					   __func__, up->sg_str);
+			return 0;
+		}
+		if (PIM_DEBUG_MROUTE_DETAIL) {
+			zlog_debug(
+				"%s: Unable to find upstream channel WHOLEPKT%pSG",
+				__func__, &sg);
+		}
+		return 0;
+	}
+
+	if (!up->rpf.source_nexthop.interface) {
+		if (PIM_DEBUG_PIM_TRACE)
+			zlog_debug("%s: up %s RPF is not present", __func__,
+				   up->sg_str);
+		return 0;
+	}
+
+	pim_ifp = up->rpf.source_nexthop.interface->info;
+
+	rpg = pim_ifp ? RP(pim_ifp->pim, sg.grp) : NULL;
+
+	if ((pim_rpf_addr_is_inaddr_any(rpg)) || (!pim_ifp) ||
+	    (!(PIM_I_am_DR(pim_ifp)))) {
+		if (PIM_DEBUG_MROUTE) {
+			zlog_debug("%s: Failed Check send packet", __func__);
+		}
+		return 0;
+	}
+
+	/*
+	 * If we've received a register suppress
+	 */
+	if (!up->t_rs_timer) {
+		if (pim_is_grp_ssm(pim_ifp->pim, sg.grp)) {
+			if (PIM_DEBUG_PIM_REG)
+				zlog_debug(
+					"%pSG register forward skipped as group is SSM",
+					&sg);
+			return 0;
+		}
+
+		if (!PIM_UPSTREAM_FLAG_TEST_FHR(up->flags)) {
+			if (PIM_DEBUG_PIM_REG)
+				zlog_debug(
+					"%s register forward skipped, not FHR",
+					up->sg_str);
+			return 0;
+		}
+
+		pim_register_send((uint8_t *)buf + sizeof(ipv_hdr),
+				  len - sizeof(ipv_hdr),
+				  pim_ifp->primary_address, rpg, 0, up);
+	}
+	return 0;
+}
+
+int pim_mroute_msg_wrongvif(int fd, struct interface *ifp, const kernmsg *msg)
+{
+	struct pim_ifchannel *ch;
+	struct pim_interface *pim_ifp;
+	pim_sgaddr sg;
+
+	memset(&sg, 0, sizeof(sg));
+	sg.src = msg->msg_im_src;
+	sg.grp = msg->msg_im_dst;
+
+	/*
+	  Send Assert(S,G) on iif as response to WRONGVIF kernel upcall.
+
+	  RFC 4601 4.8.2.  PIM-SSM-Only Routers
+
+	  iif is the incoming interface of the packet.
+	  if (iif is in inherited_olist(S,G)) {
+	  send Assert(S,G) on iif
+	  }
+	*/
+
+	if (!ifp) {
+		if (PIM_DEBUG_MROUTE)
+			zlog_debug(
+				"%s: WRONGVIF (S,G)=%pSG could not find input interface for input_vif_index=%d",
+				__func__, &sg, msg->msg_im_vif);
+		return -1;
+	}
+
+	pim_ifp = ifp->info;
+	if (!pim_ifp) {
+		if (PIM_DEBUG_MROUTE)
+			zlog_debug(
+				"%s: WRONGVIF (S,G)=%pSG multicast not enabled on interface %s",
+				__func__, &sg, ifp->name);
+		return -2;
+	}
+
+	ch = pim_ifchannel_find(ifp, &sg);
+	if (!ch) {
+		pim_sgaddr star_g = sg;
+		if (PIM_DEBUG_MROUTE)
+			zlog_debug(
+				"%s: WRONGVIF (S,G)=%pSG could not find channel on interface %s",
+				__func__, &sg, ifp->name);
+
+		star_g.src = PIMADDR_ANY;
+		ch = pim_ifchannel_find(ifp, &star_g);
+		if (!ch) {
+			if (PIM_DEBUG_MROUTE)
+				zlog_debug(
+					"%s: WRONGVIF (*,G)=%pSG could not find channel on interface %s",
+					__func__, &star_g, ifp->name);
+			return -3;
+		}
+	}
+
+	/*
+	  RFC 4601: 4.6.1.  (S,G) Assert Message State Machine
+
+	  Transitions from NoInfo State
+
+	  An (S,G) data packet arrives on interface I, AND
+	  CouldAssert(S,G,I)==TRUE An (S,G) data packet arrived on an
+	  downstream interface that is in our (S,G) outgoing interface
+	  list.  We optimistically assume that we will be the assert
+	  winner for this (S,G), and so we transition to the "I am Assert
+	  Winner" state and perform Actions A1 (below), which will
+	  initiate the assert negotiation for (S,G).
+	*/
+
+	if (ch->ifassert_state != PIM_IFASSERT_NOINFO) {
+		if (PIM_DEBUG_MROUTE) {
+			zlog_debug(
+				"%s: WRONGVIF (S,G)=%s channel is not on Assert NoInfo state for interface %s",
+				__func__, ch->sg_str, ifp->name);
+		}
+		return -4;
+	}
+
+	if (!PIM_IF_FLAG_TEST_COULD_ASSERT(ch->flags)) {
+		if (PIM_DEBUG_MROUTE) {
+			zlog_debug(
+				"%s: WRONGVIF (S,G)=%s interface %s is not downstream for channel",
+				__func__, ch->sg_str, ifp->name);
+		}
+		return -5;
+	}
+
+	if (assert_action_a1(ch)) {
+		if (PIM_DEBUG_MROUTE) {
+			zlog_debug(
+				"%s: WRONGVIF (S,G)=%s assert_action_a1 failure on interface %s",
+				__func__, ch->sg_str, ifp->name);
+		}
+		return -6;
+	}
+
+	return 0;
+}
+
+int pim_mroute_msg_wrvifwhole(int fd, struct interface *ifp, const char *buf,
+			      size_t len)
+{
+	const ipv_hdr *ip_hdr = (const ipv_hdr *)buf;
+	struct pim_interface *pim_ifp;
+	struct pim_instance *pim;
+	struct pim_ifchannel *ch;
+	struct pim_upstream *up;
+	pim_sgaddr star_g;
+	pim_sgaddr sg;
+
+	pim_ifp = ifp->info;
+
+	memset(&sg, 0, sizeof(sg));
+	sg.src = IPV_SRC(ip_hdr);
+	sg.grp = IPV_DST(ip_hdr);
+
+	ch = pim_ifchannel_find(ifp, &sg);
+	if (ch) {
+		if (PIM_DEBUG_MROUTE)
+			zlog_debug(
+				"WRVIFWHOLE (S,G)=%s found ifchannel on interface %s",
+				ch->sg_str, ifp->name);
+		return -1;
+	}
+
+	star_g = sg;
+	star_g.src = PIMADDR_ANY;
+
+	pim = pim_ifp->pim;
+	/*
+	 * If the incoming interface is the pimreg, then
+	 * we know the callback is associated with a pim register
+	 * packet and there is nothing to do here as that
+	 * normal pim processing will see the packet and allow
+	 * us to do the right thing.
+	 */
+	if (ifp == pim->regiface) {
+		return 0;
+	}
+
+	up = pim_upstream_find(pim_ifp->pim, &sg);
+	if (up) {
+		struct pim_upstream *parent;
+		struct pim_nexthop source;
+		struct pim_rpf *rpf = RP(pim_ifp->pim, sg.grp);
+
+		/* No RPF or No RPF interface or No mcast on RPF interface */
+		if (!rpf || !rpf->source_nexthop.interface ||
+		    !rpf->source_nexthop.interface->info)
+			return 0;
+
+		/*
+		 * If we have received a WRVIFWHOLE and are at this
+		 * point, we could be receiving the packet on the *,G
+		 * tree, let's check and if so we can safely drop
+		 * it.
+		 */
+		parent = pim_upstream_find(pim_ifp->pim, &star_g);
+		if (parent && parent->rpf.source_nexthop.interface == ifp)
+			return 0;
+
+		pim_ifp = rpf->source_nexthop.interface->info;
+
+		memset(&source, 0, sizeof(source));
+		/*
+		 * If we are the fhr that means we are getting a callback during
+		 * the pimreg period, so I believe we can ignore this packet
+		 */
+		if (!PIM_UPSTREAM_FLAG_TEST_FHR(up->flags)) {
+			/*
+			 * No if channel, but upstream we are at the RP.
+			 *
+			 * This could be a anycast RP too and we may
+			 * not have received a register packet from
+			 * the source here at all.  So gracefully
+			 * bow out of doing a nexthop lookup and
+			 * setting the SPTBIT to true
+			 */
+			if (!(pim_addr_is_any(up->upstream_register)) &&
+			    pim_nexthop_lookup(pim_ifp->pim, &source,
+					       up->upstream_register, 0)) {
+				pim_register_stop_send(source.interface, &sg,
+						       pim_ifp->primary_address,
+						       up->upstream_register);
+				up->sptbit = PIM_UPSTREAM_SPTBIT_TRUE;
+			}
+
+			pim_upstream_inherited_olist(pim_ifp->pim, up);
+			if (!up->channel_oil->installed)
+				pim_upstream_mroute_add(up->channel_oil,
+							__func__);
+		} else {
+			if (I_am_RP(pim_ifp->pim, up->sg.grp)) {
+				if (pim_nexthop_lookup(pim_ifp->pim, &source,
+						       up->upstream_register,
+						       0))
+					pim_register_stop_send(
+						source.interface, &sg,
+						pim_ifp->primary_address,
+						up->upstream_register);
+				up->sptbit = PIM_UPSTREAM_SPTBIT_TRUE;
+			} else {
+				/*
+				 * At this point pimd is connected to
+				 * the source, it has a parent, we are not
+				 * the RP  and the SPTBIT should be set
+				 * since we know *the* S,G is on the SPT.
+				 * The first time this happens, let's cause
+				 * an immediate join to go out so that
+				 * the RP can trim this guy immediately
+				 * if necessary, instead of waiting
+				 * one join/prune send cycle
+				 */
+				if (up->sptbit != PIM_UPSTREAM_SPTBIT_TRUE &&
+				    up->parent &&
+				    up->rpf.source_nexthop.interface !=
+					    up->parent->rpf.source_nexthop
+						    .interface) {
+					up->sptbit = PIM_UPSTREAM_SPTBIT_TRUE;
+					pim_jp_agg_single_upstream_send(
+						&up->parent->rpf, up->parent,
+						true);
+				}
+			}
+			pim_upstream_keep_alive_timer_start(
+				up, pim_ifp->pim->keep_alive_time);
+			pim_upstream_inherited_olist(pim_ifp->pim, up);
+			pim_mroute_msg_wholepkt(fd, ifp, buf, len);
+		}
+		return 0;
+	}
+
+	pim_ifp = ifp->info;
+	if (pim_if_connected_to_source(ifp, sg.src)) {
+		up = pim_upstream_add(pim_ifp->pim, &sg, ifp,
+				      PIM_UPSTREAM_FLAG_MASK_FHR, __func__,
+				      NULL);
+		if (!up) {
+			if (PIM_DEBUG_MROUTE)
+				zlog_debug(
+					"%pSG: WRONGVIF%s unable to create upstream on interface",
+					&sg, ifp->name);
+			return -2;
+		}
+		PIM_UPSTREAM_FLAG_SET_SRC_STREAM(up->flags);
+		pim_upstream_keep_alive_timer_start(
+			up, pim_ifp->pim->keep_alive_time);
+		up->channel_oil->cc.pktcnt++;
+		pim_register_join(up);
+		pim_upstream_inherited_olist(pim_ifp->pim, up);
+		if (!up->channel_oil->installed)
+			pim_upstream_mroute_add(up->channel_oil, __func__);
+
+		// Send the packet to the RP
+		pim_mroute_msg_wholepkt(fd, ifp, buf, len);
+	} else {
+		up = pim_upstream_add(pim_ifp->pim, &sg, ifp,
+				      PIM_UPSTREAM_FLAG_MASK_SRC_NOCACHE,
+				      __func__, NULL);
+		if (!up->channel_oil->installed)
+			pim_upstream_mroute_add(up->channel_oil, __func__);
+	}
+
+	return 0;
+}
+
+#if PIM_IPV == 4
+static int process_igmp_packet(struct pim_instance *pim, const char *buf,
+			       size_t buf_size, ifindex_t ifindex)
+{
+	struct interface *ifp;
+	struct pim_interface *pim_ifp;
+	struct in_addr ifaddr;
+	struct gm_sock *igmp;
+	const struct prefix *connected_src;
+	const struct ip *ip_hdr = (const struct ip *)buf;
+
+	/* We have the IP packet but we do not know which interface this
+	 * packet was
+	 * received on. Find the interface that is on the same subnet as
+	 * the source
+	 * of the IP packet.
+	 */
+	ifp = if_lookup_by_index(ifindex, pim->vrf->vrf_id);
+
+	if (!ifp || !ifp->info)
+		return 0;
+
+	connected_src = pim_if_connected_to_source(ifp, ip_hdr->ip_src);
+
+	if (!connected_src && !pim_addr_is_any(ip_hdr->ip_src)) {
+		if (PIM_DEBUG_GM_PACKETS) {
+			zlog_debug(
+				"Recv IGMP packet on interface: %s from a non-connected source: %pI4",
+				ifp->name, &ip_hdr->ip_src);
+		}
+		return 0;
+	}
+
+	pim_ifp = ifp->info;
+	ifaddr = connected_src ? connected_src->u.prefix4
+			       : pim_ifp->primary_address;
+	igmp = pim_igmp_sock_lookup_ifaddr(pim_ifp->gm_socket_list, ifaddr);
+
+	if (PIM_DEBUG_GM_PACKETS) {
+		zlog_debug(
+			"%s(%s): igmp kernel upcall on %s(%p) for %pI4 -> %pI4",
+			__func__, pim->vrf->name, ifp->name, igmp,
+			&ip_hdr->ip_src, &ip_hdr->ip_dst);
+	}
+	if (igmp)
+		pim_igmp_packet(igmp, (char *)buf, buf_size);
+	else if (PIM_DEBUG_GM_PACKETS)
+		zlog_debug(
+			"No IGMP socket on interface: %s with connected source: %pI4",
+			ifp->name, &ifaddr);
+
+	return 0;
+}
+#endif
+
+int pim_mroute_msg(struct pim_instance *pim, const char *buf, size_t buf_size,
+		   ifindex_t ifindex)
+{
+	struct interface *ifp;
+	const ipv_hdr *ip_hdr;
+	const kernmsg *msg;
+
+	if (buf_size < (int)sizeof(ipv_hdr))
+		return 0;
+
+	ip_hdr = (const ipv_hdr *)buf;
+
+#if PIM_IPV == 4
+	if (ip_hdr->ip_p == IPPROTO_IGMP) {
+		process_igmp_packet(pim, buf, buf_size, ifindex);
+	} else if (ip_hdr->ip_p) {
+		if (PIM_DEBUG_MROUTE_DETAIL) {
+			zlog_debug(
+				"%s: no kernel upcall proto=%d src: %pI4 dst: %pI4 msg_size=%ld",
+				__func__, ip_hdr->ip_p, &ip_hdr->ip_src,
+				&ip_hdr->ip_dst, (long int)buf_size);
+		}
+
+	} else {
+#else
+
+	if ((ip_hdr->ip6_vfc & 0xf) == 0) {
+#endif
+		msg = (const kernmsg *)buf;
+
+		ifp = pim_if_find_by_vif_index(pim, msg->msg_im_vif);
+
+		if (!ifp)
+			return 0;
+		if (PIM_DEBUG_MROUTE) {
+#if PIM_IPV == 4
+			zlog_debug(
+				"%s: pim kernel upcall %s type=%d ip_p=%d from fd=%d for (S,G)=(%pI4,%pI4) on %s vifi=%d  size=%ld",
+				__func__, gmmsgtype2str[msg->msg_im_msgtype],
+				msg->msg_im_msgtype, ip_hdr->ip_p,
+				pim->mroute_socket, &msg->msg_im_src,
+				&msg->msg_im_dst, ifp->name, msg->msg_im_vif,
+				(long int)buf_size);
+#else
+			zlog_debug(
+				"%s: pim kernel upcall %s type=%d ip_p=%d from fd=%d for (S,G)=(%pI6,%pI6) on %s vifi=%d  size=%ld",
+				__func__, gmmsgtype2str[msg->msg_im_msgtype],
+				msg->msg_im_msgtype, ip_hdr->ip6_nxt,
+				pim->mroute_socket, &msg->msg_im_src,
+				&msg->msg_im_dst, ifp->name, msg->msg_im_vif,
+				(long int)buf_size);
+#endif
+		}
+
+		switch (msg->msg_im_msgtype) {
+		case GMMSG_WRONGVIF:
+			return pim_mroute_msg_wrongvif(pim->mroute_socket, ifp,
+						       msg);
+		case GMMSG_NOCACHE:
+			return pim_mroute_msg_nocache(pim->mroute_socket, ifp,
+						      msg);
+		case GMMSG_WHOLEPKT:
+			return pim_mroute_msg_wholepkt(pim->mroute_socket, ifp,
+						       (const char *)msg,
+						       buf_size);
+		case GMMSG_WRVIFWHOLE:
+			return pim_mroute_msg_wrvifwhole(pim->mroute_socket,
+							 ifp, (const char *)msg,
+							 buf_size);
+		default:
+			break;
+		}
+	}
+
+	return 0;
+}
+
+static void mroute_read(struct event *t)
+{
+	struct pim_instance *pim;
+	static long long count;
+	char buf[10000];
+	int cont = 1;
+	int rd;
+	ifindex_t ifindex;
+	pim = EVENT_ARG(t);
+
+	while (cont) {
+		rd = pim_socket_recvfromto(pim->mroute_socket, (uint8_t *)buf,
+					   sizeof(buf), NULL, NULL, NULL, NULL,
+					   &ifindex);
+		if (rd <= 0) {
+			if (errno == EINTR)
+				continue;
+			if (errno == EWOULDBLOCK || errno == EAGAIN)
+				break;
+
+			zlog_warn(
+				"%s: failure reading rd=%d: fd=%d: errno=%d: %s",
+				__func__, rd, pim->mroute_socket, errno,
+				safe_strerror(errno));
+			goto done;
+		}
+
+		pim_mroute_msg(pim, buf, rd, ifindex);
+
+		count++;
+		if (count % router->packet_process == 0)
+			cont = 0;
+	}
+/* Keep reading */
+done:
+	mroute_read_on(pim);
+
+	return;
+}
+
+static void mroute_read_on(struct pim_instance *pim)
+{
+	event_add_read(router->master, mroute_read, pim, pim->mroute_socket,
+		       &pim->thread);
+}
+
+static void mroute_read_off(struct pim_instance *pim)
+{
+	EVENT_OFF(pim->thread);
+}
+
+int pim_mroute_socket_enable(struct pim_instance *pim)
+{
+	int fd;
+
+	frr_with_privs(&pimd_privs) {
+
+#if PIM_IPV == 4
+		fd = socket(AF_INET, SOCK_RAW, IPPROTO_IGMP);
+#else
+		fd = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
+#endif
+		if (fd < 0) {
+			zlog_warn("Could not create mroute socket: errno=%d: %s",
+				  errno,
+				  safe_strerror(errno));
+			return -2;
+		}
+
+#if PIM_IPV == 6
+		struct icmp6_filter filter[1];
+		int ret;
+
+		/* Unlike IPv4, this socket is not used for MLD, so just drop
+		 * everything with an empty ICMP6 filter.  Otherwise we get
+		 * all kinds of garbage here, possibly even non-multicast
+		 * related ICMPv6 traffic (e.g. ping)
+		 *
+		 * (mroute kernel upcall "packets" are injected directly on the
+		 * socket, this sockopt -or any other- has no effect on them)
+		 */
+		ICMP6_FILTER_SETBLOCKALL(filter);
+		ret = setsockopt(fd, SOL_ICMPV6, ICMP6_FILTER, filter,
+				 sizeof(filter));
+		if (ret)
+			zlog_err(
+				"(VRF %s) failed to set mroute control filter: %m",
+				pim->vrf->name);
+#endif
+
+#ifdef SO_BINDTODEVICE
+		if (pim->vrf->vrf_id != VRF_DEFAULT
+		    && setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE,
+				  pim->vrf->name, strlen(pim->vrf->name))) {
+			zlog_warn("Could not setsockopt SO_BINDTODEVICE: %s",
+				  safe_strerror(errno));
+			close(fd);
+			return -3;
+		}
+#endif
+
+	}
+
+	pim->mroute_socket = fd;
+	if (pim_mroute_set(pim, 1)) {
+		zlog_warn(
+			"Could not enable mroute on socket fd=%d: errno=%d: %s",
+			fd, errno, safe_strerror(errno));
+		close(fd);
+		pim->mroute_socket = -1;
+		return -3;
+	}
+
+	pim->mroute_socket_creation = pim_time_monotonic_sec();
+
+	mroute_read_on(pim);
+
+	return 0;
+}
+
+int pim_mroute_socket_disable(struct pim_instance *pim)
+{
+	if (pim_mroute_set(pim, 0)) {
+		zlog_warn(
+			"Could not disable mroute on socket fd=%d: errno=%d: %s",
+			pim->mroute_socket, errno, safe_strerror(errno));
+		return -2;
+	}
+
+	if (close(pim->mroute_socket)) {
+		zlog_warn("Failure closing mroute socket: fd=%d errno=%d: %s",
+			  pim->mroute_socket, errno, safe_strerror(errno));
+		return -3;
+	}
+
+	mroute_read_off(pim);
+	pim->mroute_socket = -1;
+
+	return 0;
+}
+
+/*
+  For each network interface (e.g., physical or a virtual tunnel) that
+  would be used for multicast forwarding, a corresponding multicast
+  interface must be added to the kernel.
+ */
+int pim_mroute_add_vif(struct interface *ifp, pim_addr ifaddr,
+		       unsigned char flags)
+{
+	struct pim_interface *pim_ifp = ifp->info;
+	pim_vifctl vc;
+	int err;
+
+	if (PIM_DEBUG_MROUTE)
+		zlog_debug("%s: Add Vif %d (%s[%s])", __func__,
+			   pim_ifp->mroute_vif_index, ifp->name,
+			   pim_ifp->pim->vrf->name);
+
+	memset(&vc, 0, sizeof(vc));
+	vc.vc_vifi = pim_ifp->mroute_vif_index;
+#if PIM_IPV == 4
+#ifdef VIFF_USE_IFINDEX
+	vc.vc_lcl_ifindex = ifp->ifindex;
+#else
+	if (ifaddr.s_addr == INADDR_ANY) {
+		zlog_warn(
+			"%s: unnumbered interfaces are not supported on this platform",
+			__func__);
+		return -1;
+	}
+	memcpy(&vc.vc_lcl_addr, &ifaddr, sizeof(vc.vc_lcl_addr));
+#endif
+#else
+	vc.vc_pifi = ifp->ifindex;
+#endif
+	vc.vc_flags = flags;
+	vc.vc_threshold = PIM_MROUTE_MIN_TTL;
+	vc.vc_rate_limit = 0;
+
+#if PIM_IPV == 4
+#ifdef PIM_DVMRP_TUNNEL
+	if (vc.vc_flags & VIFF_TUNNEL) {
+		memcpy(&vc.vc_rmt_addr, &vif_remote_addr,
+		       sizeof(vc.vc_rmt_addr));
+	}
+#endif
+#endif
+
+	err = setsockopt(pim_ifp->pim->mroute_socket, PIM_IPPROTO, MRT_ADD_VIF,
+			 (void *)&vc, sizeof(vc));
+	if (err) {
+		zlog_warn(
+			"%s: failure: setsockopt(fd=%d,PIM_IPPROTO,MRT_ADD_VIF,vif_index=%d,ifaddr=%pPAs,flag=%d): errno=%d: %s",
+			__func__, pim_ifp->pim->mroute_socket, ifp->ifindex,
+			&ifaddr, flags, errno, safe_strerror(errno));
+		return -2;
+	}
+
+	return 0;
+}
+
+int pim_mroute_del_vif(struct interface *ifp)
+{
+	struct pim_interface *pim_ifp = ifp->info;
+	pim_vifctl vc;
+	int err;
+
+	if (PIM_DEBUG_MROUTE)
+		zlog_debug("%s: Del Vif %d (%s[%s])", __func__,
+			   pim_ifp->mroute_vif_index, ifp->name,
+			   pim_ifp->pim->vrf->name);
+
+	memset(&vc, 0, sizeof(vc));
+	vc.vc_vifi = pim_ifp->mroute_vif_index;
+
+	err = setsockopt(pim_ifp->pim->mroute_socket, PIM_IPPROTO, MRT_DEL_VIF,
+			 (void *)&vc, sizeof(vc));
+	if (err) {
+		zlog_warn(
+			"%s %s: failure: setsockopt(fd=%d,PIM_IPPROTO,MRT_DEL_VIF,vif_index=%d): errno=%d: %s",
+			__FILE__, __func__, pim_ifp->pim->mroute_socket,
+			pim_ifp->mroute_vif_index, errno, safe_strerror(errno));
+		return -2;
+	}
+
+	return 0;
+}
+
+/*
+ * Prevent creating MFC entry with OIF=IIF.
+ *
+ * This is a protection against implementation mistakes.
+ *
+ * PIM protocol implicitely ensures loopfree multicast topology.
+ *
+ * IGMP must be protected against adding looped MFC entries created
+ * by both source and receiver attached to the same interface. See
+ * TODO T22.
+ * We shall allow igmp to create upstream when it is DR for the intf.
+ * Assume RP reachable via non DR.
+ */
+bool pim_mroute_allow_iif_in_oil(struct channel_oil *c_oil,
+		int oif_index)
+{
+#ifdef PIM_ENFORCE_LOOPFREE_MFC
+	struct interface *ifp_out;
+	struct pim_interface *pim_ifp;
+
+	if (c_oil->up &&
+		PIM_UPSTREAM_FLAG_TEST_ALLOW_IIF_IN_OIL(c_oil->up->flags))
+		return true;
+
+	ifp_out = pim_if_find_by_vif_index(c_oil->pim, oif_index);
+	if (!ifp_out)
+		return false;
+	pim_ifp = ifp_out->info;
+	if (!pim_ifp)
+		return false;
+	if ((c_oil->oif_flags[oif_index] & PIM_OIF_FLAG_PROTO_GM) &&
+	    PIM_I_am_DR(pim_ifp))
+		return true;
+
+	return false;
+#else
+	return true;
+#endif
+}
+
+static inline void pim_mroute_copy(struct channel_oil *out,
+				   struct channel_oil *in)
+{
+	int i;
+
+	*oil_origin(out) = *oil_origin(in);
+	*oil_mcastgrp(out) = *oil_mcastgrp(in);
+	*oil_incoming_vif(out) = *oil_incoming_vif(in);
+
+	for (i = 0; i < MAXVIFS; ++i) {
+		if (*oil_incoming_vif(out) == i &&
+		    !pim_mroute_allow_iif_in_oil(in, i)) {
+			oil_if_set(out, i, 0);
+			continue;
+		}
+
+		if (in->oif_flags[i] & PIM_OIF_FLAG_MUTE)
+			oil_if_set(out, i, 0);
+		else
+			oil_if_set(out, i, oil_if_has(in, i));
+	}
+}
+
+/* This function must not be called directly 0
+ * use pim_upstream_mroute_add or pim_static_mroute_add instead
+ */
+static int pim_mroute_add(struct channel_oil *c_oil, const char *name)
+{
+	struct pim_instance *pim = c_oil->pim;
+	struct channel_oil tmp_oil[1] = { };
+	int err;
+
+	pim->mroute_add_last = pim_time_monotonic_sec();
+	++pim->mroute_add_events;
+
+	/* Copy the oil to a temporary structure to fixup (without need to
+	 * later restore) before sending the mroute add to the dataplane
+	 */
+	pim_mroute_copy(tmp_oil, c_oil);
+
+	/* The linux kernel *expects* the incoming
+	 * vif to be part of the outgoing list
+	 * in the case of a (*,G).
+	 */
+	if (pim_addr_is_any(*oil_origin(c_oil))) {
+		oil_if_set(tmp_oil, *oil_incoming_vif(c_oil), 1);
+	}
+
+	/*
+	 * If we have an unresolved cache entry for the S,G
+	 * it is owned by the pimreg for the incoming IIF
+	 * So set pimreg as the IIF temporarily to cause
+	 * the packets to be forwarded.  Then set it
+	 * to the correct IIF afterwords.
+	 */
+	if (!c_oil->installed && !pim_addr_is_any(*oil_origin(c_oil)) &&
+	    *oil_incoming_vif(c_oil) != 0) {
+		*oil_incoming_vif(tmp_oil) = 0;
+	}
+	/* For IPv6 MRT_ADD_MFC is defined to MRT6_ADD_MFC */
+	err = setsockopt(pim->mroute_socket, PIM_IPPROTO, MRT_ADD_MFC,
+			 &tmp_oil->oil, sizeof(tmp_oil->oil));
+
+	if (!err && !c_oil->installed && !pim_addr_is_any(*oil_origin(c_oil)) &&
+	    *oil_incoming_vif(c_oil) != 0) {
+		*oil_incoming_vif(tmp_oil) = *oil_incoming_vif(c_oil);
+		err = setsockopt(pim->mroute_socket, PIM_IPPROTO, MRT_ADD_MFC,
+				 &tmp_oil->oil, sizeof(tmp_oil->oil));
+	}
+
+	if (err) {
+		zlog_warn(
+			"%s %s: failure: setsockopt(fd=%d,PIM_IPPROTO,MRT_ADD_MFC): errno=%d: %s",
+			__FILE__, __func__, pim->mroute_socket, errno,
+			safe_strerror(errno));
+		return -2;
+	}
+
+	if (PIM_DEBUG_MROUTE) {
+		char buf[1000];
+		zlog_debug("%s(%s), vrf %s Added Route: %s", __func__, name,
+			   pim->vrf->name,
+			   pim_channel_oil_dump(c_oil, buf, sizeof(buf)));
+	}
+
+	if (!c_oil->installed) {
+		c_oil->installed = 1;
+		c_oil->mroute_creation = pim_time_monotonic_sec();
+	}
+
+	return 0;
+}
+
+static int pim_upstream_get_mroute_iif(struct channel_oil *c_oil,
+		const char *name)
+{
+	vifi_t iif = MAXVIFS;
+	struct interface *ifp = NULL;
+	struct pim_interface *pim_ifp;
+	struct pim_upstream *up = c_oil->up;
+
+	if (up) {
+		if (PIM_UPSTREAM_FLAG_TEST_USE_RPT(up->flags)) {
+			if (up->parent)
+				ifp = up->parent->rpf.source_nexthop.interface;
+		} else {
+			ifp = up->rpf.source_nexthop.interface;
+		}
+		if (ifp) {
+			pim_ifp = (struct pim_interface *)ifp->info;
+			if (pim_ifp)
+				iif = pim_ifp->mroute_vif_index;
+		}
+	}
+	return iif;
+}
+
+static int pim_upstream_mroute_update(struct channel_oil *c_oil,
+		const char *name)
+{
+	char buf[1000];
+
+	if (*oil_incoming_vif(c_oil) >= MAXVIFS) {
+		/* the c_oil cannot be installed as a mroute yet */
+		if (PIM_DEBUG_MROUTE)
+			zlog_debug(
+					"%s(%s) %s mroute not ready to be installed; %s",
+					__func__, name,
+					pim_channel_oil_dump(c_oil, buf,
+						sizeof(buf)),
+					c_oil->installed ?
+					"uninstall" : "skip");
+		/* if already installed flush it out as we are going to stop
+		 * updates to it leaving it in a stale state
+		 */
+		if (c_oil->installed)
+			pim_mroute_del(c_oil, name);
+		/* return success (skipped) */
+		return 0;
+	}
+
+	return pim_mroute_add(c_oil, name);
+}
+
+/* IIF associated with SGrpt entries are re-evaluated when the parent
+ * (*,G) entries IIF changes
+ */
+static void pim_upstream_all_sources_iif_update(struct pim_upstream *up)
+{
+	struct listnode *listnode;
+	struct pim_upstream *child;
+
+	for (ALL_LIST_ELEMENTS_RO(up->sources, listnode,
+				child)) {
+		if (PIM_UPSTREAM_FLAG_TEST_USE_RPT(child->flags))
+			pim_upstream_mroute_iif_update(child->channel_oil,
+					__func__);
+	}
+}
+
+/* In the case of "PIM state machine" added mroutes an upstream entry
+ * must be present to decide on the SPT-forwarding vs. RPT-forwarding.
+ */
+int pim_upstream_mroute_add(struct channel_oil *c_oil, const char *name)
+{
+	vifi_t iif;
+
+	iif = pim_upstream_get_mroute_iif(c_oil, name);
+
+	if (*oil_incoming_vif(c_oil) != iif) {
+		*oil_incoming_vif(c_oil) = iif;
+		if (pim_addr_is_any(*oil_origin(c_oil)) &&
+				c_oil->up)
+			pim_upstream_all_sources_iif_update(c_oil->up);
+	} else {
+		*oil_incoming_vif(c_oil) = iif;
+	}
+
+	return pim_upstream_mroute_update(c_oil, name);
+}
+
+/* Look for IIF changes and update the dateplane entry only if the IIF
+ * has changed.
+ */
+int pim_upstream_mroute_iif_update(struct channel_oil *c_oil, const char *name)
+{
+	vifi_t iif;
+	char buf[1000];
+
+	iif = pim_upstream_get_mroute_iif(c_oil, name);
+	if (*oil_incoming_vif(c_oil) == iif) {
+		/* no change */
+		return 0;
+	}
+	*oil_incoming_vif(c_oil) = iif;
+
+	if (pim_addr_is_any(*oil_origin(c_oil)) &&
+			c_oil->up)
+		pim_upstream_all_sources_iif_update(c_oil->up);
+
+	if (PIM_DEBUG_MROUTE_DETAIL)
+		zlog_debug("%s(%s) %s mroute iif update %d",
+				__func__, name,
+				pim_channel_oil_dump(c_oil, buf,
+					sizeof(buf)), iif);
+	/* XXX: is this hack needed? */
+	c_oil->oil_inherited_rescan = 1;
+	return pim_upstream_mroute_update(c_oil, name);
+}
+
+int pim_static_mroute_add(struct channel_oil *c_oil, const char *name)
+{
+	return pim_mroute_add(c_oil, name);
+}
+
+void pim_static_mroute_iif_update(struct channel_oil *c_oil,
+				int input_vif_index,
+				const char *name)
+{
+	if (*oil_incoming_vif(c_oil) == input_vif_index)
+		return;
+
+	*oil_incoming_vif(c_oil) = input_vif_index;
+	if (input_vif_index == MAXVIFS)
+		pim_mroute_del(c_oil, name);
+	else
+		pim_static_mroute_add(c_oil, name);
+}
+
+int pim_mroute_del(struct channel_oil *c_oil, const char *name)
+{
+	struct pim_instance *pim = c_oil->pim;
+	int err;
+
+	pim->mroute_del_last = pim_time_monotonic_sec();
+	++pim->mroute_del_events;
+
+	if (!c_oil->installed) {
+		if (PIM_DEBUG_MROUTE) {
+			char buf[1000];
+			struct interface *iifp =
+				pim_if_find_by_vif_index(pim, *oil_incoming_vif(
+								      c_oil));
+
+			zlog_debug("%s %s: incoming interface %s for route is %s not installed, do not need to send del req. ",
+				   __FILE__, __func__,
+				   iifp ? iifp->name : "Unknown",
+				   pim_channel_oil_dump(c_oil, buf,
+							sizeof(buf)));
+		}
+		return -2;
+	}
+
+	err = setsockopt(pim->mroute_socket, PIM_IPPROTO, MRT_DEL_MFC,
+			 &c_oil->oil, sizeof(c_oil->oil));
+	if (err) {
+		if (PIM_DEBUG_MROUTE)
+			zlog_warn(
+				"%s %s: failure: setsockopt(fd=%d,PIM_IPPROTO,MRT_DEL_MFC): errno=%d: %s",
+				__FILE__, __func__, pim->mroute_socket, errno,
+				safe_strerror(errno));
+		return -2;
+	}
+
+	if (PIM_DEBUG_MROUTE) {
+		char buf[1000];
+		zlog_debug("%s(%s), vrf %s Deleted Route: %s", __func__, name,
+			   pim->vrf->name,
+			   pim_channel_oil_dump(c_oil, buf, sizeof(buf)));
+	}
+
+	// Reset kernel installed flag
+	c_oil->installed = 0;
+
+	return 0;
+}
+
+void pim_mroute_update_counters(struct channel_oil *c_oil)
+{
+	struct pim_instance *pim = c_oil->pim;
+	pim_sioc_sg_req sgreq;
+
+	c_oil->cc.oldpktcnt = c_oil->cc.pktcnt;
+	c_oil->cc.oldbytecnt = c_oil->cc.bytecnt;
+	c_oil->cc.oldwrong_if = c_oil->cc.wrong_if;
+
+	if (!c_oil->installed) {
+		c_oil->cc.lastused = 100 * pim->keep_alive_time;
+		if (PIM_DEBUG_MROUTE) {
+			pim_sgaddr sg;
+
+			sg.src = *oil_origin(c_oil);
+			sg.grp = *oil_mcastgrp(c_oil);
+			zlog_debug("Channel%pSG is not installed no need to collect data from kernel",
+				   &sg);
+		}
+		return;
+	}
+
+
+	memset(&sgreq, 0, sizeof(sgreq));
+
+	pim_zlookup_sg_statistics(c_oil);
+
+#if PIM_IPV == 4
+	sgreq.src = *oil_origin(c_oil);
+	sgreq.grp = *oil_mcastgrp(c_oil);
+#else
+	sgreq.src = c_oil->oil.mf6cc_origin;
+	sgreq.grp = c_oil->oil.mf6cc_mcastgrp;
+#endif
+	if (ioctl(pim->mroute_socket, PIM_SIOCGETSGCNT, &sgreq)) {
+		pim_sgaddr sg;
+
+		sg.src = *oil_origin(c_oil);
+		sg.grp = *oil_mcastgrp(c_oil);
+
+		zlog_warn(
+			"ioctl(PIM_SIOCGETSGCNT=%lu) failure for (S,G)=%pSG: errno=%d: %s",
+			(unsigned long)PIM_SIOCGETSGCNT, &sg, errno,
+			safe_strerror(errno));
+		return;
+	}
+
+	c_oil->cc.pktcnt = sgreq.pktcnt;
+	c_oil->cc.bytecnt = sgreq.bytecnt;
+	c_oil->cc.wrong_if = sgreq.wrong_if;
+	return;
+}