proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-08-11 20:26:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #10712 from patrasar/pim_nexthop_prefix_to_pimaddr

Browse Source
This commit is contained in:
David Lamparter 2022-04-26 15:39:36 +02:00 committed by GitHub
commit d1b7dfbe08
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 91 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
pimd/pim6_cmd.c
View File

@ -1541,7 +1541,6 @@ DEFPY (show_ipv6_pim_nexthop_lookup,
pim_addr vif_source; pim_addr vif_source;
struct prefix grp; struct prefix grp;
struct pim_nexthop nexthop; struct pim_nexthop nexthop;
char nexthop_addr_str[PIM_ADDRSTRLEN];
struct vrf *v; struct vrf *v;
v = vrf_lookup_by_name(vrf ? vrf : VRF_DEFAULT_NAME); v = vrf_lookup_by_name(vrf ? vrf : VRF_DEFAULT_NAME);
@ -1564,10 +1563,8 @@ DEFPY (show_ipv6_pim_nexthop_lookup,
return CMD_SUCCESS; return CMD_SUCCESS;
} }
pim_addr_dump("<nexthop?>", &nexthop.mrib_nexthop_addr, vty_out(vty, "Group %s --- Nexthop %pPAs Interface %s\n", group_str,
nexthop_addr_str, sizeof(nexthop_addr_str)); &nexthop.mrib_nexthop_addr, nexthop.interface->name);
vty_out(vty, "Group %s --- Nexthop %s Interface %s\n", group_str,
nexthop_addr_str, nexthop.interface->name);
return CMD_SUCCESS; return CMD_SUCCESS;
} }

14
pimd/pim_cmd.c
View File

@ -3525,7 +3525,6 @@ DEFPY (show_ip_pim_nexthop_lookup,
pim_addr vif_source; pim_addr vif_source;
struct prefix grp; struct prefix grp;
struct pim_nexthop nexthop; struct pim_nexthop nexthop;
char nexthop_addr_str[PREFIX_STRLEN];
struct vrf *v; struct vrf *v;
v = vrf_lookup_by_name(vrf ? vrf : VRF_DEFAULT_NAME); v = vrf_lookup_by_name(vrf ? vrf : VRF_DEFAULT_NAME);
@ -3560,10 +3559,8 @@ DEFPY (show_ip_pim_nexthop_lookup,
return CMD_SUCCESS; return CMD_SUCCESS;
} }
pim_addr_dump("<nexthop?>", &nexthop.mrib_nexthop_addr, vty_out(vty, "Group %s --- Nexthop %pPAs Interface %s \n", group_str,
nexthop_addr_str, sizeof(nexthop_addr_str)); &nexthop.mrib_nexthop_addr, nexthop.interface->name);
vty_out(vty, "Group %s --- Nexthop %s Interface %s \n", group_str,
nexthop_addr_str, nexthop.interface->name);
return CMD_SUCCESS; return CMD_SUCCESS;
} }
@ -4680,7 +4677,6 @@ DEFUN (show_ip_rib,
struct in_addr addr; struct in_addr addr;
const char *addr_str; const char *addr_str;
struct pim_nexthop nexthop; struct pim_nexthop nexthop;
char nexthop_addr_str[PREFIX_STRLEN];
int result; int result;
if (!vrf) if (!vrf)
@ -4706,10 +4702,8 @@ DEFUN (show_ip_rib,
vty_out(vty, vty_out(vty,
"Address NextHop Interface Metric Preference\n"); "Address NextHop Interface Metric Preference\n");
pim_addr_dump("<nexthop?>", &nexthop.mrib_nexthop_addr, vty_out(vty, "%-15s %-15pPAs %-9s %6d %10d\n", addr_str,
nexthop_addr_str, sizeof(nexthop_addr_str)); &nexthop.mrib_nexthop_addr,
vty_out(vty, "%-15s %-15s %-9s %6d %10d\n", addr_str, nexthop_addr_str,
nexthop.interface ? nexthop.interface->name : "<ifname?>", nexthop.interface ? nexthop.interface->name : "<ifname?>",
nexthop.mrib_route_metric, nexthop.mrib_metric_preference); nexthop.mrib_route_metric, nexthop.mrib_metric_preference);

28
pimd/pim_cmd_common.c
View File

@ -882,15 +882,11 @@ void pim_show_rpf(struct pim_instance *pim, struct vty *vty, json_object *json)
frr_each (rb_pim_upstream, &pim->upstream_head, up) { frr_each (rb_pim_upstream, &pim->upstream_head, up) {
char rpf_addr_str[PREFIX_STRLEN]; char rpf_addr_str[PREFIX_STRLEN];
char rib_nexthop_str[PREFIX_STRLEN];
const char *rpf_ifname; const char *rpf_ifname;
struct pim_rpf *rpf = &up->rpf; struct pim_rpf *rpf = &up->rpf;
pim_addr_dump("<rpf?>", &rpf->rpf_addr, rpf_addr_str, pim_addr_dump("<rpf?>", &rpf->rpf_addr, rpf_addr_str,
sizeof(rpf_addr_str)); sizeof(rpf_addr_str));
pim_addr_dump("<nexthop?>",
&rpf->source_nexthop.mrib_nexthop_addr,
rib_nexthop_str, sizeof(rib_nexthop_str));
rpf_ifname = rpf_ifname =
rpf->source_nexthop.interface ? rpf->source_nexthop rpf->source_nexthop.interface ? rpf->source_nexthop
@ -921,8 +917,9 @@ void pim_show_rpf(struct pim_instance *pim, struct vty *vty, json_object *json)
rpf_ifname); rpf_ifname);
json_object_string_add(json_row, "rpfAddress", json_object_string_add(json_row, "rpfAddress",
rpf_addr_str); rpf_addr_str);
json_object_string_add(json_row, "ribNexthop", json_object_string_addf(
rib_nexthop_str); json_row, "ribNexthop", "%pPAs",
&rpf->source_nexthop.mrib_nexthop_addr);
json_object_int_add( json_object_int_add(
json_row, "routeMetric", json_row, "routeMetric",
rpf->source_nexthop.mrib_route_metric); rpf->source_nexthop.mrib_route_metric);
@ -933,9 +930,10 @@ void pim_show_rpf(struct pim_instance *pim, struct vty *vty, json_object *json)
} else { } else {
vty_out(vty, vty_out(vty,
"%-15pPAs %-15pPAs %-16s %-15s %-15s %6d %4d\n", "%-15pPAs %-15pPAs %-16s %-15s %-15pPAs %6d %4d\n",
&up->sg.src, &up->sg.grp, rpf_ifname, &up->sg.src, &up->sg.grp, rpf_ifname,
rpf_addr_str, rib_nexthop_str, rpf_addr_str,
&rpf->source_nexthop.mrib_nexthop_addr,
rpf->source_nexthop.mrib_route_metric, rpf->source_nexthop.mrib_route_metric,
rpf->source_nexthop.mrib_metric_preference); rpf->source_nexthop.mrib_metric_preference);
} }
@ -1519,16 +1517,12 @@ void pim_show_upstream_rpf(struct pim_instance *pim, struct vty *vty, bool uj)
"Source Group RpfIface RibNextHop RpfAddress \n"); "Source Group RpfIface RibNextHop RpfAddress \n");
frr_each (rb_pim_upstream, &pim->upstream_head, up) { frr_each (rb_pim_upstream, &pim->upstream_head, up) {
char rpf_nexthop_str[PREFIX_STRLEN];
char rpf_addr_str[PREFIX_STRLEN]; char rpf_addr_str[PREFIX_STRLEN];
struct pim_rpf *rpf; struct pim_rpf *rpf;
const char *rpf_ifname; const char *rpf_ifname;
rpf = &up->rpf; rpf = &up->rpf;
pim_addr_dump("<nexthop?>",
&rpf->source_nexthop.mrib_nexthop_addr,
rpf_nexthop_str, sizeof(rpf_nexthop_str));
pim_addr_dump("<rpf?>", &rpf->rpf_addr, rpf_addr_str, pim_addr_dump("<rpf?>", &rpf->rpf_addr, rpf_addr_str,
sizeof(rpf_addr_str)); sizeof(rpf_addr_str));
@ -1559,15 +1553,17 @@ void pim_show_upstream_rpf(struct pim_instance *pim, struct vty *vty, bool uj)
json_object_string_add(json_row, "group", grp_str); json_object_string_add(json_row, "group", grp_str);
json_object_string_add(json_row, "rpfInterface", json_object_string_add(json_row, "rpfInterface",
rpf_ifname); rpf_ifname);
json_object_string_add(json_row, "ribNexthop", json_object_string_addf(
rpf_nexthop_str); json_row, "ribNexthop", "%pPAs",
&rpf->source_nexthop.mrib_nexthop_addr);
json_object_string_add(json_row, "rpfAddress", json_object_string_add(json_row, "rpfAddress",
rpf_addr_str); rpf_addr_str);
json_object_object_add(json_group, src_str, json_row); json_object_object_add(json_group, src_str, json_row);
} else { } else {
vty_out(vty, "%-15pPAs %-15pPAs %-16s %-15s %-15s\n", vty_out(vty, "%-15pPAs %-15pPAs %-16s %-15pPA %-15s\n",
&up->sg.src, &up->sg.grp, rpf_ifname, &up->sg.src, &up->sg.grp, rpf_ifname,
rpf_nexthop_str, rpf_addr_str); &rpf->source_nexthop.mrib_nexthop_addr,
rpf_addr_str);
} }
} }

8
pimd/pim_igmp_mtrace.c
View File

@ -81,11 +81,9 @@ static bool mtrace_fwd_info_weak(struct pim_instance *pim,
zlog_debug("mtrace pim_nexthop_lookup OK"); zlog_debug("mtrace pim_nexthop_lookup OK");
if (PIM_DEBUG_MTRACE) if (PIM_DEBUG_MTRACE)
zlog_debug("mtrace next_hop=%pI4", zlog_debug("mtrace next_hop=%pPAs", &nexthop.mrib_nexthop_addr);
&nexthop.mrib_nexthop_addr.u.prefix4);
if (nexthop.mrib_nexthop_addr.family == AF_INET) nh_addr = nexthop.mrib_nexthop_addr;
nh_addr = nexthop.mrib_nexthop_addr.u.prefix4;
ifp_in = nexthop.interface; ifp_in = nexthop.interface;
@ -134,7 +132,7 @@ static bool mtrace_fwd_info(struct pim_instance *pim,
} }
ifp_in = up->rpf.source_nexthop.interface; ifp_in = up->rpf.source_nexthop.interface;
nh_addr = up->rpf.source_nexthop.mrib_nexthop_addr.u.prefix4; nh_addr = up->rpf.source_nexthop.mrib_nexthop_addr;
total = htonl(MTRACE_UNKNOWN_COUNT); total = htonl(MTRACE_UNKNOWN_COUNT);
if (PIM_DEBUG_MTRACE) if (PIM_DEBUG_MTRACE)

4
pimd/pim_msdp.c
View File

@ -709,8 +709,8 @@ bool pim_msdp_peer_rpf_check(struct pim_msdp_peer *mp, struct in_addr rp)
} }
/* check if the MSDP peer is the nexthop for the RP */ /* check if the MSDP peer is the nexthop for the RP */
if (pim_nexthop_lookup(mp->pim, &nexthop, rp, 0) if (pim_nexthop_lookup(mp->pim, &nexthop, rp, 0) &&
&& nexthop.mrib_nexthop_addr.u.prefix4.s_addr == mp->peer.s_addr) { nexthop.mrib_nexthop_addr.s_addr == mp->peer.s_addr) {
return true; return true;
} }

44
pimd/pim_nht.c
View File

@ -331,13 +331,12 @@ bool pim_nht_bsr_rpf_check(struct pim_instance *pim, struct in_addr bsr_addr,
if (if_is_loopback(ifp) && if_is_loopback(src_ifp)) if (if_is_loopback(ifp) && if_is_loopback(src_ifp))
return true; return true;
nbr = pim_neighbor_find_prefix(ifp, &znh->nexthop_addr); nbr = pim_neighbor_find(ifp, znh->nexthop_addr);
if (!nbr) if (!nbr)
continue; continue;
return znh->ifindex == src_ifp->ifindex return znh->ifindex == src_ifp->ifindex &&
&& znh->nexthop_addr.u.prefix4.s_addr (!pim_addr_cmp(znh->nexthop_addr, src_ip));
== src_ip.s_addr;
} }
return false; return false;
} }
@ -406,8 +405,7 @@ bool pim_nht_bsr_rpf_check(struct pim_instance *pim, struct in_addr bsr_addr,
void pim_rp_nexthop_del(struct rp_info *rp_info) void pim_rp_nexthop_del(struct rp_info *rp_info)
{ {
rp_info->rp.source_nexthop.interface = NULL; rp_info->rp.source_nexthop.interface = NULL;
pim_addr_to_prefix(&rp_info->rp.source_nexthop.mrib_nexthop_addr, rp_info->rp.source_nexthop.mrib_nexthop_addr = PIMADDR_ANY;
PIMADDR_ANY);
rp_info->rp.source_nexthop.mrib_metric_preference = rp_info->rp.source_nexthop.mrib_metric_preference =
router->infinite_assert_metric.metric_preference; router->infinite_assert_metric.metric_preference;
rp_info->rp.source_nexthop.mrib_route_metric = rp_info->rp.source_nexthop.mrib_route_metric =
@ -510,7 +508,7 @@ static int pim_ecmp_nexthop_search(struct pim_instance *pim,
uint32_t hash_val = 0, mod_val = 0; uint32_t hash_val = 0, mod_val = 0;
uint8_t nh_iter = 0, found = 0; uint8_t nh_iter = 0, found = 0;
uint32_t i, num_nbrs = 0; uint32_t i, num_nbrs = 0;
pim_addr nh_addr = pim_addr_from_prefix(&(nexthop->mrib_nexthop_addr)); pim_addr nh_addr = nexthop->mrib_nexthop_addr;
pim_addr src_addr = pim_addr_from_prefix(src); pim_addr src_addr = pim_addr_from_prefix(src);
pim_addr grp_addr = pim_addr_from_prefix(grp); pim_addr grp_addr = pim_addr_from_prefix(grp);
@ -546,9 +544,9 @@ static int pim_ecmp_nexthop_search(struct pim_instance *pim,
if (curr_route_valid && if (curr_route_valid &&
!pim_if_connected_to_source(nexthop->interface, !pim_if_connected_to_source(nexthop->interface,
src_addr)) { src_addr)) {
nbr = pim_neighbor_find_prefix( nbr = pim_neighbor_find(
nexthop->interface, nexthop->interface,
&nexthop->mrib_nexthop_addr); nexthop->mrib_nexthop_addr);
if (!nbr if (!nbr
&& !if_is_loopback(nexthop->interface)) { && !if_is_loopback(nexthop->interface)) {
if (PIM_DEBUG_PIM_NHT) if (PIM_DEBUG_PIM_NHT)
@ -655,14 +653,10 @@ static int pim_ecmp_nexthop_search(struct pim_instance *pim,
if (nh_iter == mod_val) { if (nh_iter == mod_val) {
nexthop->interface = ifp; nexthop->interface = ifp;
nexthop->mrib_nexthop_addr.family = PIM_AF;
nexthop->mrib_nexthop_addr.prefixlen = PIM_MAX_BITLEN;
#if PIM_IPV == 4 #if PIM_IPV == 4
nexthop->mrib_nexthop_addr.u.prefix4 = nexthop->mrib_nexthop_addr = nh_node->gate.ipv4;
nh_node->gate.ipv4;
#else #else
nexthop->mrib_nexthop_addr.u.prefix6 = nexthop->mrib_nexthop_addr = nh_node->gate.ipv6;
nh_node->gate.ipv6;
#endif #endif
nexthop->mrib_metric_preference = pnc->distance; nexthop->mrib_metric_preference = pnc->distance;
nexthop->mrib_route_metric = pnc->metric; nexthop->mrib_route_metric = pnc->metric;
@ -942,8 +936,8 @@ int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
ifps[i] = if_lookup_by_index(nexthop_tab[i].ifindex, ifps[i] = if_lookup_by_index(nexthop_tab[i].ifindex,
pim->vrf->vrf_id); pim->vrf->vrf_id);
if (ifps[i]) { if (ifps[i]) {
nbrs[i] = pim_neighbor_find_prefix( nbrs[i] = pim_neighbor_find(
ifps[i], &nexthop_tab[i].nexthop_addr); ifps[i], nexthop_tab[i].nexthop_addr);
if (nbrs[i] || if (nbrs[i] ||
pim_if_connected_to_source(ifps[i], src_addr)) pim_if_connected_to_source(ifps[i], src_addr))
num_nbrs++; num_nbrs++;
@ -1006,7 +1000,7 @@ int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
mod_val++; mod_val++;
if (PIM_DEBUG_PIM_NHT) if (PIM_DEBUG_PIM_NHT)
zlog_debug( zlog_debug(
"%s: NBR (%pFXh) not found on input interface %s(%s) (RPF for source %pPA)", "%s: NBR (%pPA) not found on input interface %s(%s) (RPF for source %pPA)",
__func__, __func__,
&nexthop_tab[i].nexthop_addr, &nexthop_tab[i].nexthop_addr,
ifp->name, pim->vrf->name, ifp->name, pim->vrf->name,
@ -1017,19 +1011,13 @@ int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
} }
if (i == mod_val) { if (i == mod_val) {
if (PIM_DEBUG_PIM_NHT) { if (PIM_DEBUG_PIM_NHT)
char nexthop_str[PREFIX_STRLEN];
pim_addr_dump("<nexthop?>",
&nexthop_tab[i].nexthop_addr,
nexthop_str, sizeof(nexthop_str));
zlog_debug( zlog_debug(
"%s: found nhop %s for addr %pPA interface %s(%s) metric %d dist %d", "%s: found nhop %pPA for addr %pPA interface %s(%s) metric %d dist %d",
__func__, nexthop_str, &src_addr, __func__, &nexthop_tab[i].nexthop_addr,
ifp->name, pim->vrf->name, &src_addr, ifp->name, pim->vrf->name,
nexthop_tab[i].route_metric, nexthop_tab[i].route_metric,
nexthop_tab[i].protocol_distance); nexthop_tab[i].protocol_distance);
}
/* update nexthop data */ /* update nexthop data */
nexthop->interface = ifp; nexthop->interface = ifp;
nexthop->mrib_nexthop_addr = nexthop->mrib_nexthop_addr =

26
pimd/pim_rpf.c
View File

@ -76,7 +76,7 @@ bool pim_nexthop_lookup(struct pim_instance *pim, struct pim_nexthop *nexthop,
if (PIM_DEBUG_PIM_NHT) if (PIM_DEBUG_PIM_NHT)
zlog_debug( zlog_debug(
"%s: Using last lookup for %pPAs at %lld, %" PRId64 "%s: Using last lookup for %pPAs at %lld, %" PRId64
" addr %pFX", " addr %pPAs",
__func__, &addr, nexthop->last_lookup_time, __func__, &addr, nexthop->last_lookup_time,
pim->last_route_change_time, pim->last_route_change_time,
&nexthop->mrib_nexthop_addr); &nexthop->mrib_nexthop_addr);
@ -124,8 +124,8 @@ bool pim_nexthop_lookup(struct pim_instance *pim, struct pim_nexthop *nexthop,
i++; i++;
} else if (neighbor_needed } else if (neighbor_needed
&& !pim_if_connected_to_source(ifp, addr)) { && !pim_if_connected_to_source(ifp, addr)) {
nbr = pim_neighbor_find_prefix( nbr = pim_neighbor_find(ifp,
ifp, &nexthop_tab[i].nexthop_addr); nexthop_tab[i].nexthop_addr);
if (PIM_DEBUG_PIM_TRACE_DETAIL) if (PIM_DEBUG_PIM_TRACE_DETAIL)
zlog_debug("ifp name: %s, pim nbr: %p", zlog_debug("ifp name: %s, pim nbr: %p",
ifp->name, nbr); ifp->name, nbr);
@ -140,11 +140,12 @@ bool pim_nexthop_lookup(struct pim_instance *pim, struct pim_nexthop *nexthop,
if (found) { if (found) {
if (PIM_DEBUG_ZEBRA) if (PIM_DEBUG_ZEBRA)
zlog_debug( zlog_debug(
"%s %s: found nexthop %pFX for address %pPAs: interface %s ifindex=%d metric=%d pref=%d", "%s %s: found nexthop %pPAs for address %pPAs: interface %s ifindex=%d metric=%d pref=%d",
__FILE__, __func__, __FILE__, __func__,
&nexthop_tab[i].nexthop_addr, &addr, ifp->name, &nexthop_tab[i].nexthop_addr, &addr, ifp->name,
first_ifindex, nexthop_tab[i].route_metric, first_ifindex, nexthop_tab[i].route_metric,
nexthop_tab[i].protocol_distance); nexthop_tab[i].protocol_distance);
/* update nexthop data */ /* update nexthop data */
nexthop->interface = ifp; nexthop->interface = ifp;
nexthop->mrib_nexthop_addr = nexthop_tab[i].nexthop_addr; nexthop->mrib_nexthop_addr = nexthop_tab[i].nexthop_addr;
@ -162,11 +163,8 @@ bool pim_nexthop_lookup(struct pim_instance *pim, struct pim_nexthop *nexthop,
static int nexthop_mismatch(const struct pim_nexthop *nh1, static int nexthop_mismatch(const struct pim_nexthop *nh1,
const struct pim_nexthop *nh2) const struct pim_nexthop *nh2)
{ {
pim_addr nh_addr1 = pim_addr_from_prefix(&nh1->mrib_nexthop_addr);
pim_addr nh_addr2 = pim_addr_from_prefix(&nh2->mrib_nexthop_addr);
return (nh1->interface != nh2->interface) || return (nh1->interface != nh2->interface) ||
(pim_addr_cmp(nh_addr1, nh_addr2)) || (pim_addr_cmp(nh1->mrib_nexthop_addr, nh2->mrib_nexthop_addr)) ||
(nh1->mrib_metric_preference != nh2->mrib_metric_preference) || (nh1->mrib_metric_preference != nh2->mrib_metric_preference) ||
(nh1->mrib_route_metric != nh2->mrib_route_metric); (nh1->mrib_route_metric != nh2->mrib_route_metric);
} }
@ -257,7 +255,7 @@ enum pim_rpf_result pim_rpf_update(struct pim_instance *pim,
if (nexthop_mismatch(&rpf->source_nexthop, &saved.source_nexthop)) { if (nexthop_mismatch(&rpf->source_nexthop, &saved.source_nexthop)) {
if (PIM_DEBUG_ZEBRA) if (PIM_DEBUG_ZEBRA)
zlog_debug("%s(%s): (S,G)=%s source nexthop now is: interface=%s address=%pFX pref=%d metric=%d", zlog_debug("%s(%s): (S,G)=%s source nexthop now is: interface=%s address=%pPAs pref=%d metric=%d",
__func__, caller, __func__, caller,
up->sg_str, up->sg_str,
rpf->source_nexthop.interface ? rpf->source_nexthop.interface->name : "<ifname?>", rpf->source_nexthop.interface ? rpf->source_nexthop.interface->name : "<ifname?>",
@ -316,8 +314,7 @@ void pim_upstream_rpf_clear(struct pim_instance *pim,
if (up->rpf.source_nexthop.interface) { if (up->rpf.source_nexthop.interface) {
pim_upstream_switch(pim, up, PIM_UPSTREAM_NOTJOINED); pim_upstream_switch(pim, up, PIM_UPSTREAM_NOTJOINED);
up->rpf.source_nexthop.interface = NULL; up->rpf.source_nexthop.interface = NULL;
pim_addr_to_prefix(&up->rpf.source_nexthop.mrib_nexthop_addr, up->rpf.source_nexthop.mrib_nexthop_addr = PIMADDR_ANY;
PIMADDR_ANY);
up->rpf.source_nexthop.mrib_metric_preference = up->rpf.source_nexthop.mrib_metric_preference =
router->infinite_assert_metric.metric_preference; router->infinite_assert_metric.metric_preference;
up->rpf.source_nexthop.mrib_route_metric = up->rpf.source_nexthop.mrib_route_metric =
@ -364,11 +361,8 @@ static pim_addr pim_rpf_find_rpf_addr(struct pim_upstream *up)
/* return NBR( RPF_interface(S), MRIB.next_hop( S ) ) */ /* return NBR( RPF_interface(S), MRIB.next_hop( S ) ) */
pim_addr nhaddr; neigh = pim_if_find_neighbor(up->rpf.source_nexthop.interface,
up->rpf.source_nexthop.mrib_nexthop_addr);
nhaddr =
pim_addr_from_prefix(&up->rpf.source_nexthop.mrib_nexthop_addr);
neigh = pim_if_find_neighbor(up->rpf.source_nexthop.interface, nhaddr);
if (neigh) if (neigh)
rpf_addr = neigh->source_addr; rpf_addr = neigh->source_addr;
else else

2
pimd/pim_rpf.h
View File

@ -39,7 +39,7 @@ struct pim_nexthop {
pim_addr last_lookup; pim_addr last_lookup;
long long last_lookup_time; long long last_lookup_time;
struct interface *interface; /* RPF_interface(S) */ struct interface *interface; /* RPF_interface(S) */
struct prefix mrib_nexthop_addr; /* MRIB.next_hop(S) */ pim_addr mrib_nexthop_addr; /* MRIB.next_hop(S) */
uint32_t mrib_metric_preference; /* MRIB.pref(S) */ uint32_t mrib_metric_preference; /* MRIB.pref(S) */
uint32_t mrib_route_metric; /* MRIB.metric(S) */ uint32_t mrib_route_metric; /* MRIB.metric(S) */
struct pim_neighbor *nbr; struct pim_neighbor *nbr;

6
pimd/pim_upstream.c
View File

@ -838,8 +838,7 @@ void pim_upstream_fill_static_iif(struct pim_upstream *up,
up->rpf.source_nexthop.interface = incoming; up->rpf.source_nexthop.interface = incoming;
/* reset other parameters to matched a connected incoming interface */ /* reset other parameters to matched a connected incoming interface */
pim_addr_to_prefix(&up->rpf.source_nexthop.mrib_nexthop_addr, up->rpf.source_nexthop.mrib_nexthop_addr = PIMADDR_ANY;
PIMADDR_ANY);
up->rpf.source_nexthop.mrib_metric_preference = up->rpf.source_nexthop.mrib_metric_preference =
ZEBRA_CONNECT_DISTANCE_DEFAULT; ZEBRA_CONNECT_DISTANCE_DEFAULT;
up->rpf.source_nexthop.mrib_route_metric = 0; up->rpf.source_nexthop.mrib_route_metric = 0;
@ -899,8 +898,7 @@ static struct pim_upstream *pim_upstream_new(struct pim_instance *pim,
up->sptbit = PIM_UPSTREAM_SPTBIT_FALSE; up->sptbit = PIM_UPSTREAM_SPTBIT_FALSE;
up->rpf.source_nexthop.interface = NULL; up->rpf.source_nexthop.interface = NULL;
pim_addr_to_prefix(&up->rpf.source_nexthop.mrib_nexthop_addr, up->rpf.source_nexthop.mrib_nexthop_addr = PIMADDR_ANY;
PIMADDR_ANY);
up->rpf.source_nexthop.mrib_metric_preference = up->rpf.source_nexthop.mrib_metric_preference =
router->infinite_assert_metric.metric_preference; router->infinite_assert_metric.metric_preference;
up->rpf.source_nexthop.mrib_route_metric = up->rpf.source_nexthop.mrib_route_metric =

105
pimd/pim_zlookup.c
View File

@ -156,7 +156,7 @@ void zclient_lookup_new(void)
static int zclient_read_nexthop(struct pim_instance *pim, static int zclient_read_nexthop(struct pim_instance *pim,
struct zclient *zlookup, struct zclient *zlookup,
struct pim_zlookup_nexthop nexthop_tab[], struct pim_zlookup_nexthop nexthop_tab[],
const int tab_size, struct in_addr addr) const int tab_size, pim_addr addr)
{ {
int num_ifindex = 0; int num_ifindex = 0;
struct stream *s; struct stream *s;
@ -165,19 +165,15 @@ static int zclient_read_nexthop(struct pim_instance *pim,
uint8_t version; uint8_t version;
vrf_id_t vrf_id; vrf_id_t vrf_id;
uint16_t command = 0; uint16_t command = 0;
struct in_addr raddr; pim_addr raddr;
uint8_t distance; uint8_t distance;
uint32_t metric; uint32_t metric;
int nexthop_num; int nexthop_num;
int i, err; int i, err;
if (PIM_DEBUG_PIM_NHT_DETAIL) { if (PIM_DEBUG_PIM_NHT_DETAIL)
char addr_str[INET_ADDRSTRLEN]; zlog_debug("%s: addr=%pPAs(%s)", __func__, &addr,
pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
zlog_debug("%s: addr=%s(%s)", __func__, addr_str,
pim->vrf->name); pim->vrf->name);
}
s = zlookup->ibuf; s = zlookup->ibuf;
@ -201,17 +197,15 @@ static int zclient_read_nexthop(struct pim_instance *pim,
} }
} }
#if PIM_IPV == 4
raddr.s_addr = stream_get_ipv4(s); raddr.s_addr = stream_get_ipv4(s);
#else
if (raddr.s_addr != addr.s_addr) { stream_get(&raddr, s, sizeof(struct in6_addr));
char addr_str[INET_ADDRSTRLEN]; #endif
char raddr_str[INET_ADDRSTRLEN]; if (pim_addr_cmp(raddr, addr))
pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str)); zlog_warn("%s: address mismatch: addr=%pPAs(%s) raddr=%pPAs",
pim_inet4_dump("<raddr?>", raddr, raddr_str, sizeof(raddr_str)); __func__, &addr, pim->vrf->name, &raddr);
zlog_warn("%s: address mismatch: addr=%s(%s) raddr=%s", /* warning only */
__func__, addr_str, pim->vrf->name, raddr_str);
/* warning only */
}
distance = stream_getc(s); distance = stream_getc(s);
metric = stream_getl(s); metric = stream_getl(s);
@ -233,12 +227,9 @@ static int zclient_read_nexthop(struct pim_instance *pim,
nexthop_vrf_id = stream_getl(s); nexthop_vrf_id = stream_getl(s);
nexthop_type = stream_getc(s); nexthop_type = stream_getc(s);
if (num_ifindex >= tab_size) { if (num_ifindex >= tab_size) {
char addr_str[INET_ADDRSTRLEN];
pim_inet4_dump("<addr?>", addr, addr_str,
sizeof(addr_str));
zlog_warn( zlog_warn(
"%s: found too many nexthop ifindexes (%d > %d) for address %s(%s)", "%s: found too many nexthop ifindexes (%d > %d) for address %pPAs(%s)",
__func__, (num_ifindex + 1), tab_size, addr_str, __func__, (num_ifindex + 1), tab_size, &addr,
pim->vrf->name); pim->vrf->name);
return num_ifindex; return num_ifindex;
} }
@ -254,32 +245,25 @@ static int zclient_read_nexthop(struct pim_instance *pim,
* allow us to work in cases where we are * allow us to work in cases where we are
* trying to find a route for this box. * trying to find a route for this box.
*/ */
nexthop_tab[num_ifindex].nexthop_addr.family = AF_INET; nexthop_tab[num_ifindex].nexthop_addr = addr;
nexthop_tab[num_ifindex].nexthop_addr.prefixlen =
IPV4_MAX_BITLEN;
nexthop_tab[num_ifindex].nexthop_addr.u.prefix4 =
addr;
++num_ifindex; ++num_ifindex;
break; break;
case NEXTHOP_TYPE_IPV4_IFINDEX: case NEXTHOP_TYPE_IPV4_IFINDEX:
case NEXTHOP_TYPE_IPV4: case NEXTHOP_TYPE_IPV4:
nexthop_tab[num_ifindex].nexthop_addr.family = AF_INET; nexthop_tab[num_ifindex].nexthop_addr.s_addr =
nexthop_tab[num_ifindex].nexthop_addr.u.prefix4.s_addr =
stream_get_ipv4(s); stream_get_ipv4(s);
nexthop_tab[num_ifindex].ifindex = stream_getl(s); nexthop_tab[num_ifindex].ifindex = stream_getl(s);
++num_ifindex; ++num_ifindex;
break; break;
case NEXTHOP_TYPE_IPV6_IFINDEX: case NEXTHOP_TYPE_IPV6_IFINDEX:
nexthop_tab[num_ifindex].nexthop_addr.family = AF_INET6; stream_get(&nexthop_tab[num_ifindex].nexthop_addr, s,
stream_get(&nexthop_tab[num_ifindex] sizeof(struct in6_addr));
.nexthop_addr.u.prefix6,
s, sizeof(struct in6_addr));
nexthop_tab[num_ifindex].ifindex = stream_getl(s); nexthop_tab[num_ifindex].ifindex = stream_getl(s);
p.family = AF_INET6; p.family = AF_INET6;
p.prefixlen = IPV6_MAX_BITLEN; p.prefixlen = IPV6_MAX_BITLEN;
memcpy(&p.u.prefix6, memcpy(&p.u.prefix6,
&nexthop_tab[num_ifindex].nexthop_addr.u.prefix6, &nexthop_tab[num_ifindex].nexthop_addr,
sizeof(struct in6_addr)); sizeof(struct in6_addr));
/* /*
@ -298,23 +282,17 @@ static int zclient_read_nexthop(struct pim_instance *pim,
nbr = pim_neighbor_find_if(ifp); nbr = pim_neighbor_find_if(ifp);
if (nbr) { if (nbr) {
nexthop_tab[num_ifindex].nexthop_addr.family = nexthop_tab[num_ifindex].nexthop_addr =
AF_INET; nbr->source_addr;
pim_addr_to_prefix(
&nexthop_tab[num_ifindex].nexthop_addr,
nbr->source_addr);
} }
++num_ifindex; ++num_ifindex;
break; break;
default: default:
/* do nothing */ /* do nothing */
{ {
char addr_str[INET_ADDRSTRLEN];
pim_inet4_dump("<addr?>", addr, addr_str,
sizeof(addr_str));
zlog_warn( zlog_warn(
"%s: found non-ifindex nexthop type=%d for address %s(%s)", "%s: found non-ifindex nexthop type=%d for address %pPAs(%s)",
__func__, nexthop_type, addr_str, __func__, nexthop_type, &addr,
pim->vrf->name); pim->vrf->name);
} }
break; break;
@ -326,17 +304,14 @@ static int zclient_read_nexthop(struct pim_instance *pim,
static int zclient_lookup_nexthop_once(struct pim_instance *pim, static int zclient_lookup_nexthop_once(struct pim_instance *pim,
struct pim_zlookup_nexthop nexthop_tab[], struct pim_zlookup_nexthop nexthop_tab[],
const int tab_size, struct in_addr addr) const int tab_size, pim_addr addr)
{ {
struct stream *s; struct stream *s;
int ret; int ret;
if (PIM_DEBUG_PIM_NHT_DETAIL) { if (PIM_DEBUG_PIM_NHT_DETAIL)
char addr_str[INET_ADDRSTRLEN]; zlog_debug("%s: addr=%pPAs(%s)", __func__, &addr,
pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
zlog_debug("%s: addr=%s(%s)", __func__, addr_str,
pim->vrf->name); pim->vrf->name);
}
/* Check socket. */ /* Check socket. */
if (zlookup->sock < 0) { if (zlookup->sock < 0) {
@ -358,7 +333,11 @@ static int zclient_lookup_nexthop_once(struct pim_instance *pim,
stream_reset(s); stream_reset(s);
zclient_create_header(s, ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB, zclient_create_header(s, ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB,
pim->vrf->vrf_id); pim->vrf->vrf_id);
#if PIM_IPV == 4
stream_put_in_addr(s, &addr); stream_put_in_addr(s, &addr);
#else
stream_write(s, (uint8_t *)&addr, 16);
#endif
stream_putw_at(s, 0, stream_get_endp(s)); stream_putw_at(s, 0, stream_get_endp(s));
ret = writen(zlookup->sock, s->data, stream_get_endp(s)); ret = writen(zlookup->sock, s->data, stream_get_endp(s));
@ -386,7 +365,7 @@ void zclient_lookup_read_pipe(struct thread *thread)
struct zclient *zlookup = THREAD_ARG(thread); struct zclient *zlookup = THREAD_ARG(thread);
struct pim_instance *pim = pim_get_pim_instance(VRF_DEFAULT); struct pim_instance *pim = pim_get_pim_instance(VRF_DEFAULT);
struct pim_zlookup_nexthop nexthop_tab[10]; struct pim_zlookup_nexthop nexthop_tab[10];
struct in_addr l = {.s_addr = INADDR_ANY}; pim_addr l = PIMADDR_ANY;
if (!pim) { if (!pim) {
if (PIM_DEBUG_PIM_NHT_DETAIL) if (PIM_DEBUG_PIM_NHT_DETAIL)
@ -413,7 +392,7 @@ int zclient_lookup_nexthop(struct pim_instance *pim,
for (lookup = 0; lookup < max_lookup; ++lookup) { for (lookup = 0; lookup < max_lookup; ++lookup) {
int num_ifindex; int num_ifindex;
int first_ifindex; int first_ifindex;
struct prefix nexthop_addr; pim_addr nexthop_addr;
num_ifindex = zclient_lookup_nexthop_once(pim, nexthop_tab, num_ifindex = zclient_lookup_nexthop_once(pim, nexthop_tab,
tab_size, addr); tab_size, addr);
@ -462,8 +441,7 @@ int zclient_lookup_nexthop(struct pim_instance *pim,
nexthop_tab[0].route_metric); nexthop_tab[0].route_metric);
/* use last address as nexthop address */ /* use last address as nexthop address */
pim_addr_to_prefix( nexthop_tab[0].nexthop_addr = addr;
&(nexthop_tab[0].nexthop_addr), addr);
/* report original route metric/distance */ /* report original route metric/distance */
nexthop_tab[0].route_metric = route_metric; nexthop_tab[0].route_metric = route_metric;
@ -474,23 +452,16 @@ int zclient_lookup_nexthop(struct pim_instance *pim,
return num_ifindex; return num_ifindex;
} }
if (PIM_DEBUG_PIM_NHT) { if (PIM_DEBUG_PIM_NHT)
char addr_str[INET_ADDRSTRLEN];
char nexthop_str[PREFIX_STRLEN];
pim_inet4_dump("<addr?>", addr, addr_str,
sizeof(addr_str));
pim_addr_dump("<nexthop?>", &nexthop_addr, nexthop_str,
sizeof(nexthop_str));
zlog_debug( zlog_debug(
"%s: lookup=%d/%d: zebra returned recursive nexthop %s for address %pPA(%s) dist=%d met=%d", "%s: lookup=%d/%d: zebra returned recursive nexthop %pPAs for address %pPA(%s) dist=%d met=%d",
__func__, lookup, max_lookup, nexthop_str, __func__, lookup, max_lookup, &nexthop_addr,
&addr, pim->vrf->name, &addr, pim->vrf->name,
nexthop_tab[0].protocol_distance, nexthop_tab[0].protocol_distance,
nexthop_tab[0].route_metric); nexthop_tab[0].route_metric);
}
addr = pim_addr_from_prefix(&(nexthop_addr)); /* use nexthop addr = nexthop_addr; /* use nexthop
addr for recursive lookup */ addr for recursive lookup */
} /* for (max_lookup) */ } /* for (max_lookup) */

2
pimd/pim_zlookup.h
View File

@ -28,7 +28,7 @@
struct pim_zlookup_nexthop { struct pim_zlookup_nexthop {
vrf_id_t vrf_id; vrf_id_t vrf_id;
struct prefix nexthop_addr; pim_addr nexthop_addr;
ifindex_t ifindex; ifindex_t ifindex;
uint32_t route_metric; uint32_t route_metric;
uint8_t protocol_distance; uint8_t protocol_distance;