[mirror_frr.git] / pimd / pim_upstream.h

/*
 * 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
 */

#ifndef PIM_UPSTREAM_H
#define PIM_UPSTREAM_H

#include <zebra.h>
#include <prefix.h>
#include "plist.h"

#include <pimd/pim_rpf.h>
#include "pim_str.h"
#include "pim_ifchannel.h"

#define PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED         (1 << 0)
#define PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED_UPDATED (1 << 1)
#define PIM_UPSTREAM_FLAG_MASK_FHR                     (1 << 2)
#define PIM_UPSTREAM_FLAG_MASK_SRC_IGMP                (1 << 3)
#define PIM_UPSTREAM_FLAG_MASK_SRC_PIM                 (1 << 4)
#define PIM_UPSTREAM_FLAG_MASK_SRC_STREAM              (1 << 5)
#define PIM_UPSTREAM_FLAG_MASK_SRC_MSDP                (1 << 6)
#define PIM_UPSTREAM_FLAG_MASK_SEND_SG_RPT_PRUNE       (1 << 7)
#define PIM_UPSTREAM_FLAG_MASK_SRC_LHR                 (1 << 8)
/* In the case of pim vxlan we prime the pump by registering the
 * vxlan source and keeping the SPT (FHR-RP) alive by sending periodic
 * NULL registers. So we need to prevent KAT expiry because of the
 * lack of BUM traffic.
 */
#define PIM_UPSTREAM_FLAG_MASK_DISABLE_KAT_EXPIRY      (1 << 9)
/* for pim vxlan we need to pin the IIF to lo or MLAG-ISL on the
 * originating VTEP. This flag allows that by setting IIF to the
 * value specified and preventing next-hop-tracking on the entry
 */
#define PIM_UPSTREAM_FLAG_MASK_STATIC_IIF              (1 << 10)
#define PIM_UPSTREAM_FLAG_MASK_ALLOW_IIF_IN_OIL        (1 << 11)
/* Disable pimreg encasulation for a flow */
#define PIM_UPSTREAM_FLAG_MASK_NO_PIMREG_DATA          (1 << 12)
/* For some MDTs we need to register the router as a source even
 * if the not DR or directly connected on the IIF. This is typically
 * needed on a VxLAN-AA (MLAG) setup.
 */
#define PIM_UPSTREAM_FLAG_MASK_FORCE_PIMREG            (1 << 13)
/* VxLAN origination mroute - SG was registered by EVPN where S is the
 * local VTEP IP and G is the BUM multicast group address
 */
#define PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_ORIG          (1 << 14)
/* VxLAN termination mroute - *G entry where G is the BUM multicast group
 * address
 */
#define PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_TERM          (1 << 15)
/* MLAG mroute - synced to the MLAG peer and subject to DF (designated
 * forwarder) election
 */
#define PIM_UPSTREAM_FLAG_MASK_MLAG_VXLAN              (1 << 16)
/* MLAG mroute that lost the DF election with peer and is installed in
 * a dormant state i.e. MLAG OIFs are removed from the MFC.
 * In most cases the OIL is empty (but not not always) simply
 * blackholing the traffic pulled down to the LHR.
 */
#define PIM_UPSTREAM_FLAG_MASK_MLAG_NON_DF             (1 << 17)
/*
 * We are creating a non-joined upstream data structure
 * for this S,G as that we want to have a channel oil
 * associated with an upstream
 */
#define PIM_UPSTREAM_FLAG_MASK_SRC_NOCACHE             (1 << 19)
/* By default as SG entry will use the SPT for forwarding traffic
 * unless it was setup as a result of a Prune(S,G,rpt) from a
 * downstream router and has JoinDesired(S,G) as False.
 * This flag is only relevant for (S,G) entries.
 */
#define PIM_UPSTREAM_FLAG_MASK_USE_RPT                 (1 << 20)

#define PIM_UPSTREAM_FLAG_ALL 0xFFFFFFFF

#define PIM_UPSTREAM_FLAG_TEST_DR_JOIN_DESIRED(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED)
#define PIM_UPSTREAM_FLAG_TEST_DR_JOIN_DESIRED_UPDATED(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED_UPDATED)
#define PIM_UPSTREAM_FLAG_TEST_FHR(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_FHR)
#define PIM_UPSTREAM_FLAG_TEST_SRC_IGMP(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SRC_IGMP)
#define PIM_UPSTREAM_FLAG_TEST_SRC_PIM(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SRC_PIM)
#define PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SRC_STREAM)
#define PIM_UPSTREAM_FLAG_TEST_SRC_MSDP(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SRC_MSDP)
#define PIM_UPSTREAM_FLAG_TEST_SEND_SG_RPT_PRUNE(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SEND_SG_RPT_PRUNE)
#define PIM_UPSTREAM_FLAG_TEST_SRC_LHR(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SRC_LHR)
#define PIM_UPSTREAM_FLAG_TEST_DISABLE_KAT_EXPIRY(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_DISABLE_KAT_EXPIRY)
#define PIM_UPSTREAM_FLAG_TEST_STATIC_IIF(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_STATIC_IIF)
#define PIM_UPSTREAM_FLAG_TEST_ALLOW_IIF_IN_OIL(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_ALLOW_IIF_IN_OIL)
#define PIM_UPSTREAM_FLAG_TEST_NO_PIMREG_DATA(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_NO_PIMREG_DATA)
#define PIM_UPSTREAM_FLAG_TEST_FORCE_PIMREG(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_FORCE_PIMREG)
#define PIM_UPSTREAM_FLAG_TEST_SRC_VXLAN_ORIG(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_ORIG)
#define PIM_UPSTREAM_FLAG_TEST_SRC_VXLAN_TERM(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_TERM)
#define PIM_UPSTREAM_FLAG_TEST_SRC_VXLAN(flags) ((flags) & (PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_ORIG | PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_TERM))
#define PIM_UPSTREAM_FLAG_TEST_MLAG_VXLAN(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_MLAG_VXLAN)
#define PIM_UPSTREAM_FLAG_TEST_MLAG_NON_DF(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_MLAG_NON_DF)
#define PIM_UPSTREAM_FLAG_TEST_SRC_NOCACHE(flags) ((flags) &PIM_UPSTREAM_FLAG_MASK_SRC_NOCACHE)
#define PIM_UPSTREAM_FLAG_TEST_USE_RPT(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_USE_RPT)

#define PIM_UPSTREAM_FLAG_SET_DR_JOIN_DESIRED(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED)
#define PIM_UPSTREAM_FLAG_SET_DR_JOIN_DESIRED_UPDATED(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED_UPDATED)
#define PIM_UPSTREAM_FLAG_SET_FHR(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_FHR)
#define PIM_UPSTREAM_FLAG_SET_SRC_IGMP(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_SRC_IGMP)
#define PIM_UPSTREAM_FLAG_SET_SRC_PIM(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_SRC_PIM)
#define PIM_UPSTREAM_FLAG_SET_SRC_STREAM(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_SRC_STREAM)
#define PIM_UPSTREAM_FLAG_SET_SRC_MSDP(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_SRC_MSDP)
#define PIM_UPSTREAM_FLAG_SET_SEND_SG_RPT_PRUNE(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_SEND_SG_RPT_PRUNE)
#define PIM_UPSTREAM_FLAG_SET_SRC_LHR(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_SRC_LHR)
#define PIM_UPSTREAM_FLAG_SET_DISABLE_KAT_EXPIRY(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_DISABLE_KAT_EXPIRY)
#define PIM_UPSTREAM_FLAG_SET_STATIC_IIF(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_STATIC_IIF)
#define PIM_UPSTREAM_FLAG_SET_ALLOW_IIF_IN_OIL(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_ALLOW_IIF_IN_OIL)
#define PIM_UPSTREAM_FLAG_SET_NO_PIMREG_DATA(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_NO_PIMREG_DATA)
#define PIM_UPSTREAM_FLAG_SET_FORCE_PIMREG(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_FORCE_PIMREG)
#define PIM_UPSTREAM_FLAG_SET_SRC_VXLAN_ORIG(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_ORIG)
#define PIM_UPSTREAM_FLAG_SET_SRC_VXLAN_TERM(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_TERM)
#define PIM_UPSTREAM_FLAG_SET_MLAG_VXLAN(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_MLAG_VXLAN)
#define PIM_UPSTREAM_FLAG_SET_MLAG_NON_DF(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_MLAG_NON_DF)
#define PIM_UPSTREAM_FLAG_SET_USE_RPT(flags) ((flags) |= PIM_UPSTREAM_FLAG_MASK_USE_RPT)

#define PIM_UPSTREAM_FLAG_UNSET_DR_JOIN_DESIRED(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED)
#define PIM_UPSTREAM_FLAG_UNSET_DR_JOIN_DESIRED_UPDATED(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED_UPDATED)
#define PIM_UPSTREAM_FLAG_UNSET_FHR(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_FHR)
#define PIM_UPSTREAM_FLAG_UNSET_SRC_IGMP(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_IGMP)
#define PIM_UPSTREAM_FLAG_UNSET_SRC_PIM(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_PIM)
#define PIM_UPSTREAM_FLAG_UNSET_SRC_STREAM(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_STREAM)
#define PIM_UPSTREAM_FLAG_UNSET_SRC_MSDP(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_MSDP)
#define PIM_UPSTREAM_FLAG_UNSET_SEND_SG_RPT_PRUNE(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SEND_SG_RPT_PRUNE)
#define PIM_UPSTREAM_FLAG_UNSET_SRC_LHR(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_LHR)
#define PIM_UPSTREAM_FLAG_UNSET_DISABLE_KAT_EXPIRY(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_DISABLE_KAT_EXPIRY)
#define PIM_UPSTREAM_FLAG_UNSET_STATIC_IIF(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_STATIC_IIF)
#define PIM_UPSTREAM_FLAG_UNSET_ALLOW_IIF_IN_OIL(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_ALLOW_IIF_IN_OIL)
#define PIM_UPSTREAM_FLAG_UNSET_NO_PIMREG_DATA(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_NO_PIMREG_DATA)
#define PIM_UPSTREAM_FLAG_UNSET_FORCE_PIMREG(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_FORCE_PIMREG)
#define PIM_UPSTREAM_FLAG_UNSET_SRC_VXLAN_ORIG(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_ORIG)
#define PIM_UPSTREAM_FLAG_UNSET_SRC_VXLAN_TERM(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_TERM)
#define PIM_UPSTREAM_FLAG_UNSET_MLAG_VXLAN(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_MLAG_VXLAN)
#define PIM_UPSTREAM_FLAG_UNSET_MLAG_NON_DF(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_MLAG_NON_DF)
#define PIM_UPSTREAM_FLAG_UNSET_SRC_NOCACHE(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_NOCACHE)
#define PIM_UPSTREAM_FLAG_UNSET_USE_RPT(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_USE_RPT)

enum pim_upstream_state {
	PIM_UPSTREAM_NOTJOINED,
	PIM_UPSTREAM_JOINED,
};

enum pim_reg_state {
	PIM_REG_NOINFO,
	PIM_REG_JOIN,
	PIM_REG_JOIN_PENDING,
	PIM_REG_PRUNE,
};

enum pim_upstream_sptbit {
	PIM_UPSTREAM_SPTBIT_FALSE,
	PIM_UPSTREAM_SPTBIT_TRUE
};

PREDECL_RBTREE_UNIQ(rb_pim_upstream);
/*
  Upstream (S,G) channel in Joined state
  (S,G) in the "Not Joined" state is not represented
  See RFC 4601: 4.5.7.  Sending (S,G) Join/Prune Message

  upstream_addr : Who we are talking to.
  For (*, G), upstream_addr is RP address or INADDR_ANY(if RP not configured)
  For (S, G), upstream_addr is source address

  rpf: contains the nexthop information to whom we are talking to.

  join_state: JOINED/NOTJOINED

  In the case when FRR receives IGMP/PIM (*, G) join for group G and RP is not
  configured, then create a pim_upstream with the below information.
  pim_upstream->upstream address: INADDR_ANY
  pim_upstream->rpf: Unknown
  pim_upstream->state: NOTJOINED

  When a new RP gets configured for G, find the corresponding pim upstream (*,G)
  entries and update the upstream address as new RP address if it the better one
  for the group G.

  When RP becomes reachable, populate the nexthop information in
  pim_upstream->rpf and update the state to JOINED.

*/
struct pim_upstream {
	struct pim_instance *pim;
	struct rb_pim_upstream_item upstream_rb;
	struct pim_upstream *parent;
	struct in_addr upstream_addr;     /* Who we are talking to */
	struct in_addr upstream_register; /*Who we received a register from*/
	struct prefix_sg sg;		  /* (S,G) group key */
	char sg_str[PIM_SG_LEN];
	uint32_t flags;
	struct channel_oil *channel_oil;
	struct list *sources;
	struct list *ifchannels;

	enum pim_upstream_state join_state;
	enum pim_reg_state reg_state;
	enum pim_upstream_sptbit sptbit;

	int ref_count;

	struct pim_rpf rpf;

	struct thread *t_join_timer;

	/*
	 * RST(S,G)
	 */
	struct thread *t_rs_timer;
#define PIM_REGISTER_SUPPRESSION_PERIOD (60)
#define PIM_REGISTER_PROBE_PERIOD        (5)

	/*
	 * KAT(S,G)
	 */
	struct thread *t_ka_timer;
#define PIM_KEEPALIVE_PERIOD  (210)
#define PIM_RP_KEEPALIVE_PERIOD                                                \
	(3 * router->register_suppress_time + router->register_probe_time)

	/* on the RP we restart a timer to indicate if registers are being rxed
	 * for
	 * SG. This is needed by MSDP to determine its local SA cache */
	struct thread *t_msdp_reg_timer;
#define PIM_MSDP_REG_RXED_PERIOD (3 * (1.5 * router->register_suppress_time))

	int64_t state_transition; /* Record current state uptime */
};

static inline bool pim_upstream_is_kat_running(struct pim_upstream *up)
{
	return (up->t_ka_timer != NULL);
}

struct pim_upstream *pim_upstream_find(struct pim_instance *pim,
				       struct prefix_sg *sg);
struct pim_upstream *pim_upstream_find_or_add(struct prefix_sg *sg,
					      struct interface *ifp, int flags,
					      const char *name);
struct pim_upstream *pim_upstream_add(struct pim_instance *pim,
				      struct prefix_sg *sg,
				      struct interface *ifp, int flags,
				      const char *name,
				      struct pim_ifchannel *ch);
void pim_upstream_ref(struct pim_upstream *up, int flags, const char *name);
struct pim_upstream *pim_upstream_del(struct pim_instance *pim,
				      struct pim_upstream *up,
				      const char *name);

int pim_upstream_evaluate_join_desired(struct pim_instance *pim,
				       struct pim_upstream *up);
int pim_upstream_evaluate_join_desired_interface(struct pim_upstream *up,
						 struct pim_ifchannel *ch,
						 struct pim_ifchannel *starch);
int pim_upstream_eval_inherit_if(struct pim_upstream *up,
						 struct pim_ifchannel *ch,
						 struct pim_ifchannel *starch);
void pim_upstream_update_join_desired(struct pim_instance *pim,
				      struct pim_upstream *up);

void pim_upstream_join_suppress(struct pim_upstream *up,
				struct in_addr rpf_addr, int holdtime);

void pim_upstream_join_timer_decrease_to_t_override(const char *debug_label,
						    struct pim_upstream *up);

void pim_upstream_join_timer_restart(struct pim_upstream *up,
				     struct pim_rpf *old);
void pim_upstream_rpf_genid_changed(struct pim_instance *pim,
				    struct in_addr neigh_addr);
void pim_upstream_rpf_interface_changed(struct pim_upstream *up,
					struct interface *old_rpf_ifp);

void pim_upstream_update_could_assert(struct pim_upstream *up);
void pim_upstream_update_my_assert_metric(struct pim_upstream *up);

void pim_upstream_keep_alive_timer_start(struct pim_upstream *up,
					 uint32_t time);

int pim_upstream_switch_to_spt_desired_on_rp(struct pim_instance *pim,
				       struct prefix_sg *sg);
#define SwitchToSptDesiredOnRp(pim, sg) pim_upstream_switch_to_spt_desired_on_rp (pim, sg)
int pim_upstream_is_sg_rpt(struct pim_upstream *up);

void pim_upstream_set_sptbit(struct pim_upstream *up,
			     struct interface *incoming);

void pim_upstream_start_register_stop_timer(struct pim_upstream *up,
					    int null_register);

void pim_upstream_send_join(struct pim_upstream *up);

void pim_upstream_switch(struct pim_instance *pim, struct pim_upstream *up,
			 enum pim_upstream_state new_state);

const char *pim_upstream_state2str(enum pim_upstream_state join_state);
#define PIM_REG_STATE_STR_LEN 12
const char *pim_reg_state2str(enum pim_reg_state state, char *state_str,
			      size_t state_str_len);

int pim_upstream_inherited_olist_decide(struct pim_instance *pim,
					struct pim_upstream *up);
int pim_upstream_inherited_olist(struct pim_instance *pim,
				 struct pim_upstream *up);
int pim_upstream_empty_inherited_olist(struct pim_upstream *up);

void pim_upstream_find_new_rpf(struct pim_instance *pim);
void pim_upstream_msdp_reg_timer_start(struct pim_upstream *up);

void pim_upstream_init(struct pim_instance *pim);
void pim_upstream_terminate(struct pim_instance *pim);

void join_timer_start(struct pim_upstream *up);
int pim_upstream_compare(const struct pim_upstream *up1,
			 const struct pim_upstream *up2);
DECLARE_RBTREE_UNIQ(rb_pim_upstream, struct pim_upstream, upstream_rb,
		    pim_upstream_compare)

void pim_upstream_register_reevaluate(struct pim_instance *pim);

void pim_upstream_add_lhr_star_pimreg(struct pim_instance *pim);
void pim_upstream_remove_lhr_star_pimreg(struct pim_instance *pim,
					 const char *nlist);

void pim_upstream_spt_prefix_list_update(struct pim_instance *pim,
					 struct prefix_list *pl);

unsigned int pim_upstream_hash_key(const void *arg);
bool pim_upstream_equal(const void *arg1, const void *arg2);
struct pim_upstream *pim_upstream_keep_alive_timer_proc(
		struct pim_upstream *up);
void pim_upstream_fill_static_iif(struct pim_upstream *up,
				struct interface *incoming);
void pim_upstream_update_use_rpt(struct pim_upstream *up,
		bool update_mroute);
void pim_upstream_reeval_use_rpt(struct pim_instance *pim);
#endif /* PIM_UPSTREAM_H */
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	#ifndef PIM_UPSTREAM_H
	21	#define PIM_UPSTREAM_H
	22
	23	#include <zebra.h>
05e451f8	24	#include <prefix.h>
ba4eb1bc	25	#include "plist.h"
12e41d03	26
f9717886	27	#include <pimd/pim_rpf.h>
ba4eb1bc CS	28	#include "pim_str.h"
ba4eb1bc CS	29	#include "pim_ifchannel.h"
bfea315d	30
12e41d03	31	#define PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED (1 << 0)
ca973133 DS	32	#define PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED_UPDATED (1 << 1)
	33	#define PIM_UPSTREAM_FLAG_MASK_FHR (1 << 2)
	34	#define PIM_UPSTREAM_FLAG_MASK_SRC_IGMP (1 << 3)
	35	#define PIM_UPSTREAM_FLAG_MASK_SRC_PIM (1 << 4)
	36	#define PIM_UPSTREAM_FLAG_MASK_SRC_STREAM (1 << 5)
1bf16443	37	#define PIM_UPSTREAM_FLAG_MASK_SRC_MSDP (1 << 6)
54179a37	38	#define PIM_UPSTREAM_FLAG_MASK_SEND_SG_RPT_PRUNE (1 << 7)
850a9f99	39	#define PIM_UPSTREAM_FLAG_MASK_SRC_LHR (1 << 8)
820b4a40 AK	40	/* In the case of pim vxlan we prime the pump by registering the
	41	* vxlan source and keeping the SPT (FHR-RP) alive by sending periodic
	42	* NULL registers. So we need to prevent KAT expiry because of the
	43	* lack of BUM traffic.
	44	*/
	45	#define PIM_UPSTREAM_FLAG_MASK_DISABLE_KAT_EXPIRY (1 << 9)
6a5de0ad AK	46	/* for pim vxlan we need to pin the IIF to lo or MLAG-ISL on the
	47	* originating VTEP. This flag allows that by setting IIF to the
	48	* value specified and preventing next-hop-tracking on the entry
	49	*/
	50	#define PIM_UPSTREAM_FLAG_MASK_STATIC_IIF (1 << 10)
7d973323	51	#define PIM_UPSTREAM_FLAG_MASK_ALLOW_IIF_IN_OIL (1 << 11)
76e4825a AK	52	/* Disable pimreg encasulation for a flow */
76e4825a AK	53	#define PIM_UPSTREAM_FLAG_MASK_NO_PIMREG_DATA (1 << 12)
8eeaef9b AK	54	/* For some MDTs we need to register the router as a source even
	55	* if the not DR or directly connected on the IIF. This is typically
	56	* needed on a VxLAN-AA (MLAG) setup.
	57	*/
	58	#define PIM_UPSTREAM_FLAG_MASK_FORCE_PIMREG (1 << 13)
e12fa762 AK	59	/* VxLAN origination mroute - SG was registered by EVPN where S is the
	60	* local VTEP IP and G is the BUM multicast group address
	61	*/
	62	#define PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_ORIG (1 << 14)
	63	/* VxLAN termination mroute - *G entry where G is the BUM multicast group
	64	* address
	65	*/
	66	#define PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_TERM (1 << 15)
f376b701 AK	67	/* MLAG mroute - synced to the MLAG peer and subject to DF (designated
	68	* forwarder) election
	69	*/
	70	#define PIM_UPSTREAM_FLAG_MASK_MLAG_VXLAN (1 << 16)
	71	/* MLAG mroute that lost the DF election with peer and is installed in
	72	* a dormant state i.e. MLAG OIFs are removed from the MFC.
	73	* In most cases the OIL is empty (but not not always) simply
	74	* blackholing the traffic pulled down to the LHR.
	75	*/
	76	#define PIM_UPSTREAM_FLAG_MASK_MLAG_NON_DF (1 << 17)
02434c43 DS	77	/*
	78	* We are creating a non-joined upstream data structure
	79	* for this S,G as that we want to have a channel oil
	80	* associated with an upstream
	81	*/
	82	#define PIM_UPSTREAM_FLAG_MASK_SRC_NOCACHE (1 << 19)
69e3538c AK	83	/* By default as SG entry will use the SPT for forwarding traffic
	84	* unless it was setup as a result of a Prune(S,G,rpt) from a
	85	* downstream router and has JoinDesired(S,G) as False.
	86	* This flag is only relevant for (S,G) entries.
	87	*/
	88	#define PIM_UPSTREAM_FLAG_MASK_USE_RPT (1 << 20)
02434c43	89
850a9f99	90	#define PIM_UPSTREAM_FLAG_ALL 0xFFFFFFFF
12e41d03 DL	91
	92	#define PIM_UPSTREAM_FLAG_TEST_DR_JOIN_DESIRED(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED)
	93	#define PIM_UPSTREAM_FLAG_TEST_DR_JOIN_DESIRED_UPDATED(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED_UPDATED)
69ff3706	94	#define PIM_UPSTREAM_FLAG_TEST_FHR(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_FHR)
1d3a62cd DS	95	#define PIM_UPSTREAM_FLAG_TEST_SRC_IGMP(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SRC_IGMP)
	96	#define PIM_UPSTREAM_FLAG_TEST_SRC_PIM(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SRC_PIM)
	97	#define PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SRC_STREAM)
7667c556	98	#define PIM_UPSTREAM_FLAG_TEST_SRC_MSDP(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SRC_MSDP)
54179a37	99	#define PIM_UPSTREAM_FLAG_TEST_SEND_SG_RPT_PRUNE(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SEND_SG_RPT_PRUNE)
850a9f99	100	#define PIM_UPSTREAM_FLAG_TEST_SRC_LHR(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SRC_LHR)
820b4a40	101	#define PIM_UPSTREAM_FLAG_TEST_DISABLE_KAT_EXPIRY(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_DISABLE_KAT_EXPIRY)
6a5de0ad	102	#define PIM_UPSTREAM_FLAG_TEST_STATIC_IIF(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_STATIC_IIF)
7d973323	103	#define PIM_UPSTREAM_FLAG_TEST_ALLOW_IIF_IN_OIL(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_ALLOW_IIF_IN_OIL)
76e4825a	104	#define PIM_UPSTREAM_FLAG_TEST_NO_PIMREG_DATA(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_NO_PIMREG_DATA)
8eeaef9b	105	#define PIM_UPSTREAM_FLAG_TEST_FORCE_PIMREG(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_FORCE_PIMREG)
e12fa762 AK	106	#define PIM_UPSTREAM_FLAG_TEST_SRC_VXLAN_ORIG(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_ORIG)
	107	#define PIM_UPSTREAM_FLAG_TEST_SRC_VXLAN_TERM(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_TERM)
	108	#define PIM_UPSTREAM_FLAG_TEST_SRC_VXLAN(flags) ((flags) & (PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_ORIG \| PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_TERM))
f376b701 AK	109	#define PIM_UPSTREAM_FLAG_TEST_MLAG_VXLAN(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_MLAG_VXLAN)
f376b701 AK	110	#define PIM_UPSTREAM_FLAG_TEST_MLAG_NON_DF(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_MLAG_NON_DF)
02434c43	111	#define PIM_UPSTREAM_FLAG_TEST_SRC_NOCACHE(flags) ((flags) &PIM_UPSTREAM_FLAG_MASK_SRC_NOCACHE)
69e3538c	112	#define PIM_UPSTREAM_FLAG_TEST_USE_RPT(flags) ((flags) & PIM_UPSTREAM_FLAG_MASK_USE_RPT)
12e41d03 DL	113
	114	#define PIM_UPSTREAM_FLAG_SET_DR_JOIN_DESIRED(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED)
	115	#define PIM_UPSTREAM_FLAG_SET_DR_JOIN_DESIRED_UPDATED(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED_UPDATED)
69ff3706	116	#define PIM_UPSTREAM_FLAG_SET_FHR(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_FHR)
1d3a62cd DS	117	#define PIM_UPSTREAM_FLAG_SET_SRC_IGMP(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_SRC_IGMP)
	118	#define PIM_UPSTREAM_FLAG_SET_SRC_PIM(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_SRC_PIM)
	119	#define PIM_UPSTREAM_FLAG_SET_SRC_STREAM(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_SRC_STREAM)
7667c556	120	#define PIM_UPSTREAM_FLAG_SET_SRC_MSDP(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_SRC_MSDP)
54179a37	121	#define PIM_UPSTREAM_FLAG_SET_SEND_SG_RPT_PRUNE(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_SEND_SG_RPT_PRUNE)
850a9f99	122	#define PIM_UPSTREAM_FLAG_SET_SRC_LHR(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_SRC_LHR)
820b4a40	123	#define PIM_UPSTREAM_FLAG_SET_DISABLE_KAT_EXPIRY(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_DISABLE_KAT_EXPIRY)
6a5de0ad	124	#define PIM_UPSTREAM_FLAG_SET_STATIC_IIF(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_STATIC_IIF)
7d973323	125	#define PIM_UPSTREAM_FLAG_SET_ALLOW_IIF_IN_OIL(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_ALLOW_IIF_IN_OIL)
76e4825a	126	#define PIM_UPSTREAM_FLAG_SET_NO_PIMREG_DATA(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_NO_PIMREG_DATA)
8eeaef9b	127	#define PIM_UPSTREAM_FLAG_SET_FORCE_PIMREG(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_FORCE_PIMREG)
e12fa762 AK	128	#define PIM_UPSTREAM_FLAG_SET_SRC_VXLAN_ORIG(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_ORIG)
e12fa762 AK	129	#define PIM_UPSTREAM_FLAG_SET_SRC_VXLAN_TERM(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_TERM)
f376b701 AK	130	#define PIM_UPSTREAM_FLAG_SET_MLAG_VXLAN(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_MLAG_VXLAN)
f376b701 AK	131	#define PIM_UPSTREAM_FLAG_SET_MLAG_NON_DF(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_MLAG_NON_DF)
69e3538c	132	#define PIM_UPSTREAM_FLAG_SET_USE_RPT(flags) ((flags) \|= PIM_UPSTREAM_FLAG_MASK_USE_RPT)
12e41d03 DL	133
	134	#define PIM_UPSTREAM_FLAG_UNSET_DR_JOIN_DESIRED(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED)
	135	#define PIM_UPSTREAM_FLAG_UNSET_DR_JOIN_DESIRED_UPDATED(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_DR_JOIN_DESIRED_UPDATED)
69ff3706	136	#define PIM_UPSTREAM_FLAG_UNSET_FHR(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_FHR)
1d3a62cd DS	137	#define PIM_UPSTREAM_FLAG_UNSET_SRC_IGMP(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_IGMP)
	138	#define PIM_UPSTREAM_FLAG_UNSET_SRC_PIM(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_PIM)
	139	#define PIM_UPSTREAM_FLAG_UNSET_SRC_STREAM(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_STREAM)
7667c556	140	#define PIM_UPSTREAM_FLAG_UNSET_SRC_MSDP(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_MSDP)
54179a37	141	#define PIM_UPSTREAM_FLAG_UNSET_SEND_SG_RPT_PRUNE(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SEND_SG_RPT_PRUNE)
850a9f99	142	#define PIM_UPSTREAM_FLAG_UNSET_SRC_LHR(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_LHR)
820b4a40	143	#define PIM_UPSTREAM_FLAG_UNSET_DISABLE_KAT_EXPIRY(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_DISABLE_KAT_EXPIRY)
6a5de0ad	144	#define PIM_UPSTREAM_FLAG_UNSET_STATIC_IIF(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_STATIC_IIF)
7d973323	145	#define PIM_UPSTREAM_FLAG_UNSET_ALLOW_IIF_IN_OIL(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_ALLOW_IIF_IN_OIL)
76e4825a	146	#define PIM_UPSTREAM_FLAG_UNSET_NO_PIMREG_DATA(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_NO_PIMREG_DATA)
8eeaef9b	147	#define PIM_UPSTREAM_FLAG_UNSET_FORCE_PIMREG(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_FORCE_PIMREG)
e12fa762 AK	148	#define PIM_UPSTREAM_FLAG_UNSET_SRC_VXLAN_ORIG(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_ORIG)
e12fa762 AK	149	#define PIM_UPSTREAM_FLAG_UNSET_SRC_VXLAN_TERM(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_TERM)
f376b701 AK	150	#define PIM_UPSTREAM_FLAG_UNSET_MLAG_VXLAN(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_MLAG_VXLAN)
f376b701 AK	151	#define PIM_UPSTREAM_FLAG_UNSET_MLAG_NON_DF(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_MLAG_NON_DF)
02434c43	152	#define PIM_UPSTREAM_FLAG_UNSET_SRC_NOCACHE(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_SRC_NOCACHE)
69e3538c	153	#define PIM_UPSTREAM_FLAG_UNSET_USE_RPT(flags) ((flags) &= ~PIM_UPSTREAM_FLAG_MASK_USE_RPT)
12e41d03	154
12e41d03	155	enum pim_upstream_state {
d62a17ae	156	PIM_UPSTREAM_NOTJOINED,
d62a17ae	157	PIM_UPSTREAM_JOINED,
12e41d03 DL	158	};
12e41d03 DL	159
0c2ebf00	160	enum pim_reg_state {
d62a17ae	161	PIM_REG_NOINFO,
	162	PIM_REG_JOIN,
	163	PIM_REG_JOIN_PENDING,
	164	PIM_REG_PRUNE,
0c2ebf00	165	};
0c2ebf00	166
d99764f6	167	enum pim_upstream_sptbit {
d62a17ae	168	PIM_UPSTREAM_SPTBIT_FALSE,
d62a17ae	169	PIM_UPSTREAM_SPTBIT_TRUE
d99764f6 DS	170	};
d99764f6 DS	171
dd3364cb	172	PREDECL_RBTREE_UNIQ(rb_pim_upstream);
12e41d03 DL	173	/*
12e41d03 DL	174	Upstream (S,G) channel in Joined state
12e41d03	175	(S,G) in the "Not Joined" state is not represented
12e41d03	176	See RFC 4601: 4.5.7. Sending (S,G) Join/Prune Message
bbe598df SP	177
	178	upstream_addr : Who we are talking to.
	179	For (*, G), upstream_addr is RP address or INADDR_ANY(if RP not configured)
	180	For (S, G), upstream_addr is source address
	181
	182	rpf: contains the nexthop information to whom we are talking to.
	183
	184	join_state: JOINED/NOTJOINED
	185
	186	In the case when FRR receives IGMP/PIM (*, G) join for group G and RP is not
	187	configured, then create a pim_upstream with the below information.
	188	pim_upstream->upstream address: INADDR_ANY
	189	pim_upstream->rpf: Unknown
	190	pim_upstream->state: NOTJOINED
	191
	192	When a new RP gets configured for G, find the corresponding pim upstream (*,G)
	193	entries and update the upstream address as new RP address if it the better one
	194	for the group G.
	195
	196	When RP becomes reachable, populate the nexthop information in
	197	pim_upstream->rpf and update the state to JOINED.
	198
12e41d03 DL	199	*/
12e41d03 DL	200	struct pim_upstream {
69e3538c	201	struct pim_instance *pim;
dd3364cb	202	struct rb_pim_upstream_item upstream_rb;
d62a17ae	203	struct pim_upstream *parent;
	204	struct in_addr upstream_addr; /* Who we are talking to */
	205	struct in_addr upstream_register; /Who we received a register from/
	206	struct prefix_sg sg; /* (S,G) group key */
	207	char sg_str[PIM_SG_LEN];
	208	uint32_t flags;
	209	struct channel_oil *channel_oil;
	210	struct list *sources;
	211	struct list *ifchannels;
	212
	213	enum pim_upstream_state join_state;
	214	enum pim_reg_state reg_state;
	215	enum pim_upstream_sptbit sptbit;
	216
	217	int ref_count;
	218
	219	struct pim_rpf rpf;
	220
	221	struct thread *t_join_timer;
	222
	223	/*
	224	* RST(S,G)
	225	*/
	226	struct thread *t_rs_timer;
2ddab288	227	#define PIM_REGISTER_SUPPRESSION_PERIOD (60)
38de2445	228	#define PIM_REGISTER_PROBE_PERIOD (5)
2ddab288	229
d62a17ae	230	/*
	231	* KAT(S,G)
	232	*/
	233	struct thread *t_ka_timer;
4a4c4a07	234	#define PIM_KEEPALIVE_PERIOD (210)
2925dff5	235	#define PIM_RP_KEEPALIVE_PERIOD \
a6c5db59	236	(3 * router->register_suppress_time + router->register_probe_time)
4a4c4a07	237
d62a17ae	238	/* on the RP we restart a timer to indicate if registers are being rxed
	239	* for
	240	* SG. This is needed by MSDP to determine its local SA cache */
	241	struct thread *t_msdp_reg_timer;
2925dff5	242	#define PIM_MSDP_REG_RXED_PERIOD (3 * (1.5 * router->register_suppress_time))
1bf16443	243
d62a17ae	244	int64_t state_transition; /* Record current state uptime */
12e41d03 DL	245	};
12e41d03 DL	246
ec836533 AK	247	static inline bool pim_upstream_is_kat_running(struct pim_upstream *up)
	248	{
	249	return (up->t_ka_timer != NULL);
	250	}
	251
9b29ea95 DS	252	struct pim_upstream pim_upstream_find(struct pim_instance pim,
9b29ea95 DS	253	struct prefix_sg *sg);
d62a17ae	254	struct pim_upstream pim_upstream_find_or_add(struct prefix_sg sg,
	255	struct interface *ifp, int flags,
	256	const char *name);
2002dcdb DS	257	struct pim_upstream pim_upstream_add(struct pim_instance pim,
2002dcdb DS	258	struct prefix_sg *sg,
d62a17ae	259	struct interface *ifp, int flags,
0885a9f1 DS	260	const char *name,
0885a9f1 DS	261	struct pim_ifchannel *ch);
d62a17ae	262	void pim_upstream_ref(struct pim_upstream up, int flags, const char name);
9b29ea95 DS	263	struct pim_upstream pim_upstream_del(struct pim_instance pim,
9b29ea95 DS	264	struct pim_upstream *up,
d62a17ae	265	const char *name);
12e41d03	266
9b29ea95 DS	267	int pim_upstream_evaluate_join_desired(struct pim_instance *pim,
9b29ea95 DS	268	struct pim_upstream *up);
9f44d042	269	int pim_upstream_evaluate_join_desired_interface(struct pim_upstream *up,
d62a17ae	270	struct pim_ifchannel *ch,
a53a9b3e AK	271	struct pim_ifchannel *starch);
	272	int pim_upstream_eval_inherit_if(struct pim_upstream *up,
	273	struct pim_ifchannel *ch,
d62a17ae	274	struct pim_ifchannel *starch);
9b29ea95 DS	275	void pim_upstream_update_join_desired(struct pim_instance *pim,
9b29ea95 DS	276	struct pim_upstream *up);
12e41d03 DL	277
12e41d03 DL	278	void pim_upstream_join_suppress(struct pim_upstream *up,
d62a17ae	279	struct in_addr rpf_addr, int holdtime);
c48a612c	280
12e41d03	281	void pim_upstream_join_timer_decrease_to_t_override(const char *debug_label,
d62a17ae	282	struct pim_upstream *up);
c48a612c	283
d62a17ae	284	void pim_upstream_join_timer_restart(struct pim_upstream *up,
d62a17ae	285	struct pim_rpf *old);
9b29ea95 DS	286	void pim_upstream_rpf_genid_changed(struct pim_instance *pim,
9b29ea95 DS	287	struct in_addr neigh_addr);
12e41d03 DL	288	void pim_upstream_rpf_interface_changed(struct pim_upstream *up,
	289	struct interface *old_rpf_ifp);
	290
	291	void pim_upstream_update_could_assert(struct pim_upstream *up);
	292	void pim_upstream_update_my_assert_metric(struct pim_upstream *up);
	293
d62a17ae	294	void pim_upstream_keep_alive_timer_start(struct pim_upstream *up,
d62a17ae	295	uint32_t time);
cb40b272	296
2ef4ed70	297	int pim_upstream_switch_to_spt_desired_on_rp(struct pim_instance *pim,
8e5f97e3	298	struct prefix_sg *sg);
2ef4ed70	299	#define SwitchToSptDesiredOnRp(pim, sg) pim_upstream_switch_to_spt_desired_on_rp (pim, sg)
d62a17ae	300	int pim_upstream_is_sg_rpt(struct pim_upstream *up);
cb40b272	301
d62a17ae	302	void pim_upstream_set_sptbit(struct pim_upstream *up,
d62a17ae	303	struct interface *incoming);
3a66b17b	304
d62a17ae	305	void pim_upstream_start_register_stop_timer(struct pim_upstream *up,
d62a17ae	306	int null_register);
627ed2a3	307
d62a17ae	308	void pim_upstream_send_join(struct pim_upstream *up);
56638739	309
1eca8576	310	void pim_upstream_switch(struct pim_instance pim, struct pim_upstream up,
d62a17ae	311	enum pim_upstream_state new_state);
7fcdfb34	312
d62a17ae	313	const char *pim_upstream_state2str(enum pim_upstream_state join_state);
e0e127b0	314	#define PIM_REG_STATE_STR_LEN 12
c35b7e6b QY	315	const char pim_reg_state2str(enum pim_reg_state state, char state_str,
c35b7e6b QY	316	size_t state_str_len);
4fdc8f36	317
9b29ea95 DS	318	int pim_upstream_inherited_olist_decide(struct pim_instance *pim,
	319	struct pim_upstream *up);
	320	int pim_upstream_inherited_olist(struct pim_instance *pim,
	321	struct pim_upstream *up);
d62a17ae	322	int pim_upstream_empty_inherited_olist(struct pim_upstream *up);
d3dd1804	323
9b29ea95	324	void pim_upstream_find_new_rpf(struct pim_instance *pim);
1bf16443	325	void pim_upstream_msdp_reg_timer_start(struct pim_upstream *up);
d3dd1804	326
9b29ea95 DS	327	void pim_upstream_init(struct pim_instance *pim);
9b29ea95 DS	328	void pim_upstream_terminate(struct pim_instance *pim);
982bff89	329
d62a17ae	330	void join_timer_start(struct pim_upstream *up);
dd3364cb DS	331	int pim_upstream_compare(const struct pim_upstream *up1,
	332	const struct pim_upstream *up2);
	333	DECLARE_RBTREE_UNIQ(rb_pim_upstream, struct pim_upstream, upstream_rb,
	334	pim_upstream_compare)
	335
9b29ea95	336	void pim_upstream_register_reevaluate(struct pim_instance *pim);
a7b2b1e2	337
9b29ea95 DS	338	void pim_upstream_add_lhr_star_pimreg(struct pim_instance *pim);
	339	void pim_upstream_remove_lhr_star_pimreg(struct pim_instance *pim,
	340	const char *nlist);
df94f9a9	341
9b29ea95 DS	342	void pim_upstream_spt_prefix_list_update(struct pim_instance *pim,
9b29ea95 DS	343	struct prefix_list *pl);
7c591950	344
d8b87afe	345	unsigned int pim_upstream_hash_key(const void *arg);
74df8d6d	346	bool pim_upstream_equal(const void arg1, const void arg2);
ff459c36 AK	347	struct pim_upstream *pim_upstream_keep_alive_timer_proc(
ff459c36 AK	348	struct pim_upstream *up);
6a5de0ad AK	349	void pim_upstream_fill_static_iif(struct pim_upstream *up,
6a5de0ad AK	350	struct interface *incoming);
69e3538c AK	351	void pim_upstream_update_use_rpt(struct pim_upstream *up,
69e3538c AK	352	bool update_mroute);
a749b900	353	void pim_upstream_reeval_use_rpt(struct pim_instance *pim);
12e41d03	354	#endif /* PIM_UPSTREAM_H */