proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-07-09 05:37:07 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #10715 from patrasar/pim_rpf_prefix_to_pimaddr

Browse Source 
pim6d: modify pim_rpf from struct prefix to pim_addr
This commit is contained in:
David Lamparter 2022-07-07 15:36:57 +02:00 committed by GitHub
commit 3eade02f13
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
19 changed files with 231 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
pimd/pim_bsm.c
View File

@ -571,7 +571,7 @@ void pim_bsm_clear(struct pim_instance *pim)
struct route_node *rn;
struct route_node *rpnode;
struct bsgrp_node *bsgrp;
struct prefix nht_p;
pim_addr nht_p;
struct prefix g_all;
struct rp_info *rp_all;
struct pim_upstream *up;
@ -617,16 +617,14 @@ void pim_bsm_clear(struct pim_instance *pim)
}
/* Deregister addr with Zebra NHT */
nht_p.family = AF_INET;
nht_p.prefixlen = IPV4_MAX_BITLEN;
nht_p.u.prefix4 = rp_info->rp.rpf_addr.u.prefix4;
nht_p = rp_info->rp.rpf_addr;
if (PIM_DEBUG_PIM_NHT_RP) {
zlog_debug("%s: Deregister RP addr %pFX with Zebra ",
zlog_debug("%s: Deregister RP addr %pPA with Zebra ",
__func__, &nht_p);
}
pim_delete_tracked_nexthop(pim, &nht_p, NULL, rp_info);
pim_delete_tracked_nexthop(pim, nht_p, NULL, rp_info);
if (!pim_get_all_mcast_group(&g_all))
return;
@ -634,7 +632,7 @@ void pim_bsm_clear(struct pim_instance *pim)
rp_all = pim_rp_find_match_group(pim, &g_all);
if (rp_all == rp_info) {
pim_addr_to_prefix(&rp_all->rp.rpf_addr, PIMADDR_ANY);
rp_all->rp.rpf_addr = PIMADDR_ANY;
rp_all->i_am_rp = 0;
} else {
/* Delete the rp_info from rp-list */

53
pimd/pim_cmd_common.c
View File

@ -898,13 +898,9 @@ void pim_show_rpf(struct pim_instance *pim, struct vty *vty, json_object *json)
}
frr_each (rb_pim_upstream, &pim->upstream_head, up) {
char rpf_addr_str[PREFIX_STRLEN];
const char *rpf_ifname;
struct pim_rpf *rpf = &up->rpf;
pim_addr_dump("<rpf?>", &rpf->rpf_addr, rpf_addr_str,
sizeof(rpf_addr_str));
rpf_ifname =
rpf->source_nexthop.interface ? rpf->source_nexthop
.interface->name
@ -932,8 +928,8 @@ void pim_show_rpf(struct pim_instance *pim, struct vty *vty, json_object *json)
json_object_string_add(json_row, "group", grp_str);
json_object_string_add(json_row, "rpfInterface",
rpf_ifname);
json_object_string_add(json_row, "rpfAddress",
rpf_addr_str);
json_object_string_addf(json_row, "rpfAddress", "%pPA",
&rpf->rpf_addr);
json_object_string_addf(
json_row, "ribNexthop", "%pPAs",
&rpf->source_nexthop.mrib_nexthop_addr);
@ -947,9 +943,9 @@ void pim_show_rpf(struct pim_instance *pim, struct vty *vty, json_object *json)
} else {
vty_out(vty,
"%-15pPAs %-15pPAs %-16s %-15s %-15pPAs %6d %4d\n",
"%-15pPAs %-15pPAs %-16s %-15pPA %-15pPAs %6d %4d\n",
&up->sg.src, &up->sg.grp, rpf_ifname,
rpf_addr_str,
&rpf->rpf_addr,
&rpf->source_nexthop.mrib_nexthop_addr,
rpf->source_nexthop.mrib_route_metric,
rpf->source_nexthop.mrib_metric_preference);
@ -1352,9 +1348,9 @@ void pim_show_upstream(struct pim_instance *pim, struct vty *vty,
if (!up->t_join_timer && up->rpf.source_nexthop.interface) {
struct pim_neighbor *nbr;
nbr = pim_neighbor_find_prefix(
nbr = pim_neighbor_find(
up->rpf.source_nexthop.interface,
&up->rpf.rpf_addr);
up->rpf.rpf_addr);
if (nbr)
pim_time_timer_to_hhmmss(join_timer,
sizeof(join_timer),
@ -1418,7 +1414,7 @@ void pim_show_upstream(struct pim_instance *pim, struct vty *vty,
rpg = RP(pim, up->sg.grp);
json_object_string_addf(json_row, "rpfAddress",
"%pFX", &rpg->rpf_addr);
"%pPA", &rpg->rpf_addr);
} else {
json_object_string_add(json_row, "rpfAddress",
src_str);
@ -1534,15 +1530,11 @@ void pim_show_upstream_rpf(struct pim_instance *pim, struct vty *vty, bool uj)
"Source Group RpfIface RibNextHop RpfAddress \n");
frr_each (rb_pim_upstream, &pim->upstream_head, up) {
char rpf_addr_str[PREFIX_STRLEN];
struct pim_rpf *rpf;
const char *rpf_ifname;
rpf = &up->rpf;
pim_addr_dump("<rpf?>", &rpf->rpf_addr, rpf_addr_str,
sizeof(rpf_addr_str));
rpf_ifname =
rpf->source_nexthop.interface ? rpf->source_nexthop
.interface->name
@ -1573,14 +1565,15 @@ void pim_show_upstream_rpf(struct pim_instance *pim, struct vty *vty, bool uj)
json_object_string_addf(
json_row, "ribNexthop", "%pPAs",
&rpf->source_nexthop.mrib_nexthop_addr);
json_object_string_add(json_row, "rpfAddress",
rpf_addr_str);
json_object_string_addf(json_row, "rpfAddress", "%pPA",
&rpf->rpf_addr);
json_object_object_add(json_group, src_str, json_row);
} else {
vty_out(vty, "%-15pPAs %-15pPAs %-16s %-15pPA %-15s\n",
vty_out(vty,
"%-15pPAs %-15pPAs %-16s %-15pPA %-15pPA\n",
&up->sg.src, &up->sg.grp, rpf_ifname,
&rpf->source_nexthop.mrib_nexthop_addr,
rpf_addr_str);
&rpf->rpf_addr);
}
}
@ -2657,11 +2650,10 @@ static int pim_print_vty_pnc_cache_walkcb(struct hash_bucket *bucket, void *arg)
for (nh_node = pnc->nexthop; nh_node; nh_node = nh_node->next) {
first_ifindex = nh_node->ifindex;
pim_addr rpf_addr = pim_addr_from_prefix(&pnc->rpf.rpf_addr);
ifp = if_lookup_by_index(first_ifindex, pim->vrf->vrf_id);
vty_out(vty, "%-15pPAs ", &rpf_addr);
vty_out(vty, "%-15pPA ", &pnc->rpf.rpf_addr);
vty_out(vty, "%-16s ", ifp ? ifp->name : "NULL");
#if PIM_IPV == 4
vty_out(vty, "%pI4 ", &nh_node->gate.ipv4);
@ -2688,19 +2680,17 @@ static int pim_print_json_pnc_cache_walkcb(struct hash_bucket *backet,
json_object *json_arr = NULL;
for (nh_node = pnc->nexthop; nh_node; nh_node = nh_node->next) {
pim_addr rpf_addr;
first_ifindex = nh_node->ifindex;
rpf_addr = pim_addr_from_prefix(&pnc->rpf.rpf_addr);
ifp = if_lookup_by_index(first_ifindex, pim->vrf->vrf_id);
snprintfrr(addr_str, sizeof(addr_str), "%pPAs", &rpf_addr);
snprintfrr(addr_str, sizeof(addr_str), "%pPA",
&pnc->rpf.rpf_addr);
json_object_object_get_ex(cwd->json_obj, addr_str, &json_row);
if (!json_row) {
json_row = json_object_new_object();
json_object_string_addf(json_row, "address", "%pPAs",
&rpf_addr);
json_object_object_addf(cwd->json_obj, json_row,
"%pPAs", &rpf_addr);
json_object_string_addf(json_row, "address", "%pPA",
&pnc->rpf.rpf_addr);
json_object_object_addf(cwd->json_obj, json_row, "%pPA",
&pnc->rpf.rpf_addr);
json_arr = json_object_new_array();
json_object_object_add(json_row, "nexthops", json_arr);
}
@ -2722,7 +2712,6 @@ static int pim_print_json_pnc_cache_walkcb(struct hash_bucket *backet,
int pim_show_nexthop_lookup_cmd_helper(const char *vrf, struct vty *vty,
pim_addr source, pim_addr group)
{
struct prefix nht_p;
int result = 0;
pim_addr vif_source;
struct prefix grp;
@ -2752,11 +2741,11 @@ int pim_show_nexthop_lookup_cmd_helper(const char *vrf, struct vty *vty,
if (!pim_rp_set_upstream_addr(v->info, &vif_source, source, group))
return CMD_SUCCESS;
pim_addr_to_prefix(&nht_p, vif_source);
pim_addr_to_prefix(&grp, group);
memset(&nexthop, 0, sizeof(nexthop));
result = pim_ecmp_nexthop_lookup(v->info, &nexthop, &nht_p, &grp, 0);
result =
pim_ecmp_nexthop_lookup(v->info, &nexthop, vif_source, &grp, 0);
if (!result) {
vty_out(vty,

4
pimd/pim_iface.c
View File

@ -635,9 +635,7 @@ void pim_if_addr_add(struct connected *ifc)
with RNH address to receive update and add the
interface as nexthop. */
memset(&rpf, 0, sizeof(struct pim_rpf));
rpf.rpf_addr.family = AF_INET;
rpf.rpf_addr.prefixlen = IPV4_MAX_BITLEN;
rpf.rpf_addr.u.prefix4 = ifc->address->u.prefix4;
rpf.rpf_addr = pim_addr_from_prefix(ifc->address);
pnc = pim_nexthop_cache_find(pim_ifp->pim, &rpf);
if (pnc)
pim_sendmsg_zebra_rnh(pim_ifp->pim, zclient,

5
pimd/pim_ifchannel.c
View File

@ -685,8 +685,7 @@ static void on_ifjoin_prune_pending_timer(struct thread *t)
struct pim_rpf rpf;
rpf.source_nexthop.interface = ifp;
pim_addr_to_prefix(&rpf.rpf_addr,
pim_ifp->primary_address);
rpf.rpf_addr = pim_ifp->primary_address;
pim_jp_agg_single_upstream_send(
&rpf, ch->upstream, 0);
}
@ -751,7 +750,7 @@ static void check_recv_upstream(int is_join, struct interface *recv_ifp,
return;
}
rpf_addr = pim_addr_from_prefix(&up->rpf.rpf_addr);
rpf_addr = up->rpf.rpf_addr;
/* upstream directed to RPF'(S,G) ? */
if (pim_addr_cmp(upstream, rpf_addr)) {

16
pimd/pim_join.c
View File

@ -86,7 +86,7 @@ static void recv_join(struct interface *ifp, struct pim_neighbor *neigh,
* If the RP sent in the message is not
* our RP for the group, drop the message
*/
rpf_addr = pim_addr_from_prefix(&rp->rpf_addr);
rpf_addr = rp->rpf_addr;
if (pim_addr_cmp(sg->src, rpf_addr)) {
zlog_warn(
"%s: Specified RP(%pPAs) in join is different than our configured RP(%pPAs)",
@ -427,7 +427,6 @@ int pim_joinprune_send(struct pim_rpf *rpf, struct list *groups)
size_t packet_left = 0;
size_t packet_size = 0;
size_t group_size = 0;
pim_addr rpf_addr;
if (rpf->source_nexthop.interface)
pim_ifp = rpf->source_nexthop.interface->info;
@ -436,9 +435,8 @@ int pim_joinprune_send(struct pim_rpf *rpf, struct list *groups)
return -1;
}
rpf_addr = pim_addr_from_prefix(&rpf->rpf_addr);
on_trace(__func__, rpf->source_nexthop.interface, rpf_addr);
on_trace(__func__, rpf->source_nexthop.interface, rpf->rpf_addr);
if (!pim_ifp) {
zlog_warn("%s: multicast not enabled on interface %s", __func__,
@ -446,11 +444,11 @@ int pim_joinprune_send(struct pim_rpf *rpf, struct list *groups)
return -1;
}
if (pim_addr_is_any(rpf_addr)) {
if (pim_addr_is_any(rpf->rpf_addr)) {
if (PIM_DEBUG_PIM_J_P)
zlog_debug(
"%s: upstream=%pPA is myself on interface %s",
__func__, &rpf_addr,
__func__, &rpf->rpf_addr,
rpf->source_nexthop.interface->name);
return 0;
}
@ -473,7 +471,7 @@ int pim_joinprune_send(struct pim_rpf *rpf, struct list *groups)
memset(msg, 0, sizeof(*msg));
pim_msg_addr_encode_ucast((uint8_t *)&msg->addr,
rpf_addr);
rpf->rpf_addr);
msg->reserved = 0;
msg->holdtime = htons(PIM_JP_HOLDTIME);
@ -492,7 +490,7 @@ int pim_joinprune_send(struct pim_rpf *rpf, struct list *groups)
if (PIM_DEBUG_PIM_J_P)
zlog_debug(
"%s: sending (G)=%pPAs to upstream=%pPA on interface %s",
__func__, &group->group, &rpf_addr,
__func__, &group->group, &rpf->rpf_addr,
rpf->source_nexthop.interface->name);
group_size = pim_msg_get_jp_group_size(group->sources);
@ -516,7 +514,7 @@ int pim_joinprune_send(struct pim_rpf *rpf, struct list *groups)
memset(msg, 0, sizeof(*msg));
pim_msg_addr_encode_ucast((uint8_t *)&msg->addr,
rpf_addr);
rpf->rpf_addr);
msg->reserved = 0;
msg->holdtime = htons(PIM_JP_HOLDTIME);

7
pimd/pim_jp_agg.c
View File

@ -110,7 +110,6 @@ pim_jp_agg_get_interface_upstream_switch_list(struct pim_rpf *rpf)
struct pim_interface *pim_ifp;
struct pim_iface_upstream_switch *pius;
struct listnode *node, *nnode;
pim_addr rpf_addr;
if (!ifp)
return NULL;
@ -121,18 +120,16 @@ pim_jp_agg_get_interface_upstream_switch_list(struct pim_rpf *rpf)
if (!pim_ifp)
return NULL;
rpf_addr = pim_addr_from_prefix(&rpf->rpf_addr);
for (ALL_LIST_ELEMENTS(pim_ifp->upstream_switch_list, node, nnode,
pius)) {
if (!pim_addr_cmp(pius->address, rpf_addr))
if (!pim_addr_cmp(pius->address, rpf->rpf_addr))
break;
}
if (!pius) {
pius = XCALLOC(MTYPE_PIM_JP_AGG_GROUP,
sizeof(struct pim_iface_upstream_switch));
pius->address = rpf_addr;
pius->address = rpf->rpf_addr;
pius->us = list_new();
listnode_add_sort(pim_ifp->upstream_switch_list, pius);
}

2
pimd/pim_msg.c
View File

@ -279,7 +279,7 @@ size_t pim_msg_build_jp_groups(struct pim_jp_groups *grp,
struct pim_rpf *rpf = pim_rp_g(pim, source->up->sg.grp);
bits = PIM_ENCODE_SPARSE_BIT | PIM_ENCODE_WC_BIT
| PIM_ENCODE_RPT_BIT;
stosend = pim_addr_from_prefix(&rpf->rpf_addr);
stosend = rpf->rpf_addr;
/* Only Send SGRpt in case of *,G Join */
if (source->is_join)
up = source->up;

2
pimd/pim_neighbor.c
View File

@ -263,7 +263,7 @@ static void on_neighbor_jp_timer(struct thread *t)
neigh->upstream_jp_agg->count);
rpf.source_nexthop.interface = neigh->interface;
pim_addr_to_prefix(&rpf.rpf_addr, neigh->source_addr);
rpf.rpf_addr = neigh->source_addr;
pim_joinprune_send(&rpf, neigh->upstream_jp_agg);
thread_add_timer(router->master, on_neighbor_jp_timer, neigh,

143
pimd/pim_nht.c
View File

@ -52,11 +52,11 @@
void pim_sendmsg_zebra_rnh(struct pim_instance *pim, struct zclient *zclient,
struct pim_nexthop_cache *pnc, int command)
{
struct prefix *p;
struct prefix p;
int ret;
p = &(pnc->rpf.rpf_addr);
ret = zclient_send_rnh(zclient, command, p, SAFI_UNICAST, false, false,
pim_addr_to_prefix(&p, pnc->rpf.rpf_addr);
ret = zclient_send_rnh(zclient, command, &p, SAFI_UNICAST, false, false,
pim->vrf->vrf_id);
if (ret == ZCLIENT_SEND_FAILURE)
zlog_warn("sendmsg_nexthop: zclient_send_message() failed");
@ -65,7 +65,7 @@ void pim_sendmsg_zebra_rnh(struct pim_instance *pim, struct zclient *zclient,
zlog_debug(
"%s: NHT %sregistered addr %pFX(%s) with Zebra ret:%d ",
__func__,
(command == ZEBRA_NEXTHOP_REGISTER) ? " " : "de", p,
(command == ZEBRA_NEXTHOP_REGISTER) ? " " : "de", &p,
pim->vrf->name, ret);
return;
@ -98,7 +98,7 @@ static struct pim_nexthop_cache *pim_nexthop_cache_add(struct pim_instance *pim,
pnc->rp_list = list_new();
pnc->rp_list->cmp = pim_rp_list_cmp;
snprintfrr(hash_name, sizeof(hash_name), "PNC %pFX(%s) Upstream Hash",
snprintfrr(hash_name, sizeof(hash_name), "PNC %pPA(%s) Upstream Hash",
&pnc->rpf.rpf_addr, pim->vrf->name);
pnc->upstream_hash = hash_create_size(8192, pim_upstream_hash_key,
pim_upstream_equal, hash_name);
@ -107,7 +107,7 @@ static struct pim_nexthop_cache *pim_nexthop_cache_add(struct pim_instance *pim,
}
static struct pim_nexthop_cache *pim_nht_get(struct pim_instance *pim,
struct prefix *addr)
pim_addr addr)
{
struct pim_nexthop_cache *pnc = NULL;
struct pim_rpf rpf;
@ -115,7 +115,7 @@ static struct pim_nexthop_cache *pim_nht_get(struct pim_instance *pim,
zclient = pim_zebra_zclient_get();
memset(&rpf, 0, sizeof(rpf));
rpf.rpf_addr = *addr;
rpf.rpf_addr = addr;
pnc = pim_nexthop_cache_find(pim, &rpf);
if (!pnc) {
@ -124,8 +124,8 @@ static struct pim_nexthop_cache *pim_nht_get(struct pim_instance *pim,
ZEBRA_NEXTHOP_REGISTER);
if (PIM_DEBUG_PIM_NHT_DETAIL)
zlog_debug(
"%s: NHT cache and zebra notification added for %pFX(%s)",
__func__, addr, pim->vrf->name);
"%s: NHT cache and zebra notification added for %pPA(%s)",
__func__, &addr, pim->vrf->name);
}
return pnc;
@ -134,7 +134,7 @@ static struct pim_nexthop_cache *pim_nht_get(struct pim_instance *pim,
/* TBD: this does several distinct things and should probably be split up.
* (checking state vs. returning pnc vs. adding upstream vs. adding rp)
*/
int pim_find_or_track_nexthop(struct pim_instance *pim, struct prefix *addr,
int pim_find_or_track_nexthop(struct pim_instance *pim, pim_addr addr,
struct pim_upstream *up, struct rp_info *rp,
struct pim_nexthop_cache *out_pnc)
{
@ -143,7 +143,7 @@ int pim_find_or_track_nexthop(struct pim_instance *pim, struct prefix *addr,
pnc = pim_nht_get(pim, addr);
assertf(up || rp, "addr=%pFX", addr);
assertf(up || rp, "addr=%pPA", &addr);
if (rp != NULL) {
ch_node = listnode_lookup(pnc->rp_list, rp);
@ -167,13 +167,8 @@ int pim_find_or_track_nexthop(struct pim_instance *pim, struct prefix *addr,
void pim_nht_bsr_add(struct pim_instance *pim, struct in_addr addr)
{
struct pim_nexthop_cache *pnc;
struct prefix pfx;
pfx.family = AF_INET;
pfx.prefixlen = IPV4_MAX_BITLEN;
pfx.u.prefix4 = addr;
pnc = pim_nht_get(pim, &pfx);
pnc = pim_nht_get(pim, addr);
pnc->bsr_count++;
}
@ -184,7 +179,7 @@ static void pim_nht_drop_maybe(struct pim_instance *pim,
{
if (PIM_DEBUG_PIM_NHT)
zlog_debug(
"%s: NHT %pFX(%s) rp_list count:%d upstream count:%ld BSR count:%u",
"%s: NHT %pPA(%s) rp_list count:%d upstream count:%ld BSR count:%u",
__func__, &pnc->rpf.rpf_addr, pim->vrf->name,
pnc->rp_list->count, pnc->upstream_hash->count,
pnc->bsr_count);
@ -206,7 +201,7 @@ static void pim_nht_drop_maybe(struct pim_instance *pim,
}
}
void pim_delete_tracked_nexthop(struct pim_instance *pim, struct prefix *addr,
void pim_delete_tracked_nexthop(struct pim_instance *pim, pim_addr addr,
struct pim_upstream *up, struct rp_info *rp)
{
struct pim_nexthop_cache *pnc = NULL;
@ -214,11 +209,11 @@ void pim_delete_tracked_nexthop(struct pim_instance *pim, struct prefix *addr,
struct pim_upstream *upstream = NULL;
/* Remove from RPF hash if it is the last entry */
lookup.rpf.rpf_addr = *addr;
lookup.rpf.rpf_addr = addr;
pnc = hash_lookup(pim->rpf_hash, &lookup);
if (!pnc) {
zlog_warn("attempting to delete nonexistent NHT entry %pFX",
addr);
zlog_warn("attempting to delete nonexistent NHT entry %pPA",
&addr);
return;
}
@ -261,9 +256,7 @@ void pim_nht_bsr_del(struct pim_instance *pim, struct in_addr addr)
if (addr.s_addr == INADDR_ANY)
return;
lookup.rpf.rpf_addr.family = AF_INET;
lookup.rpf.rpf_addr.prefixlen = IPV4_MAX_BITLEN;
lookup.rpf.rpf_addr.u.prefix4 = addr;
lookup.rpf.rpf_addr = addr;
pnc = hash_lookup(pim->rpf_hash, &lookup);
@ -288,9 +281,7 @@ bool pim_nht_bsr_rpf_check(struct pim_instance *pim, struct in_addr bsr_addr,
struct nexthop *nh;
struct interface *ifp;
lookup.rpf.rpf_addr.family = AF_INET;
lookup.rpf.rpf_addr.prefixlen = IPV4_MAX_BITLEN;
lookup.rpf.rpf_addr.u.prefix4 = bsr_addr;
lookup.rpf.rpf_addr = bsr_addr;
pnc = hash_lookup(pim->rpf_hash, &lookup);
if (!pnc || !CHECK_FLAG(pnc->flags, PIM_NEXTHOP_ANSWER_RECEIVED)) {
@ -396,8 +387,8 @@ bool pim_nht_bsr_rpf_check(struct pim_instance *pim, struct in_addr bsr_addr,
if (!nbr)
continue;
return nh->ifindex == src_ifp->ifindex
&& nhaddr.s_addr == src_ip.s_addr;
return nh->ifindex == src_ifp->ifindex &&
(!pim_addr_cmp(nhaddr, src_ip));
}
return false;
}
@ -427,7 +418,7 @@ static void pim_update_rp_nh(struct pim_instance *pim,
// Compute PIM RPF using cached nexthop
if (!pim_ecmp_nexthop_lookup(pim, &rp_info->rp.source_nexthop,
&rp_info->rp.rpf_addr,
rp_info->rp.rpf_addr,
&rp_info->group, 1))
pim_rp_nexthop_del(rp_info);
}
@ -497,9 +488,8 @@ uint32_t pim_compute_ecmp_hash(struct prefix *src, struct prefix *grp)
static int pim_ecmp_nexthop_search(struct pim_instance *pim,
struct pim_nexthop_cache *pnc,
struct pim_nexthop *nexthop,
struct prefix *src, struct prefix *grp,
int neighbor_needed)
struct pim_nexthop *nexthop, pim_addr src,
struct prefix *grp, int neighbor_needed)
{
struct pim_neighbor *nbrs[router->multipath], *nbr = NULL;
struct interface *ifps[router->multipath];
@ -510,7 +500,6 @@ static int pim_ecmp_nexthop_search(struct pim_instance *pim,
uint8_t nh_iter = 0, found = 0;
uint32_t i, num_nbrs = 0;
pim_addr nh_addr = nexthop->mrib_nexthop_addr;
pim_addr src_addr = pim_addr_from_prefix(src);
pim_addr grp_addr = pim_addr_from_prefix(grp);
if (!pnc || !pnc->nexthop_num || !nexthop)
@ -544,7 +533,7 @@ static int pim_ecmp_nexthop_search(struct pim_instance *pim,
if (curr_route_valid &&
!pim_if_connected_to_source(nexthop->interface,
src_addr)) {
src)) {
nbr = pim_neighbor_find(
nexthop->interface,
nexthop->mrib_nexthop_addr);
@ -565,7 +554,7 @@ static int pim_ecmp_nexthop_search(struct pim_instance *pim,
if (PIM_DEBUG_PIM_NHT)
zlog_debug(
"%s: (%pPA,%pPA)(%s) current nexthop %s is valid, skipping new path selection",
__func__, &src_addr,
__func__, &src,
&grp_addr,
pim->vrf->name,
nexthop->interface->name);
@ -590,12 +579,12 @@ static int pim_ecmp_nexthop_search(struct pim_instance *pim,
pim_addr nhaddr = nh_node->gate.ipv6;
#endif
nbrs[i] = pim_neighbor_find(ifps[i], nhaddr);
if (nbrs[i] ||
pim_if_connected_to_source(ifps[i], src_addr))
if (nbrs[i] || pim_if_connected_to_source(ifps[i], src))
num_nbrs++;
}
}
if (pim->ecmp_enable) {
struct prefix src_pfx;
uint32_t consider = pnc->nexthop_num;
if (neighbor_needed && num_nbrs < consider)
@ -605,7 +594,8 @@ static int pim_ecmp_nexthop_search(struct pim_instance *pim,
return 0;
// PIM ECMP flag is enable then choose ECMP path.
hash_val = pim_compute_ecmp_hash(src, grp);
pim_addr_to_prefix(&src_pfx, src);
hash_val = pim_compute_ecmp_hash(&src_pfx, grp);
mod_val = hash_val % consider;
}
@ -617,8 +607,8 @@ static int pim_ecmp_nexthop_search(struct pim_instance *pim,
if (PIM_DEBUG_PIM_NHT)
zlog_debug(
"%s %s: could not find interface for ifindex %d (address %pPA(%s))",
__FILE__, __func__, first_ifindex,
&src_addr, pim->vrf->name);
__FILE__, __func__, first_ifindex, &src,
pim->vrf->name);
if (nh_iter == mod_val)
mod_val++; // Select nexthpath
nh_iter++;
@ -629,15 +619,14 @@ static int pim_ecmp_nexthop_search(struct pim_instance *pim,
zlog_debug(
"%s: multicast not enabled on input interface %s(%s) (ifindex=%d, RPF for source %pPA)",
__func__, ifp->name, pim->vrf->name,
first_ifindex, &src_addr);
first_ifindex, &src);
if (nh_iter == mod_val)
mod_val++; // Select nexthpath
nh_iter++;
continue;
}
if (neighbor_needed &&
!pim_if_connected_to_source(ifp, src_addr)) {
if (neighbor_needed && !pim_if_connected_to_source(ifp, src)) {
nbr = nbrs[nh_iter];
if (!nbr && !if_is_loopback(ifp)) {
if (PIM_DEBUG_PIM_NHT)
@ -661,14 +650,14 @@ static int pim_ecmp_nexthop_search(struct pim_instance *pim,
#endif
nexthop->mrib_metric_preference = pnc->distance;
nexthop->mrib_route_metric = pnc->metric;
nexthop->last_lookup = src_addr;
nexthop->last_lookup = src;
nexthop->last_lookup_time = pim_time_monotonic_usec();
nexthop->nbr = nbr;
found = 1;
if (PIM_DEBUG_PIM_NHT)
zlog_debug(
"%s: (%pPA,%pPA)(%s) selected nhop interface %s addr %pPAs mod_val %u iter %d ecmp %d",
__func__, &src_addr, &grp_addr,
__func__, &src, &grp_addr,
pim->vrf->name, ifp->name, &nh_addr,
mod_val, nh_iter, pim->ecmp_enable);
}
@ -708,12 +697,12 @@ int pim_parse_nexthop_update(ZAPI_CALLBACK_ARGS)
}
if (cmd == ZEBRA_NEXTHOP_UPDATE) {
prefix_copy(&rpf.rpf_addr, &match);
rpf.rpf_addr = pim_addr_from_prefix(&match);
pnc = pim_nexthop_cache_find(pim, &rpf);
if (!pnc) {
if (PIM_DEBUG_PIM_NHT)
zlog_debug(
"%s: Skipping NHT update, addr %pFX is not in local cached DB.",
"%s: Skipping NHT update, addr %pPA is not in local cached DB.",
__func__, &rpf.rpf_addr);
return 0;
}
@ -740,12 +729,10 @@ int pim_parse_nexthop_update(ZAPI_CALLBACK_ARGS)
*/
#if PIM_IPV == 4
nexthop->type = NEXTHOP_TYPE_IPV4_IFINDEX;
nexthop->gate.ipv4 =
pnc->rpf.rpf_addr.u.prefix4;
nexthop->gate.ipv4 = pnc->rpf.rpf_addr;
#else
nexthop->type = NEXTHOP_TYPE_IPV6_IFINDEX;
nexthop->gate.ipv6 =
pnc->rpf.rpf_addr.u.prefix6;
nexthop->gate.ipv6 = pnc->rpf.rpf_addr;
#endif
break;
#if PIM_IPV == 4
@ -884,7 +871,7 @@ int pim_parse_nexthop_update(ZAPI_CALLBACK_ARGS)
}
int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
struct pim_nexthop *nexthop, struct prefix *src,
struct pim_nexthop *nexthop, pim_addr src,
struct prefix *grp, int neighbor_needed)
{
struct pim_nexthop_cache *pnc;
@ -898,14 +885,13 @@ int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
uint8_t i = 0;
uint32_t hash_val = 0, mod_val = 0;
uint32_t num_nbrs = 0;
pim_addr src_addr = pim_addr_from_prefix(src);
if (PIM_DEBUG_PIM_NHT_DETAIL)
zlog_debug("%s: Looking up: %pPA(%s), last lookup time: %lld",
__func__, &src_addr, pim->vrf->name,
__func__, &src, pim->vrf->name,
nexthop->last_lookup_time);
rpf.rpf_addr = *src;
rpf.rpf_addr = src;
pnc = pim_nexthop_cache_find(pim, &rpf);
if (pnc) {
@ -917,13 +903,13 @@ int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
memset(nexthop_tab, 0,
sizeof(struct pim_zlookup_nexthop) * router->multipath);
num_ifindex =
zclient_lookup_nexthop(pim, nexthop_tab, router->multipath,
src_addr, PIM_NEXTHOP_LOOKUP_MAX);
zclient_lookup_nexthop(pim, nexthop_tab, router->multipath, src,
PIM_NEXTHOP_LOOKUP_MAX);
if (num_ifindex < 1) {
if (PIM_DEBUG_PIM_NHT)
zlog_warn(
"%s: could not find nexthop ifindex for address %pPA(%s)",
__func__, &src_addr, pim->vrf->name);
__func__, &src, pim->vrf->name);
return 0;
}
@ -940,14 +926,14 @@ int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
if (ifps[i]) {
nbrs[i] = pim_neighbor_find(
ifps[i], nexthop_tab[i].nexthop_addr);
if (nbrs[i] ||
pim_if_connected_to_source(ifps[i], src_addr))
if (nbrs[i] || pim_if_connected_to_source(ifps[i], src))
num_nbrs++;
}
}
// If PIM ECMP enable then choose ECMP path.
if (pim->ecmp_enable) {
struct prefix src_pfx;
uint32_t consider = num_ifindex;
if (neighbor_needed && num_nbrs < consider)
@ -956,7 +942,8 @@ int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
if (consider == 0)
return 0;
hash_val = pim_compute_ecmp_hash(src, grp);
pim_addr_to_prefix(&src_pfx, src);
hash_val = pim_compute_ecmp_hash(&src_pfx, grp);
mod_val = hash_val % consider;
if (PIM_DEBUG_PIM_NHT_DETAIL)
zlog_debug("%s: hash_val %u mod_val %u", __func__,
@ -972,8 +959,8 @@ int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
if (PIM_DEBUG_PIM_NHT)
zlog_debug(
"%s %s: could not find interface for ifindex %d (address %pPA(%s))",
__FILE__, __func__, first_ifindex,
&src_addr, pim->vrf->name);
__FILE__, __func__, first_ifindex, &src,
pim->vrf->name);
if (i == mod_val)
mod_val++;
i++;
@ -985,14 +972,13 @@ int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
zlog_debug(
"%s: multicast not enabled on input interface %s(%s) (ifindex=%d, RPF for source %pPA)",
__func__, ifp->name, pim->vrf->name,
first_ifindex, &src_addr);
first_ifindex, &src);
if (i == mod_val)
mod_val++;
i++;
continue;
}
if (neighbor_needed &&
!pim_if_connected_to_source(ifp, src_addr)) {
if (neighbor_needed && !pim_if_connected_to_source(ifp, src)) {
nbr = nbrs[i];
if (PIM_DEBUG_PIM_NHT_DETAIL)
zlog_debug("ifp name: %s(%s), pim nbr: %p",
@ -1006,7 +992,7 @@ int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
__func__,
&nexthop_tab[i].nexthop_addr,
ifp->name, pim->vrf->name,
&src_addr);
&src);
i++;
continue;
}
@ -1017,7 +1003,7 @@ int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
zlog_debug(
"%s: found nhop %pPA for addr %pPA interface %s(%s) metric %d dist %d",
__func__, &nexthop_tab[i].nexthop_addr,
&src_addr, ifp->name, pim->vrf->name,
&src, ifp->name, pim->vrf->name,
nexthop_tab[i].route_metric,
nexthop_tab[i].protocol_distance);
/* update nexthop data */
@ -1028,7 +1014,7 @@ int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
nexthop_tab[i].protocol_distance;
nexthop->mrib_route_metric =
nexthop_tab[i].route_metric;
nexthop->last_lookup = src_addr;
nexthop->last_lookup = src;
nexthop->last_lookup_time = pim_time_monotonic_usec();
nexthop->nbr = nbr;
found = 1;
@ -1042,24 +1028,19 @@ int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
return 0;
}
int pim_ecmp_fib_lookup_if_vif_index(struct pim_instance *pim,
struct prefix *src, struct prefix *grp)
int pim_ecmp_fib_lookup_if_vif_index(struct pim_instance *pim, pim_addr src,
struct prefix *grp)
{
struct pim_nexthop nhop;
int vif_index;
ifindex_t ifindex;
pim_addr src_addr;
if (PIM_DEBUG_PIM_NHT_DETAIL) {
src_addr = pim_addr_from_prefix(src);
}
memset(&nhop, 0, sizeof(nhop));
if (!pim_ecmp_nexthop_lookup(pim, &nhop, src, grp, 1)) {
if (PIM_DEBUG_PIM_NHT)
zlog_debug(
"%s: could not find nexthop ifindex for address %pPA(%s)",
__func__, &src_addr, pim->vrf->name);
__func__, &src, pim->vrf->name);
return -1;
}
@ -1069,7 +1050,7 @@ int pim_ecmp_fib_lookup_if_vif_index(struct pim_instance *pim,
"%s: found nexthop ifindex=%d (interface %s(%s)) for address %pPA",
__func__, ifindex,
ifindex2ifname(ifindex, pim->vrf->vrf_id),
pim->vrf->name, &src_addr);
pim->vrf->name, &src);
vif_index = pim_if_find_vifindex_by_ifindex(pim, ifindex);
@ -1077,7 +1058,7 @@ int pim_ecmp_fib_lookup_if_vif_index(struct pim_instance *pim,
if (PIM_DEBUG_PIM_NHT) {
zlog_debug(
"%s: low vif_index=%d(%s) < 1 nexthop for address %pPA",
__func__, vif_index, pim->vrf->name, &src_addr);
__func__, vif_index, pim->vrf->name, &src);
}
return -2;
}

10
pimd/pim_nht.h
View File

@ -54,21 +54,21 @@ struct pim_nexthop_cache {
};
int pim_parse_nexthop_update(ZAPI_CALLBACK_ARGS);
int pim_find_or_track_nexthop(struct pim_instance *pim, struct prefix *addr,
int pim_find_or_track_nexthop(struct pim_instance *pim, pim_addr addr,
struct pim_upstream *up, struct rp_info *rp,
struct pim_nexthop_cache *out_pnc);
void pim_delete_tracked_nexthop(struct pim_instance *pim, struct prefix *addr,
void pim_delete_tracked_nexthop(struct pim_instance *pim, pim_addr addr,
struct pim_upstream *up, struct rp_info *rp);
struct pim_nexthop_cache *pim_nexthop_cache_find(struct pim_instance *pim,
struct pim_rpf *rpf);
uint32_t pim_compute_ecmp_hash(struct prefix *src, struct prefix *grp);
int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
struct pim_nexthop *nexthop, struct prefix *src,
struct pim_nexthop *nexthop, pim_addr src,
struct prefix *grp, int neighbor_needed);
void pim_sendmsg_zebra_rnh(struct pim_instance *pim, struct zclient *zclient,
struct pim_nexthop_cache *pnc, int command);
int pim_ecmp_fib_lookup_if_vif_index(struct pim_instance *pim,
struct prefix *src, struct prefix *grp);
int pim_ecmp_fib_lookup_if_vif_index(struct pim_instance *pim, pim_addr src,
struct prefix *grp);
void pim_rp_nexthop_del(struct rp_info *rp_info);
/* for RPF check on BSM message receipt */

16
pimd/pim_register.c
View File

@ -139,7 +139,6 @@ int pim_register_stop_recv(struct interface *ifp, uint8_t *buf, int buf_size)
struct pim_instance *pim = pim_ifp->pim;
struct pim_upstream *up = NULL;
struct pim_rpf *rp;
pim_addr rpf_addr;
pim_sgaddr sg;
struct listnode *up_node;
struct pim_upstream *child;
@ -174,12 +173,11 @@ int pim_register_stop_recv(struct interface *ifp, uint8_t *buf, int buf_size)
rp = RP(pim_ifp->pim, sg.grp);
if (rp) {
rpf_addr = pim_addr_from_prefix(&rp->rpf_addr);
/* As per RFC 7761, Section 4.9.4:
* A special wildcard value consisting of an address field of
* all zeros can be used to indicate any source.
*/
if ((pim_addr_cmp(sg.src, rpf_addr) == 0) ||
if ((pim_addr_cmp(sg.src, rp->rpf_addr) == 0) ||
pim_addr_is_any(sg.src)) {
handling_star = true;
sg.src = PIMADDR_ANY;
@ -284,11 +282,10 @@ void pim_register_send(const uint8_t *buf, int buf_size, pim_addr src,
unsigned char *b1;
struct pim_interface *pinfo;
struct interface *ifp;
pim_addr dst = pim_addr_from_prefix(&rpg->rpf_addr);
if (PIM_DEBUG_PIM_REG) {
zlog_debug("Sending %s %sRegister Packet to %pPA", up->sg_str,
null_register ? "NULL " : "", &dst);
null_register ? "NULL " : "", &rpg->rpf_addr);
}
ifp = rpg->source_nexthop.interface;
@ -310,7 +307,7 @@ void pim_register_send(const uint8_t *buf, int buf_size, pim_addr src,
if (PIM_DEBUG_PIM_REG) {
zlog_debug("%s: Sending %s %sRegister Packet to %pPA on %s",
__func__, up->sg_str, null_register ? "NULL " : "",
&dst, ifp->name);
&rpg->rpf_addr, ifp->name);
}
memset(buffer, 0, 10000);
@ -327,13 +324,14 @@ void pim_register_send(const uint8_t *buf, int buf_size, pim_addr src,
*/
src = pim_register_get_unicast_v6_addr(pinfo);
#endif
pim_msg_build_header(src, dst, buffer, buf_size + PIM_MSG_REGISTER_LEN,
pim_msg_build_header(src, rpg->rpf_addr, buffer,
buf_size + PIM_MSG_REGISTER_LEN,
PIM_MSG_TYPE_REGISTER, false);
if (!pinfo->pim_passive_enable)
++pinfo->pim_ifstat_reg_send;
if (pim_msg_send(pinfo->pim_sock_fd, src, dst, buffer,
if (pim_msg_send(pinfo->pim_sock_fd, src, rpg->rpf_addr, buffer,
buf_size + PIM_MSG_REGISTER_LEN, ifp)) {
if (PIM_DEBUG_PIM_TRACE) {
zlog_debug(
@ -618,7 +616,7 @@ int pim_register_recv(struct interface *ifp, pim_addr dest_addr,
}
}
rp_addr = pim_addr_from_prefix(&(RP(pim, sg.grp))->rpf_addr);
rp_addr = (RP(pim, sg.grp))->rpf_addr;
if (i_am_rp && (!pim_addr_cmp(dest_addr, rp_addr))) {
sentRegisterStop = 0;

149
pimd/pim_rp.c
View File

@ -84,7 +84,7 @@ int pim_rp_list_cmp(void *v1, void *v2)
/*
* Sort by RP IP address
*/
ret = prefix_cmp(&rp1->rp.rpf_addr, &rp2->rp.rpf_addr);
ret = pim_addr_cmp(rp1->rp.rpf_addr, rp2->rp.rpf_addr);
if (ret)
return ret;
@ -119,7 +119,7 @@ void pim_rp_init(struct pim_instance *pim)
XFREE(MTYPE_PIM_RP, rp_info);
return;
}
pim_addr_to_prefix(&rp_info->rp.rpf_addr, PIMADDR_ANY);
rp_info->rp.rpf_addr = PIMADDR_ANY;
listnode_add(pim->rp_list, rp_info);
@ -149,12 +149,9 @@ static struct rp_info *pim_rp_find_prefix_list(struct pim_instance *pim,
{
struct listnode *node;
struct rp_info *rp_info;
struct prefix rp_prefix;
pim_addr_to_prefix(&rp_prefix, rp);
for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
if (prefix_same(&rp_prefix, &rp_info->rp.rpf_addr) &&
if ((!pim_addr_cmp(rp, rp_info->rp.rpf_addr)) &&
rp_info->plist && strcmp(rp_info->plist, plist) == 0) {
return rp_info;
}
@ -189,11 +186,9 @@ static struct rp_info *pim_rp_find_exact(struct pim_instance *pim, pim_addr rp,
{
struct listnode *node;
struct rp_info *rp_info;
struct prefix rp_prefix;
pim_addr_to_prefix(&rp_prefix, rp);
for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
if (prefix_same(&rp_prefix, &rp_info->rp.rpf_addr) &&
if ((!pim_addr_cmp(rp, rp_info->rp.rpf_addr)) &&
prefix_same(&rp_info->group, group))
return rp_info;
}
@ -344,11 +339,11 @@ static int pim_rp_check_interface_addrs(struct rp_info *rp_info,
{
struct listnode *node;
struct pim_secondary_addr *sec_addr;
pim_addr rpf_addr;
struct prefix rpf_addr;
rpf_addr = pim_addr_from_prefix(&rp_info->rp.rpf_addr);
pim_addr_to_prefix(&rpf_addr, rp_info->rp.rpf_addr);
if (!pim_addr_cmp(pim_ifp->primary_address, rpf_addr))
if (!pim_addr_cmp(pim_ifp->primary_address, rp_info->rp.rpf_addr))
return 1;
if (!pim_ifp->sec_addr_list) {
@ -356,7 +351,7 @@ static int pim_rp_check_interface_addrs(struct rp_info *rp_info,
}
for (ALL_LIST_ELEMENTS_RO(pim_ifp->sec_addr_list, node, sec_addr)) {
if (prefix_same(&sec_addr->addr, &rp_info->rp.rpf_addr)) {
if (prefix_same(&sec_addr->addr, &rpf_addr)) {
return 1;
}
}
@ -388,7 +383,6 @@ void pim_upstream_update(struct pim_instance *pim, struct pim_upstream *up)
enum pim_rpf_result rpf_result;
pim_addr old_upstream_addr;
pim_addr new_upstream_addr;
struct prefix nht_p;
old_upstream_addr = up->upstream_addr;
pim_rp_set_upstream_addr(pim, &new_upstream_addr, up->sg.src,
@ -408,12 +402,11 @@ void pim_upstream_update(struct pim_instance *pim, struct pim_upstream *up)
*/
if (!pim_addr_is_any(old_upstream_addr)) {
/* Deregister addr with Zebra NHT */
pim_addr_to_prefix(&nht_p, old_upstream_addr);
if (PIM_DEBUG_PIM_TRACE)
zlog_debug(
"%s: Deregister upstream %s addr %pFX with Zebra NHT",
__func__, up->sg_str, &nht_p);
pim_delete_tracked_nexthop(pim, &nht_p, up, NULL);
"%s: Deregister upstream %s addr %pPA with Zebra NHT",
__func__, up->sg_str, &old_upstream_addr);
pim_delete_tracked_nexthop(pim, old_upstream_addr, up, NULL);
}
/* Update the upstream address */
@ -446,7 +439,7 @@ int pim_rp_new(struct pim_instance *pim, pim_addr rp_addr, struct prefix group,
struct listnode *node, *nnode;
struct rp_info *tmp_rp_info;
char buffer[BUFSIZ];
struct prefix nht_p;
pim_addr nht_p;
struct route_node *rn = NULL;
struct pim_upstream *up;
bool upstream_updated = false;
@ -456,7 +449,7 @@ int pim_rp_new(struct pim_instance *pim, pim_addr rp_addr, struct prefix group,
rp_info = XCALLOC(MTYPE_PIM_RP, sizeof(*rp_info));
pim_addr_to_prefix(&rp_info->rp.rpf_addr, rp_addr);
rp_info->rp.rpf_addr = rp_addr;
prefix_copy(&rp_info->group, &group);
rp_info->rp_src = rp_src_flag;
@ -482,8 +475,8 @@ int pim_rp_new(struct pim_instance *pim, pim_addr rp_addr, struct prefix group,
*/
for (ALL_LIST_ELEMENTS(pim->rp_list, node, nnode,
tmp_rp_info)) {
if (prefix_same(&rp_info->rp.rpf_addr,
&tmp_rp_info->rp.rpf_addr)) {
if (!pim_addr_cmp(rp_info->rp.rpf_addr,
tmp_rp_info->rp.rpf_addr)) {
if (tmp_rp_info->plist)
pim_rp_del_config(pim, rp_addr, NULL,
tmp_rp_info->plist);
@ -519,8 +512,8 @@ int pim_rp_new(struct pim_instance *pim, pim_addr rp_addr, struct prefix group,
for (ALL_LIST_ELEMENTS(pim->rp_list, node, nnode,
tmp_rp_info)) {
if (tmp_rp_info->plist &&
prefix_same(&rp_info->rp.rpf_addr,
&tmp_rp_info->rp.rpf_addr)) {
(!pim_addr_cmp(rp_info->rp.rpf_addr,
tmp_rp_info->rp.rpf_addr))) {
pim_rp_del_config(pim, rp_addr, NULL,
tmp_rp_info->plist);
}
@ -539,7 +532,7 @@ int pim_rp_new(struct pim_instance *pim, pim_addr rp_addr, struct prefix group,
nht_p = rp_all->rp.rpf_addr;
if (PIM_DEBUG_PIM_NHT_RP)
zlog_debug(
"%s: NHT Register rp_all addr %pFX grp %pFX ",
"%s: NHT Register rp_all addr %pPA grp %pFX ",
__func__, &nht_p, &rp_all->group);
frr_each (rb_pim_upstream, &pim->upstream_head, up) {
@ -565,12 +558,12 @@ int pim_rp_new(struct pim_instance *pim, pim_addr rp_addr, struct prefix group,
pim_rp_check_interfaces(pim, rp_all);
pim_rp_refresh_group_to_rp_mapping(pim);
pim_find_or_track_nexthop(pim, &nht_p, NULL, rp_all,
pim_find_or_track_nexthop(pim, nht_p, NULL, rp_all,
NULL);
if (!pim_ecmp_nexthop_lookup(pim,
&rp_all->rp.source_nexthop,
&nht_p, &rp_all->group, 1))
nht_p, &rp_all->group, 1))
return PIM_RP_NO_PATH;
return PIM_SUCCESS;
}
@ -660,10 +653,10 @@ int pim_rp_new(struct pim_instance *pim, pim_addr rp_addr, struct prefix group,
/* Register addr with Zebra NHT */
nht_p = rp_info->rp.rpf_addr;
if (PIM_DEBUG_PIM_NHT_RP)
zlog_debug("%s: NHT Register RP addr %pFX grp %pFX with Zebra ",
zlog_debug("%s: NHT Register RP addr %pPA grp %pFX with Zebra ",
__func__, &nht_p, &rp_info->group);
pim_find_or_track_nexthop(pim, &nht_p, NULL, rp_info, NULL);
if (!pim_ecmp_nexthop_lookup(pim, &rp_info->rp.source_nexthop, &nht_p,
pim_find_or_track_nexthop(pim, nht_p, NULL, rp_info, NULL);
if (!pim_ecmp_nexthop_lookup(pim, &rp_info->rp.source_nexthop, nht_p,
&rp_info->group, 1))
return PIM_RP_NO_PATH;
@ -698,7 +691,7 @@ int pim_rp_del(struct pim_instance *pim, pim_addr rp_addr, struct prefix group,
struct prefix g_all;
struct rp_info *rp_info;
struct rp_info *rp_all;
struct prefix nht_p;
pim_addr nht_p;
struct route_node *rn;
bool was_plist = false;
struct rp_info *trp_info;
@ -753,9 +746,9 @@ int pim_rp_del(struct pim_instance *pim, pim_addr rp_addr, struct prefix group,
/* Deregister addr with Zebra NHT */
nht_p = rp_info->rp.rpf_addr;
if (PIM_DEBUG_PIM_NHT_RP)
zlog_debug("%s: Deregister RP addr %pFX with Zebra ", __func__,
zlog_debug("%s: Deregister RP addr %pPA with Zebra ", __func__,
&nht_p);
pim_delete_tracked_nexthop(pim, &nht_p, NULL, rp_info);
pim_delete_tracked_nexthop(pim, nht_p, NULL, rp_info);
if (!pim_get_all_mcast_group(&g_all))
return PIM_RP_BAD_ADDRESS;
@ -769,7 +762,7 @@ int pim_rp_del(struct pim_instance *pim, pim_addr rp_addr, struct prefix group,
*/
pim_addr rpf_addr;
rpf_addr = pim_addr_from_prefix(&rp_info->rp.rpf_addr);
rpf_addr = rp_info->rp.rpf_addr;
if (!pim_addr_cmp(up->upstream_addr, rpf_addr) &&
pim_addr_is_any(up->sg.src)) {
struct prefix grp;
@ -782,7 +775,7 @@ int pim_rp_del(struct pim_instance *pim, pim_addr rp_addr, struct prefix group,
}
}
}
pim_addr_to_prefix(&rp_all->rp.rpf_addr, PIMADDR_ANY);
rp_all->rp.rpf_addr = PIMADDR_ANY;
rp_all->i_am_rp = 0;
return PIM_SUCCESS;
}
@ -817,7 +810,7 @@ int pim_rp_del(struct pim_instance *pim, pim_addr rp_addr, struct prefix group,
*/
pim_addr rpf_addr;
rpf_addr = pim_addr_from_prefix(&rp_info->rp.rpf_addr);
rpf_addr = rp_info->rp.rpf_addr;
if (!pim_addr_cmp(up->upstream_addr, rpf_addr) &&
pim_addr_is_any(up->sg.src)) {
struct prefix grp;
@ -851,7 +844,7 @@ int pim_rp_del(struct pim_instance *pim, pim_addr rp_addr, struct prefix group,
int pim_rp_change(struct pim_instance *pim, pim_addr new_rp_addr,
struct prefix group, enum rp_source rp_src_flag)
{
struct prefix nht_p;
pim_addr nht_p;
struct route_node *rn;
int result = 0;
struct rp_info *rp_info = NULL;
@ -873,7 +866,7 @@ int pim_rp_change(struct pim_instance *pim, pim_addr new_rp_addr,
return result;
}
old_rp_addr = pim_addr_from_prefix(&rp_info->rp.rpf_addr);
old_rp_addr = rp_info->rp.rpf_addr;
if (!pim_addr_cmp(new_rp_addr, old_rp_addr)) {
if (rp_info->rp_src != rp_src_flag) {
rp_info->rp_src = rp_src_flag;
@ -882,24 +875,21 @@ int pim_rp_change(struct pim_instance *pim, pim_addr new_rp_addr,
}
}
nht_p.family = PIM_AF;
nht_p.prefixlen = PIM_MAX_BITLEN;
/* Deregister old RP addr with Zebra NHT */
if (!pim_addr_is_any(old_rp_addr)) {
nht_p = rp_info->rp.rpf_addr;
if (PIM_DEBUG_PIM_NHT_RP)
zlog_debug("%s: Deregister RP addr %pFX with Zebra ",
zlog_debug("%s: Deregister RP addr %pPA with Zebra ",
__func__, &nht_p);
pim_delete_tracked_nexthop(pim, &nht_p, NULL, rp_info);
pim_delete_tracked_nexthop(pim, nht_p, NULL, rp_info);
}
pim_rp_nexthop_del(rp_info);
listnode_delete(pim->rp_list, rp_info);
/* Update the new RP address*/
pim_addr_to_prefix(&rp_info->rp.rpf_addr, new_rp_addr);
rp_info->rp.rpf_addr = new_rp_addr;
rp_info->rp_src = rp_src_flag;
rp_info->i_am_rp = 0;
@ -926,11 +916,11 @@ int pim_rp_change(struct pim_instance *pim, pim_addr new_rp_addr,
/* Register new RP addr with Zebra NHT */
nht_p = rp_info->rp.rpf_addr;
if (PIM_DEBUG_PIM_NHT_RP)
zlog_debug("%s: NHT Register RP addr %pFX grp %pFX with Zebra ",
zlog_debug("%s: NHT Register RP addr %pPA grp %pFX with Zebra ",
__func__, &nht_p, &rp_info->group);
pim_find_or_track_nexthop(pim, &nht_p, NULL, rp_info, NULL);
if (!pim_ecmp_nexthop_lookup(pim, &rp_info->rp.source_nexthop, &nht_p,
pim_find_or_track_nexthop(pim, nht_p, NULL, rp_info, NULL);
if (!pim_ecmp_nexthop_lookup(pim, &rp_info->rp.source_nexthop, nht_p,
&rp_info->group, 1)) {
route_unlock_node(rn);
return PIM_RP_NO_PATH;
@ -949,7 +939,7 @@ void pim_rp_setup(struct pim_instance *pim)
{
struct listnode *node;
struct rp_info *rp_info;
struct prefix nht_p;
pim_addr nht_p;
for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
if (pim_rpf_addr_is_inaddr_any(&rp_info->rp))
@ -957,9 +947,9 @@ void pim_rp_setup(struct pim_instance *pim)
nht_p = rp_info->rp.rpf_addr;
pim_find_or_track_nexthop(pim, &nht_p, NULL, rp_info, NULL);
pim_find_or_track_nexthop(pim, nht_p, NULL, rp_info, NULL);
if (!pim_ecmp_nexthop_lookup(pim, &rp_info->rp.source_nexthop,
&nht_p, &rp_info->group, 1))
nht_p, &rp_info->group, 1))
if (PIM_DEBUG_PIM_NHT_RP)
zlog_debug(
"Unable to lookup nexthop for rp specified");
@ -994,12 +984,9 @@ void pim_rp_check_on_if_add(struct pim_interface *pim_ifp)
if (pim_rp_check_interface_addrs(rp_info, pim_ifp)) {
i_am_rp_changed = true;
rp_info->i_am_rp = 1;
if (PIM_DEBUG_PIM_NHT_RP) {
char rp[PREFIX_STRLEN];
pim_addr_dump("<rp?>", &rp_info->rp.rpf_addr,
rp, sizeof(rp));
zlog_debug("%s: %s: i am rp", __func__, rp);
}
if (PIM_DEBUG_PIM_NHT_RP)
zlog_debug("%s: %pPA: i am rp", __func__,
&rp_info->rp.rpf_addr);
}
}
@ -1032,16 +1019,15 @@ void pim_i_am_rp_re_evaluate(struct pim_instance *pim)
if (old_i_am_rp != rp_info->i_am_rp) {
i_am_rp_changed = true;
if (PIM_DEBUG_PIM_NHT_RP) {
char rp[PREFIX_STRLEN];
pim_addr_dump("<rp?>", &rp_info->rp.rpf_addr,
rp, sizeof(rp));
if (rp_info->i_am_rp) {
zlog_debug("%s: %s: i am rp", __func__,
rp);
} else {
zlog_debug("%s: %s: i am no longer rp",
__func__, rp);
}
if (rp_info->i_am_rp)
zlog_debug("%s: %pPA: i am rp",
__func__,
&rp_info->rp.rpf_addr);
else
zlog_debug(
"%s: %pPA: i am no longer rp",
__func__,
&rp_info->rp.rpf_addr);
}
}
}
@ -1088,18 +1074,18 @@ struct pim_rpf *pim_rp_g(struct pim_instance *pim, pim_addr group)
rp_info = pim_rp_find_match_group(pim, &g);
if (rp_info) {
struct prefix nht_p;
pim_addr nht_p;
/* Register addr with Zebra NHT */
nht_p = rp_info->rp.rpf_addr;
if (PIM_DEBUG_PIM_NHT_RP)
zlog_debug(
"%s: NHT Register RP addr %pFX grp %pFX with Zebra",
"%s: NHT Register RP addr %pPA grp %pFX with Zebra",
__func__, &nht_p, &rp_info->group);
pim_find_or_track_nexthop(pim, &nht_p, NULL, rp_info, NULL);
pim_find_or_track_nexthop(pim, nht_p, NULL, rp_info, NULL);
pim_rpf_set_refresh_time(pim);
(void)pim_ecmp_nexthop_lookup(pim, &rp_info->rp.source_nexthop,
&nht_p, &rp_info->group, 1);
nht_p, &rp_info->group, 1);
return (&rp_info->rp);
}
@ -1137,7 +1123,7 @@ int pim_rp_set_upstream_addr(struct pim_instance *pim, pim_addr *up,
}
if (pim_addr_is_any(source))
*up = pim_addr_from_prefix(&rp_info->rp.rpf_addr);
*up = rp_info->rp.rpf_addr;
else
*up = source;
@ -1159,7 +1145,7 @@ int pim_rp_config_write(struct pim_instance *pim, struct vty *vty,
if (rp_info->rp_src == RP_SRC_BSR)
continue;
rp_addr = pim_addr_from_prefix(&rp_info->rp.rpf_addr);
rp_addr = rp_info->rp.rpf_addr;
if (rp_info->plist)
vty_out(vty,
"%s" PIM_AF_NAME
@ -1215,10 +1201,10 @@ void pim_rp_show_information(struct pim_instance *pim, struct prefix *range,
* entry for the previous RP
*/
if (prev_rp_info &&
prefix_cmp(&prev_rp_info->rp.rpf_addr,
&rp_info->rp.rpf_addr)) {
(pim_addr_cmp(prev_rp_info->rp.rpf_addr,
rp_info->rp.rpf_addr))) {
json_object_object_addf(
json, json_rp_rows, "%pFXh",
json, json_rp_rows, "%pPA",
&prev_rp_info->rp.rpf_addr);
json_rp_rows = NULL;
}
@ -1227,7 +1213,7 @@ void pim_rp_show_information(struct pim_instance *pim, struct prefix *range,
json_rp_rows = json_object_new_array();
json_row = json_object_new_object();
json_object_string_addf(json_row, "rpAddress", "%pFXh",
json_object_string_addf(json_row, "rpAddress", "%pPA",
&rp_info->rp.rpf_addr);
if (rp_info->rp.source_nexthop.interface)
json_object_string_add(
@ -1257,7 +1243,7 @@ void pim_rp_show_information(struct pim_instance *pim, struct prefix *range,
json_object_array_add(json_rp_rows, json_row);
} else {
vty_out(vty, "%-15pFXh ", &rp_info->rp.rpf_addr);
vty_out(vty, "%-15pPA ", &rp_info->rp.rpf_addr);
if (rp_info->plist)
vty_out(vty, "%-18s ", rp_info->plist);
@ -1284,7 +1270,7 @@ void pim_rp_show_information(struct pim_instance *pim, struct prefix *range,
if (json) {
if (prev_rp_info && json_rp_rows)
json_object_object_addf(json, json_rp_rows, "%pFXh",
json_object_object_addf(json, json_rp_rows, "%pPA",
&prev_rp_info->rp.rpf_addr);
}
}
@ -1294,7 +1280,7 @@ void pim_resolve_rp_nh(struct pim_instance *pim, struct pim_neighbor *nbr)
struct listnode *node = NULL;
struct rp_info *rp_info = NULL;
struct nexthop *nh_node = NULL;
struct prefix nht_p;
pim_addr nht_p;
struct pim_nexthop_cache pnc;
for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
@ -1303,8 +1289,7 @@ void pim_resolve_rp_nh(struct pim_instance *pim, struct pim_neighbor *nbr)
nht_p = rp_info->rp.rpf_addr;
memset(&pnc, 0, sizeof(struct pim_nexthop_cache));
if (!pim_find_or_track_nexthop(pim, &nht_p, NULL, rp_info,
&pnc))
if (!pim_find_or_track_nexthop(pim, nht_p, NULL, rp_info, &pnc))
continue;
for (nh_node = pnc.nexthop; nh_node; nh_node = nh_node->next) {
@ -1329,7 +1314,7 @@ void pim_resolve_rp_nh(struct pim_instance *pim, struct pim_neighbor *nbr)
#endif
if (PIM_DEBUG_PIM_NHT_RP)
zlog_debug(
"%s: addr %pFXh new nexthop addr %pPAs interface %s",
"%s: addr %pPA new nexthop addr %pPAs interface %s",
__func__, &nht_p, &nbr->source_addr,
ifp1->name);
}

40
pimd/pim_rpf.c
View File

@ -203,11 +203,10 @@ enum pim_rpf_result pim_rpf_update(struct pim_instance *pim,
{
struct pim_rpf *rpf = &up->rpf;
struct pim_rpf saved;
struct prefix nht_p;
struct prefix src, grp;
pim_addr src;
struct prefix grp;
bool neigh_needed = true;
uint32_t saved_mrib_route_metric;
pim_addr rpf_addr;
if (PIM_UPSTREAM_FLAG_TEST_STATIC_IIF(up->flags))
return PIM_RPF_OK;
@ -226,25 +225,22 @@ enum pim_rpf_result pim_rpf_update(struct pim_instance *pim,
old->rpf_addr = saved.rpf_addr;
}
pim_addr_to_prefix(&nht_p, up->upstream_addr);
pim_addr_to_prefix(&src, up->upstream_addr); // RP or Src address
src = up->upstream_addr; // RP or Src address
pim_addr_to_prefix(&grp, up->sg.grp);
if ((pim_addr_is_any(up->sg.src) && I_am_RP(pim, up->sg.grp)) ||
PIM_UPSTREAM_FLAG_TEST_FHR(up->flags))
neigh_needed = false;
pim_find_or_track_nexthop(pim, &nht_p, up, NULL, NULL);
if (!pim_ecmp_nexthop_lookup(pim, &rpf->source_nexthop, &src, &grp,
neigh_needed)) {
pim_find_or_track_nexthop(pim, up->upstream_addr, up, NULL, NULL);
if (!pim_ecmp_nexthop_lookup(pim, &rpf->source_nexthop, src, &grp,
neigh_needed)) {
/* Route is Deleted in Zebra, reset the stored NH data */
pim_upstream_rpf_clear(pim, up);
pim_rpf_cost_change(pim, up, saved_mrib_route_metric);
return PIM_RPF_FAILURE;
}
rpf_addr = pim_rpf_find_rpf_addr(up);
pim_addr_to_prefix(&rpf->rpf_addr, rpf_addr);
rpf->rpf_addr = pim_rpf_find_rpf_addr(up);
if (pim_rpf_addr_is_inaddr_any(rpf) && PIM_DEBUG_ZEBRA) {
/* RPF'(S,G) not found */
@ -287,7 +283,7 @@ enum pim_rpf_result pim_rpf_update(struct pim_instance *pim,
}
/* detect change in RPF'(S,G) */
if (!prefix_same(&saved.rpf_addr, &rpf->rpf_addr) ||
if (pim_addr_cmp(saved.rpf_addr, rpf->rpf_addr) ||
saved.source_nexthop.interface != rpf->source_nexthop.interface) {
pim_rpf_cost_change(pim, up, saved_mrib_route_metric);
return PIM_RPF_CHANGED;
@ -321,7 +317,7 @@ void pim_upstream_rpf_clear(struct pim_instance *pim,
router->infinite_assert_metric.metric_preference;
up->rpf.source_nexthop.mrib_route_metric =
router->infinite_assert_metric.route_metric;
pim_addr_to_prefix(&up->rpf.rpf_addr, PIMADDR_ANY);
up->rpf.rpf_addr = PIMADDR_ANY;
pim_upstream_mroute_iif_update(up->channel_oil, __func__);
}
}
@ -375,15 +371,7 @@ static pim_addr pim_rpf_find_rpf_addr(struct pim_upstream *up)
int pim_rpf_addr_is_inaddr_any(struct pim_rpf *rpf)
{
pim_addr rpf_addr = pim_addr_from_prefix(&rpf->rpf_addr);
switch (rpf->rpf_addr.family) {
case AF_INET:
case AF_INET6:
return pim_addr_is_any(rpf_addr);
default:
return 0;
}
return pim_addr_is_any(rpf->rpf_addr);
}
int pim_rpf_is_same(struct pim_rpf *rpf1, struct pim_rpf *rpf2)
@ -399,10 +387,10 @@ unsigned int pim_rpf_hash_key(const void *arg)
const struct pim_nexthop_cache *r = arg;
#if PIM_IPV == 4
return jhash_1word(r->rpf.rpf_addr.u.prefix4.s_addr, 0);
return jhash_1word(r->rpf.rpf_addr.s_addr, 0);
#else
return jhash2(r->rpf.rpf_addr.u.prefix6.s6_addr32,
array_size(r->rpf.rpf_addr.u.prefix6.s6_addr32), 0);
return jhash2(r->rpf.rpf_addr.s6_addr32,
array_size(r->rpf.rpf_addr.s6_addr32), 0);
#endif
}
@ -413,5 +401,5 @@ bool pim_rpf_equal(const void *arg1, const void *arg2)
const struct pim_nexthop_cache *r2 =
(const struct pim_nexthop_cache *)arg2;
return prefix_same(&r1->rpf.rpf_addr, &r2->rpf.rpf_addr);
return (!pim_addr_cmp(r1->rpf.rpf_addr, r2->rpf.rpf_addr));
}

2
pimd/pim_rpf.h
View File

@ -49,7 +49,7 @@ struct pim_nexthop {
struct pim_rpf {
struct pim_nexthop source_nexthop;
struct prefix rpf_addr; /* RPF'(S,G) */
pim_addr rpf_addr; /* RPF'(S,G) */
};
enum pim_rpf_result { PIM_RPF_OK = 0, PIM_RPF_CHANGED, PIM_RPF_FAILURE };

7
pimd/pim_tib.c
View File

@ -34,7 +34,7 @@ tib_sg_oil_setup(struct pim_instance *pim, pim_sgaddr sg, struct interface *oif)
struct pim_interface *pim_oif = oif->info;
int input_iface_vif_index = 0;
pim_addr vif_source;
struct prefix src, grp;
struct prefix grp;
struct pim_nexthop nexthop;
struct pim_upstream *up = NULL;
@ -43,20 +43,19 @@ tib_sg_oil_setup(struct pim_instance *pim, pim_sgaddr sg, struct interface *oif)
return pim_channel_oil_add(pim, &sg, __func__);
}
pim_addr_to_prefix(&src, vif_source); // RP or Src addr
pim_addr_to_prefix(&grp, sg.grp);
up = pim_upstream_find(pim, &sg);
if (up) {
memcpy(&nexthop, &up->rpf.source_nexthop,
sizeof(struct pim_nexthop));
pim_ecmp_nexthop_lookup(pim, &nexthop, &src, &grp, 0);
pim_ecmp_nexthop_lookup(pim, &nexthop, vif_source, &grp, 0);
if (nexthop.interface)
input_iface_vif_index = pim_if_find_vifindex_by_ifindex(
pim, nexthop.interface->ifindex);
} else
input_iface_vif_index =
pim_ecmp_fib_lookup_if_vif_index(pim, &src, &grp);
pim_ecmp_fib_lookup_if_vif_index(pim, vif_source, &grp);
if (PIM_DEBUG_ZEBRA)
zlog_debug("%s: NHT %pSG vif_source %pPAs vif_index:%d",

69
pimd/pim_upstream.c
View File

@ -192,7 +192,6 @@ struct pim_upstream *pim_upstream_del(struct pim_instance *pim,
struct listnode *node, *nnode;
struct pim_ifchannel *ch;
bool notify_msdp = false;
struct prefix nht_p;
if (PIM_DEBUG_PIM_TRACE)
zlog_debug(
@ -267,12 +266,11 @@ struct pim_upstream *pim_upstream_del(struct pim_instance *pim,
*/
if (!pim_addr_is_any(up->upstream_addr)) {
/* Deregister addr with Zebra NHT */
pim_addr_to_prefix(&nht_p, up->upstream_addr);
if (PIM_DEBUG_PIM_TRACE)
zlog_debug(
"%s: Deregister upstream %s addr %pFX with Zebra NHT",
__func__, up->sg_str, &nht_p);
pim_delete_tracked_nexthop(pim, &nht_p, up, NULL);
"%s: Deregister upstream %s addr %pPA with Zebra NHT",
__func__, up->sg_str, &up->upstream_addr);
pim_delete_tracked_nexthop(pim, up->upstream_addr, up, NULL);
}
XFREE(MTYPE_PIM_UPSTREAM, up);
@ -290,16 +288,13 @@ void pim_upstream_send_join(struct pim_upstream *up)
}
if (PIM_DEBUG_PIM_TRACE) {
char rpf_str[PREFIX_STRLEN];
pim_addr_dump("<rpf?>", &up->rpf.rpf_addr, rpf_str,
sizeof(rpf_str));
zlog_debug("%s: RPF'%s=%s(%s) for Interface %s", __func__,
up->sg_str, rpf_str,
zlog_debug("%s: RPF'%s=%pPA(%s) for Interface %s", __func__,
up->sg_str, &up->rpf.rpf_addr,
pim_upstream_state2str(up->join_state),
up->rpf.source_nexthop.interface->name);
if (pim_rpf_addr_is_inaddr_any(&up->rpf)) {
zlog_debug("%s: can't send join upstream: RPF'%s=%s",
__func__, up->sg_str, rpf_str);
zlog_debug("%s: can't send join upstream: RPF'%s=%pPA",
__func__, up->sg_str, &up->rpf.rpf_addr);
/* warning only */
}
}
@ -345,8 +340,8 @@ static void join_timer_stop(struct pim_upstream *up)
THREAD_OFF(up->t_join_timer);
if (up->rpf.source_nexthop.interface)
nbr = pim_neighbor_find_prefix(up->rpf.source_nexthop.interface,
&up->rpf.rpf_addr);
nbr = pim_neighbor_find(up->rpf.source_nexthop.interface,
up->rpf.rpf_addr);
if (nbr)
pim_jp_agg_remove_group(nbr->upstream_jp_agg, up, nbr);
@ -359,8 +354,8 @@ void join_timer_start(struct pim_upstream *up)
struct pim_neighbor *nbr = NULL;
if (up->rpf.source_nexthop.interface) {
nbr = pim_neighbor_find_prefix(up->rpf.source_nexthop.interface,
&up->rpf.rpf_addr);
nbr = pim_neighbor_find(up->rpf.source_nexthop.interface,
up->rpf.rpf_addr);
if (PIM_DEBUG_PIM_EVENTS) {
zlog_debug(
@ -428,7 +423,7 @@ void pim_update_suppress_timers(uint32_t suppress_time)
}
}
void pim_upstream_join_suppress(struct pim_upstream *up, struct prefix rpf,
void pim_upstream_join_suppress(struct pim_upstream *up, pim_addr rpf,
int holdtime)
{
long t_joinsuppress_msec;
@ -451,23 +446,19 @@ void pim_upstream_join_suppress(struct pim_upstream *up, struct prefix rpf,
pim_time_timer_remain_msec(up->t_join_timer);
else {
/* Remove it from jp agg from the nbr for suppression */
nbr = pim_neighbor_find_prefix(up->rpf.source_nexthop.interface,
&up->rpf.rpf_addr);
nbr = pim_neighbor_find(up->rpf.source_nexthop.interface,
up->rpf.rpf_addr);
if (nbr) {
join_timer_remain_msec =
pim_time_timer_remain_msec(nbr->jp_timer);
}
}
if (PIM_DEBUG_PIM_TRACE) {
char rpf_str[INET_ADDRSTRLEN];
pim_addr_dump("<rpf?>", &rpf, rpf_str, sizeof(rpf_str));
if (PIM_DEBUG_PIM_TRACE)
zlog_debug(
"%s %s: detected Join%s to RPF'(S,G)=%s: join_timer=%ld msec t_joinsuppress=%ld msec",
__FILE__, __func__, up->sg_str, rpf_str,
"%s %s: detected Join%s to RPF'(S,G)=%pPA: join_timer=%ld msec t_joinsuppress=%ld msec",
__FILE__, __func__, up->sg_str, &rpf,
join_timer_remain_msec, t_joinsuppress_msec);
}
if (join_timer_remain_msec < t_joinsuppress_msec) {
if (PIM_DEBUG_PIM_TRACE) {
@ -507,8 +498,8 @@ void pim_upstream_join_timer_decrease_to_t_override(const char *debug_label,
/* upstream join tracked with neighbor jp timer */
struct pim_neighbor *nbr;
nbr = pim_neighbor_find_prefix(up->rpf.source_nexthop.interface,
&up->rpf.rpf_addr);
nbr = pim_neighbor_find(up->rpf.source_nexthop.interface,
up->rpf.rpf_addr);
if (nbr)
join_timer_remain_msec =
pim_time_timer_remain_msec(nbr->jp_timer);
@ -517,17 +508,11 @@ void pim_upstream_join_timer_decrease_to_t_override(const char *debug_label,
join_timer_remain_msec = t_override_msec + 1;
}
if (PIM_DEBUG_PIM_TRACE) {
char rpf_str[INET_ADDRSTRLEN];
pim_addr_dump("<rpf?>", &up->rpf.rpf_addr, rpf_str,
sizeof(rpf_str));
if (PIM_DEBUG_PIM_TRACE)
zlog_debug(
"%s: to RPF'%s=%s: join_timer=%ld msec t_override=%d msec",
debug_label, up->sg_str, rpf_str,
"%s: to RPF'%s=%pPA: join_timer=%ld msec t_override=%d msec",
debug_label, up->sg_str, &up->rpf.rpf_addr,
join_timer_remain_msec, t_override_msec);
}
if (join_timer_remain_msec > t_override_msec) {
if (PIM_DEBUG_PIM_TRACE) {
@ -842,9 +827,7 @@ void pim_upstream_fill_static_iif(struct pim_upstream *up,
up->rpf.source_nexthop.mrib_metric_preference =
ZEBRA_CONNECT_DISTANCE_DEFAULT;
up->rpf.source_nexthop.mrib_route_metric = 0;
up->rpf.rpf_addr.family = AF_INET;
up->rpf.rpf_addr.u.prefix4.s_addr = PIM_NET_INADDR_ANY;
up->rpf.rpf_addr = PIMADDR_ANY;
}
static struct pim_upstream *pim_upstream_new(struct pim_instance *pim,
@ -903,7 +886,7 @@ static struct pim_upstream *pim_upstream_new(struct pim_instance *pim,
router->infinite_assert_metric.metric_preference;
up->rpf.source_nexthop.mrib_route_metric =
router->infinite_assert_metric.route_metric;
pim_addr_to_prefix(&up->rpf.rpf_addr, PIMADDR_ANY);
up->rpf.rpf_addr = PIMADDR_ANY;
up->ifchannels = list_new();
up->ifchannels->cmp = (int (*)(void *, void *))pim_ifchannel_compare;
@ -1070,7 +1053,7 @@ struct pim_upstream *pim_upstream_add(struct pim_instance *pim, pim_sgaddr *sg,
if (PIM_DEBUG_PIM_TRACE) {
if (up)
zlog_debug("%s(%s): %s, iif %pFX (%s) found: %d: ref_count: %d",
zlog_debug("%s(%s): %s, iif %pPA (%s) found: %d: ref_count: %d",
__func__, name,
up->sg_str, &up->rpf.rpf_addr, up->rpf.source_nexthop.interface ?
up->rpf.source_nexthop.interface->name : "Unknown" ,
@ -1274,7 +1257,7 @@ void pim_upstream_rpf_genid_changed(struct pim_instance *pim,
frr_each (rb_pim_upstream, &pim->upstream_head, up) {
pim_addr rpf_addr;
rpf_addr = pim_addr_from_prefix(&up->rpf.rpf_addr);
rpf_addr = up->rpf.rpf_addr;
if (PIM_DEBUG_PIM_TRACE)
zlog_debug(

2
pimd/pim_upstream.h
View File

@ -317,7 +317,7 @@ void pim_upstream_update_join_desired(struct pim_instance *pim,
struct pim_upstream *up);
void pim_update_suppress_timers(uint32_t suppress_time);
void pim_upstream_join_suppress(struct pim_upstream *up, struct prefix rpf,
void pim_upstream_join_suppress(struct pim_upstream *up, pim_addr rpf,
int holdtime);
void pim_upstream_join_timer_decrease_to_t_override(const char *debug_label,

6
pimd/pim_vxlan.c
View File

@ -303,7 +303,6 @@ static void pim_vxlan_orig_mr_up_add(struct pim_vxlan_sg *vxlan_sg)
struct pim_upstream *up;
struct pim_interface *term_ifp;
int flags = 0;
struct prefix nht_p;
struct pim_instance *pim = vxlan_sg->pim;
if (vxlan_sg->up) {
@ -353,9 +352,8 @@ static void pim_vxlan_orig_mr_up_add(struct pim_vxlan_sg *vxlan_sg)
* iif
*/
if (!PIM_UPSTREAM_FLAG_TEST_STATIC_IIF(up->flags)) {
pim_addr_to_prefix(&nht_p, up->upstream_addr);
pim_delete_tracked_nexthop(vxlan_sg->pim, &nht_p, up,
NULL);
pim_delete_tracked_nexthop(vxlan_sg->pim,
up->upstream_addr, up, NULL);
}
/* We are acting FHR; clear out use_rpt setting if any */
pim_upstream_update_use_rpt(up, false /*update_mroute*/);

6
pimd/pim_zebra.c
View File

@ -255,7 +255,7 @@ void pim_zebra_update_all_interfaces(struct pim_instance *pim)
struct pim_rpf rpf;
rpf.source_nexthop.interface = ifp;
pim_addr_to_prefix(&rpf.rpf_addr, us->address);
rpf.rpf_addr = us->address;
pim_joinprune_send(&rpf, us->us);
pim_jp_agg_clear_group(us->us);
}
@ -269,8 +269,8 @@ void pim_zebra_upstream_rpf_changed(struct pim_instance *pim,
if (old->source_nexthop.interface) {
struct pim_neighbor *nbr;
nbr = pim_neighbor_find_prefix(old->source_nexthop.interface,
&old->rpf_addr);
nbr = pim_neighbor_find(old->source_nexthop.interface,
old->rpf_addr);
if (nbr)
pim_jp_agg_remove_group(nbr->upstream_jp_agg, up, nbr);