pimd: switch pim_rpf.h to use 'struct prefix' for address

mrib_nexthop_addr and rpf_addr should be 'struct prefix'
so that we can safely handle unnumbered data from a nexthop
lookup in zebra

Signed-off-by: Donald Sharp <sharpd@cumulusnetworks.com>

diff --git a/pimd/pim_cmd.c b/pimd/pim_cmd.c
index ae9a3fd19e316cd696242e278c1ae1dd8bc1eb02..fd4da29291b8b82aa21187633ad3568d14764085 100644 (file)
--- a/pimd/pim_cmd.c
+++ b/pimd/pim_cmd.c
@@ -1076,8 +1076,8 @@ static void pim_show_upstream_rpf(struct vty *vty)
     
     pim_inet4_dump("<src?>", up->sg.src, src_str, sizeof(src_str));
     pim_inet4_dump("<grp?>", up->sg.grp, grp_str, sizeof(grp_str));
-    pim_inet4_dump("<nexthop?>", rpf->source_nexthop.mrib_nexthop_addr, rpf_nexthop_str, sizeof(rpf_nexthop_str));
-    pim_inet4_dump("<rpf?>", rpf->rpf_addr, rpf_addr_str, sizeof(rpf_addr_str));
+    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, sizeof(rpf_addr_str));
     
     rpf_ifname = rpf->source_nexthop.interface ? rpf->source_nexthop.interface->name : "<ifname?>";
     
@@ -1155,8 +1155,8 @@ static void pim_show_rpf(struct vty *vty)
     
     pim_inet4_dump("<src?>", up->sg.src, src_str, sizeof(src_str));
     pim_inet4_dump("<grp?>", up->sg.grp, grp_str, sizeof(grp_str));
-    pim_inet4_dump("<rpf?>", rpf->rpf_addr, rpf_addr_str, sizeof(rpf_addr_str));
-    pim_inet4_dump("<nexthop?>", rpf->source_nexthop.mrib_nexthop_addr, rib_nexthop_str, sizeof(rib_nexthop_str));
+    pim_addr_dump("<rpf?>", &rpf->rpf_addr, 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->source_nexthop.interface ? rpf->source_nexthop.interface->name : "<ifname?>";
     
@@ -2371,8 +2371,8 @@ DEFUN (show_ip_rib,
   vty_out(vty, "Address         NextHop         Interface Metric Preference%s",
          VTY_NEWLINE);
 
-  pim_inet4_dump("<nexthop?>", nexthop.mrib_nexthop_addr,
-                nexthop_addr_str, sizeof(nexthop_addr_str));
+  pim_addr_dump("<nexthop?>", &nexthop.mrib_nexthop_addr,
+               nexthop_addr_str, sizeof(nexthop_addr_str));
 
   vty_out(vty, "%-15s %-15s %-9s %6d %10d%s",
          addr_str,

diff --git a/pimd/pim_ifchannel.c b/pimd/pim_ifchannel.c
index e2b145a5b21bfaa1accb96b57590ae16922c936e..eaf7ab7096460487679c975fbdbb201117e8a5a7 100644 (file)
--- a/pimd/pim_ifchannel.c
+++ b/pimd/pim_ifchannel.c
@@ -512,7 +512,7 @@ static void check_recv_upstream(int is_join,
 
   /* Upstream (S,G) in Joined state */
 
-  if (PIM_INADDR_IS_ANY(up->rpf.rpf_addr)) {
+  if (pim_rpf_addr_is_inaddr_any(&up->rpf)) {
     /* RPF'(S,G) not found */
     zlog_warn("%s %s: RPF'%s not found",
              __FILE__, __PRETTY_FUNCTION__, 
@@ -521,11 +521,11 @@ static void check_recv_upstream(int is_join,
   }
 
   /* upstream directed to RPF'(S,G) ? */
-  if (upstream.s_addr != up->rpf.rpf_addr.s_addr) {
+  if (upstream.s_addr != up->rpf.rpf_addr.u.prefix4.s_addr) {
     char up_str[100];
     char rpf_str[100];
     pim_inet4_dump("<up?>", upstream, up_str, sizeof(up_str));
-    pim_inet4_dump("<rpf?>", up->rpf.rpf_addr, rpf_str, sizeof(rpf_str));
+    pim_addr_dump("<rpf?>", &up->rpf.rpf_addr, rpf_str, sizeof(rpf_str));
     zlog_warn("%s %s: (S,G)=%s upstream=%s not directed to RPF'(S,G)=%s on interface %s",
              __FILE__, __PRETTY_FUNCTION__, 
              pim_str_sg_dump (sg),
@@ -536,7 +536,7 @@ static void check_recv_upstream(int is_join,
 
   if (is_join) {
     /* Join(S,G) to RPF'(S,G) */
-    pim_upstream_join_suppress(up, up->rpf.rpf_addr, holdtime);
+    pim_upstream_join_suppress(up, up->rpf.rpf_addr.u.prefix4, holdtime);
     return;
   }
 
@@ -546,19 +546,19 @@ static void check_recv_upstream(int is_join,
     if (source_flags & PIM_WILDCARD_BIT_MASK) {
       /* Prune(*,G) to RPF'(S,G) */
       pim_upstream_join_timer_decrease_to_t_override("Prune(*,G)",
-                                                    up, up->rpf.rpf_addr);
+                                                    up, up->rpf.rpf_addr.u.prefix4);
       return;
     }
 
     /* Prune(S,G,rpt) to RPF'(S,G) */
     pim_upstream_join_timer_decrease_to_t_override("Prune(S,G,rpt)",
-                                                  up, up->rpf.rpf_addr);
+                                                  up, up->rpf.rpf_addr.u.prefix4);
     return;
   }
 
   /* Prune(S,G) to RPF'(S,G) */
   pim_upstream_join_timer_decrease_to_t_override("Prune(S,G)", up,
-                                                up->rpf.rpf_addr);
+                                                up->rpf.rpf_addr.u.prefix4);
 }
 
 static int nonlocal_upstream(int is_join,

diff --git a/pimd/pim_join.c b/pimd/pim_join.c
index 09924574203ff9e2af6f291f2555e339ac6dc6ad..1f722e7637cae78ea810c7443909480290e2fd22 100644 (file)
--- a/pimd/pim_join.c
+++ b/pimd/pim_join.c
@@ -90,7 +90,7 @@ static void recv_join(struct interface *ifp,
        * If the RP sent in the message is not
        * our RP for the group, drop the message
        */
-      if (sg.src.s_addr != rp->rpf_addr.s_addr)
+      if (sg.src.s_addr != rp->rpf_addr.u.prefix4.s_addr)
        return;
 
       sg.src.s_addr = INADDR_ANY;
@@ -162,7 +162,7 @@ static void recv_prune(struct interface *ifp,
       struct pim_rpf *rp = RP (sg.grp);
 
       // Ignoring Prune *,G's at the moment.
-      if (sg.src.s_addr != rp->rpf_addr.s_addr)
+      if (sg.src.s_addr != rp->rpf_addr.u.prefix4.s_addr)
        return;
 
       sg.src.s_addr = INADDR_ANY;

diff --git a/pimd/pim_mroute.c b/pimd/pim_mroute.c
index 14221d33030033a58cf233b008a64131f7b24177..f498bfcd0061fb035c547487168b336bb9f2c2a8 100644 (file)
--- a/pimd/pim_mroute.c
+++ b/pimd/pim_mroute.c
@@ -97,7 +97,7 @@ pim_mroute_msg_nocache (int fd, struct interface *ifp, const struct igmpmsg *msg
    * the Interface type is SSM we don't need to
    * do anything here
    */
-  if ((rpg->rpf_addr.s_addr == INADDR_NONE) ||
+  if ((pim_rpf_addr_is_inaddr_none (rpg)) ||
       (!pim_ifp) ||
       (!(PIM_I_am_DR(pim_ifp))) ||
       (pim_ifp->itype == PIM_INTERFACE_SSM))
@@ -183,7 +183,7 @@ pim_mroute_msg_wholepkt (int fd, struct interface *ifp, const char *buf)
 
   rpg = RP(sg.grp);
 
-  if ((rpg->rpf_addr.s_addr == INADDR_NONE) ||
+  if ((pim_rpf_addr_is_inaddr_none (rpg)) ||
       (!pim_ifp) ||
       (!(PIM_I_am_DR(pim_ifp))) ||
       (pim_ifp->itype == PIM_INTERFACE_SSM)) {

diff --git a/pimd/pim_msg.c b/pimd/pim_msg.c
index df7f7051d346f2b6ec32281511f417b32411bdeb..62e0bb1a3690959b6c7cf9b1be845a9bf8f7913e 100644 (file)
--- a/pimd/pim_msg.c
+++ b/pimd/pim_msg.c
@@ -181,7 +181,7 @@ pim_msg_join_prune_encode (uint8_t *buf, int buf_size, int is_join,
     {
       struct pim_rpf *rpf = pim_rp_g (group);
       bits = PIM_ENCODE_SPARSE_BIT | PIM_ENCODE_WC_BIT | PIM_ENCODE_RPT_BIT;
-      stosend = rpf->rpf_addr;
+      stosend = rpf->rpf_addr.u.prefix4;
     }
   else
     {

diff --git a/pimd/pim_register.c b/pimd/pim_register.c
index 46601c0dcbdeca37979c28c8b4e11c6c790df280..4131c5ef019ebd9cf973ba9c659a907ec9e4c23a 100644 (file)
--- a/pimd/pim_register.c
+++ b/pimd/pim_register.c
@@ -155,7 +155,7 @@ pim_register_send (const uint8_t *buf, int buf_size, struct in_addr src, struct
   if (PIM_DEBUG_PIM_REG)
     {
        char rp_str[100];
-       strcpy (rp_str, inet_ntoa (rpg->rpf_addr));
+       strcpy (rp_str, inet_ntoa (rpg->rpf_addr.u.prefix4));
        zlog_debug ("Sending %sRegister Packet to %s", null_register ? "NULL " : "", rp_str);
     }
 
@@ -177,7 +177,7 @@ pim_register_send (const uint8_t *buf, int buf_size, struct in_addr src, struct
 
   if (pim_msg_send(pinfo->pim_sock_fd,
                   src,
-                  rpg->rpf_addr,
+                  rpg->rpf_addr.u.prefix4,
                   buffer,
                   buf_size + PIM_MSG_REGISTER_LEN,
                   ifp->name)) {
@@ -296,7 +296,7 @@ pim_register_recv (struct interface *ifp,
   sg.src = ip_hdr->ip_src;
   sg.grp = ip_hdr->ip_dst;
 
-  if (I_am_RP (sg.grp) && (dest_addr.s_addr == ((RP (sg.grp))->rpf_addr.s_addr))) {
+  if (I_am_RP (sg.grp) && (dest_addr.s_addr == ((RP (sg.grp))->rpf_addr.u.prefix4.s_addr))) {
     sentRegisterStop = 0;
 
     if (*bits & PIM_REGISTER_BORDER_BIT) {

diff --git a/pimd/pim_rp.c b/pimd/pim_rp.c
index 81c4a65abe50bf538cb619d753502b2a858821c0..05b6623e8cef260d064934f000f796a01f6a0f4d 100644 (file)
--- a/pimd/pim_rp.c
+++ b/pimd/pim_rp.c
@@ -91,7 +91,8 @@ pim_rp_init (void)
     return;
 
   str2prefix ("224.0.0.0/4", &rp_info->group);
-  rp_info->rp.rpf_addr.s_addr = INADDR_NONE;
+  rp_info->rp.rpf_addr.family = AF_INET;
+  rp_info->rp.rpf_addr.u.prefix4.s_addr = INADDR_NONE;
   tail = rp_info;
 
   listnode_add (qpim_rp_list, rp_info);
@@ -112,7 +113,7 @@ pim_rp_find_exact (struct in_addr rp, struct prefix *group)
 
   for (ALL_LIST_ELEMENTS_RO (qpim_rp_list, node, rp_info))
     {
-      if (rp.s_addr == rp_info->rp.rpf_addr.s_addr &&
+      if (rp.s_addr == rp_info->rp.rpf_addr.u.prefix4.s_addr &&
          prefix_same (&rp_info->group, group))
        return rp_info;
     }
@@ -128,7 +129,7 @@ pim_rp_find_match (struct in_addr rp, struct prefix *group)
 
   for (ALL_LIST_ELEMENTS_RO (qpim_rp_list, node, rp_info))
     {
-      if (rp.s_addr == rp_info->rp.rpf_addr.s_addr &&
+      if (rp.s_addr == rp_info->rp.rpf_addr.u.prefix4.s_addr &&
           prefix_match (&rp_info->group, group))
        return rp_info;
     }
@@ -164,7 +165,7 @@ pim_rp_check_interfaces (struct rp_info *rp_info)
       if (!pim_ifp)
         continue;
 
-      if (pim_ifp->primary_address.s_addr == rp_info->rp.rpf_addr.s_addr)
+      if (pim_ifp->primary_address.s_addr == rp_info->rp.rpf_addr.u.prefix4.s_addr)
        rp_info->i_am_rp = 1;
     }
 }
@@ -192,7 +193,7 @@ pim_rp_new (const char *rp, const char *group_range)
   if (!result)
     return -1;
 
-  result = inet_pton (AF_INET, rp, &rp_info->rp.rpf_addr.s_addr);
+  result = inet_pton (rp_info->rp.rpf_addr.family, rp, &rp_info->rp.rpf_addr.u.prefix);
   if (result <= 0)
     return -1;
 
@@ -200,7 +201,7 @@ pim_rp_new (const char *rp, const char *group_range)
    * Take over the 224.0.0.0/4 group if the rp is INADDR_NONE
    */
   if (prefix_same (&rp_all->group, &rp_info->group) &&
-      rp_all->rp.rpf_addr.s_addr == INADDR_NONE)
+      pim_rpf_addr_is_inaddr_none (&rp_all->rp))
     {
       rp_all->rp.rpf_addr = rp_info->rp.rpf_addr;
       XFREE (MTYPE_PIM_RP, rp_info);
@@ -210,13 +211,13 @@ pim_rp_new (const char *rp, const char *group_range)
       return 0;
     }
 
-  if (pim_rp_find_exact (rp_info->rp.rpf_addr, &rp_info->group))
+  if (pim_rp_find_exact (rp_info->rp.rpf_addr.u.prefix4, &rp_info->group))
     {
       XFREE (MTYPE_PIM_RP, rp_info);
       return 0;
     }
 
-  if (pim_rp_find_match (rp_info->rp.rpf_addr, &rp_info->group))
+  if (pim_rp_find_match (rp_info->rp.rpf_addr.u.prefix4, &rp_info->group))
     {
       if (prefix_same (&group_all, &rp_info->group))
         {
@@ -267,7 +268,8 @@ pim_rp_del (const char *rp, const char *group_range)
 
   if (rp_all == rp_info)
     {
-      rp_all->rp.rpf_addr.s_addr = INADDR_NONE;
+      rp_all->rp.rpf_addr.family = AF_INET;
+      rp_all->rp.rpf_addr.u.prefix4.s_addr = INADDR_NONE;
       rp_all->i_am_rp = 0;
       return 0;
     }
@@ -285,7 +287,7 @@ pim_rp_setup (void)
 
   for (ALL_LIST_ELEMENTS_RO (qpim_rp_list, node, rp_info))
     {
-      if (pim_nexthop_lookup (&rp_info->rp.source_nexthop, rp_info->rp.rpf_addr) != 0)
+      if (pim_nexthop_lookup (&rp_info->rp.source_nexthop, rp_info->rp.rpf_addr.u.prefix4) != 0)
         {
           zlog_err ("Unable to lookup nexthop for rp specified");
           ret++;
@@ -316,20 +318,20 @@ pim_rp_check_rp (struct in_addr old, struct in_addr new)
         char sold[100];
         char snew[100];
         char rp[100];
-        pim_inet4_dump("<rp?>", rp_info->rp.rpf_addr, rp, sizeof(rp));
+        pim_addr_dump("<rp?>", &rp_info->rp.rpf_addr, rp, sizeof(rp));
         pim_inet4_dump("<old?>", old, sold, sizeof(sold));
         pim_inet4_dump("<new?>", new, snew, sizeof(snew));
         zlog_debug("%s: %s for old %s new %s", __func__, rp, sold, snew );
       }
-      if (rp_info->rp.rpf_addr.s_addr == INADDR_NONE)
+      if (pim_rpf_addr_is_inaddr_none (&rp_info->rp))
         continue;
 
-      if (new.s_addr == rp_info->rp.rpf_addr.s_addr)
+      if (new.s_addr == rp_info->rp.rpf_addr.u.prefix4.s_addr)
         {
          rp_info->i_am_rp = 1;
         }
 
-      if (old.s_addr == rp_info->rp.rpf_addr.s_addr)
+      if (old.s_addr == rp_info->rp.rpf_addr.u.prefix4.s_addr)
         {
           rp_info->i_am_rp = 0;
         }
@@ -381,7 +383,7 @@ pim_rp_g (struct in_addr group)
 
   if (rp_info)
     {
-      pim_nexthop_lookup(&rp_info->rp.source_nexthop, rp_info->rp.rpf_addr);
+      pim_nexthop_lookup(&rp_info->rp.source_nexthop, rp_info->rp.rpf_addr.u.prefix4);
       return (&rp_info->rp);
     }
 
@@ -410,14 +412,14 @@ pim_rp_set_upstream_addr (struct in_addr *up, struct in_addr source, struct in_a
 
   rp_info = pim_rp_find_match_group (&g);
 
-  if ((rp_info->rp.rpf_addr.s_addr == INADDR_NONE) && (source.s_addr == INADDR_ANY))
+  if ((pim_rpf_addr_is_inaddr_none (&rp_info->rp)) && (source.s_addr == INADDR_ANY))
     {
       if (PIM_DEBUG_PIM_TRACE)
        zlog_debug("%s: Received a (*,G) with no RP configured", __PRETTY_FUNCTION__);
       return 0;
     }
 
-  *up = (source.s_addr == INADDR_ANY) ? rp_info->rp.rpf_addr : source;
+  *up = (source.s_addr == INADDR_ANY) ? rp_info->rp.rpf_addr.u.prefix4 : source;
 
   return 1;
 }
@@ -432,10 +434,10 @@ pim_rp_config_write (struct vty *vty)
 
   for (ALL_LIST_ELEMENTS_RO (qpim_rp_list, node, rp_info))
     {
-      if (rp_info->rp.rpf_addr.s_addr == INADDR_NONE)
+      if (pim_rpf_addr_is_inaddr_none (&rp_info->rp))
         continue;
 
-      if (rp_info->rp.rpf_addr.s_addr != INADDR_NONE)
+      if (!pim_rpf_addr_is_inaddr_none (&rp_info->rp))
         {
          char buf[32];
           vty_out(vty, "ip pim rp %s %s%s", inet_ntop(AF_INET, &rp_info->rp.rpf_addr, buffer, 32),
@@ -467,7 +469,7 @@ pim_rp_check_is_my_ip_address (struct in_addr group, struct in_addr dest_addr)
    */
   if (I_am_RP(group))
     {
-     if (dest_addr.s_addr == rp_info->rp.rpf_addr.s_addr)
+     if (dest_addr.s_addr == rp_info->rp.rpf_addr.u.prefix4.s_addr)
        return 1;
     }
 
@@ -486,11 +488,11 @@ pim_rp_show_information (struct vty *vty)
   vty_out (vty, "RP Addr           Group   Oif    I_am_RP%s", VTY_NEWLINE);
   for (ALL_LIST_ELEMENTS_RO (qpim_rp_list, node, rp_info))
     {
-      if (rp_info->rp.rpf_addr.s_addr != INADDR_NONE)
+      if (!pim_rpf_addr_is_inaddr_none (&rp_info->rp))
         {
           char buf[48];
           vty_out (vty, "%-10s  %-10s  %-10s%-10d%s",
-          inet_ntoa (rp_info->rp.rpf_addr),
+          inet_ntoa (rp_info->rp.rpf_addr.u.prefix4),
                     prefix2str(&rp_info->group, buf, 48),
                     rp_info->rp.source_nexthop.interface->name,
                     rp_info->i_am_rp, VTY_NEWLINE);

diff --git a/pimd/pim_rpf.c b/pimd/pim_rpf.c
index 928629b0cf18a09b66f0fa4dcd6fd52755279895..662d4aaf520896e4254dd86af5e54b824cb3302a 100644 (file)
--- a/pimd/pim_rpf.c
+++ b/pimd/pim_rpf.c
@@ -102,10 +102,10 @@ int pim_nexthop_lookup(struct pim_nexthop *nexthop, struct in_addr addr)
   }
 
   /* update nextop data */
-  nexthop->interface              = ifp;
-  nexthop->mrib_nexthop_addr      = nexthop_tab[0].nexthop_addr.u.prefix4;
-  nexthop->mrib_metric_preference = nexthop_tab[0].protocol_distance;
-  nexthop->mrib_route_metric      = nexthop_tab[0].route_metric;
+  nexthop->interface                = ifp;
+  nexthop->mrib_nexthop_addr        = nexthop_tab[0].nexthop_addr;
+  nexthop->mrib_metric_preference   = nexthop_tab[0].protocol_distance;
+  nexthop->mrib_route_metric        = nexthop_tab[0].route_metric;
 
   return 0;
 }
@@ -113,18 +113,15 @@ int pim_nexthop_lookup(struct pim_nexthop *nexthop, struct in_addr addr)
 static int nexthop_mismatch(const struct pim_nexthop *nh1,
                            const struct pim_nexthop *nh2)
 {
-  return (nh1->interface != nh2->interface) 
-    ||
-    (nh1->mrib_nexthop_addr.s_addr != nh2->mrib_nexthop_addr.s_addr)
-    ||
-    (nh1->mrib_metric_preference != nh2->mrib_metric_preference)
-    ||
+  return (nh1->interface != nh2->interface)                          ||
+    (nh1->mrib_nexthop_addr.u.prefix4.s_addr != nh2->mrib_nexthop_addr.u.prefix4.s_addr) ||
+    (nh1->mrib_metric_preference != nh2->mrib_metric_preference)     ||
     (nh1->mrib_route_metric != nh2->mrib_route_metric);
 }
 
 enum pim_rpf_result pim_rpf_update(struct pim_upstream *up, struct in_addr *old_rpf_addr)
 {
-  struct in_addr      save_rpf_addr;
+  struct prefix       save_rpf_addr;
   struct pim_nexthop  save_nexthop;
   struct pim_rpf     *rpf = &up->rpf;
 
@@ -135,8 +132,9 @@ enum pim_rpf_result pim_rpf_update(struct pim_upstream *up, struct in_addr *old_
     return PIM_RPF_FAILURE;
   }
 
-  rpf->rpf_addr = pim_rpf_find_rpf_addr(up);
-  if (PIM_INADDR_IS_ANY(rpf->rpf_addr) && PIM_DEBUG_ZEBRA) {
+  rpf->rpf_addr.family = AF_INET;
+  rpf->rpf_addr.u.prefix4 = pim_rpf_find_rpf_addr(up);
+  if (pim_rpf_addr_is_inaddr_any(rpf) && PIM_DEBUG_ZEBRA) {
     /* RPF'(S,G) not found */
     zlog_debug("%s %s: RPF'%s not found: won't send join upstream",
               __FILE__, __PRETTY_FUNCTION__,
@@ -149,7 +147,7 @@ enum pim_rpf_result pim_rpf_update(struct pim_upstream *up, struct in_addr *old_
 
     if (PIM_DEBUG_ZEBRA) {
       char nhaddr_str[100];
-      pim_inet4_dump("<addr?>", rpf->source_nexthop.mrib_nexthop_addr, nhaddr_str, sizeof(nhaddr_str));
+      pim_addr_dump("<addr?>", &rpf->source_nexthop.mrib_nexthop_addr, nhaddr_str, sizeof(nhaddr_str));
       zlog_debug("%s %s: (S,G)=%s source nexthop now is: interface=%s address=%s pref=%d metric=%d",
                 __FILE__, __PRETTY_FUNCTION__,
                 pim_str_sg_dump (&up->sg),
@@ -180,11 +178,11 @@ enum pim_rpf_result pim_rpf_update(struct pim_upstream *up, struct in_addr *old_
   }
 
   /* detect change in RPF'(S,G) */
-  if (save_rpf_addr.s_addr != rpf->rpf_addr.s_addr) {
+  if (save_rpf_addr.u.prefix4.s_addr != rpf->rpf_addr.u.prefix4.s_addr) {
 
     /* return old rpf to caller ? */
     if (old_rpf_addr)
-      *old_rpf_addr = save_rpf_addr;
+      *old_rpf_addr = save_rpf_addr.u.prefix4;
 
     return PIM_RPF_CHANGED;
   }
@@ -233,7 +231,7 @@ static struct in_addr pim_rpf_find_rpf_addr(struct pim_upstream *up)
   /* return NBR( RPF_interface(S), MRIB.next_hop( S ) ) */
 
   neigh = pim_if_find_neighbor(up->rpf.source_nexthop.interface,
-                              up->rpf.source_nexthop.mrib_nexthop_addr);
+                              up->rpf.source_nexthop.mrib_nexthop_addr.u.prefix4);
   if (neigh)
     rpf_addr = neigh->source_addr;
   else
@@ -241,3 +239,43 @@ static struct in_addr pim_rpf_find_rpf_addr(struct pim_upstream *up)
 
   return rpf_addr;
 }
+
+int
+pim_rpf_addr_is_inaddr_none (struct pim_rpf *rpf)
+{
+  switch (rpf->rpf_addr.family)
+    {
+    case AFI_IP:
+      return rpf->rpf_addr.u.prefix4.s_addr == INADDR_NONE;
+      break;
+    case AFI_IP6:
+      zlog_warn ("%s: v6 Unimplmeneted", __PRETTY_FUNCTION__);
+      return 1;
+      break;
+    default:
+      return 0;
+      break;
+    }
+
+  return 0;
+}
+
+int
+pim_rpf_addr_is_inaddr_any (struct pim_rpf *rpf)
+{
+  switch (rpf->rpf_addr.family)
+    {
+    case AFI_IP:
+      return rpf->rpf_addr.u.prefix4.s_addr == INADDR_ANY;
+      break;
+    case AFI_IP6:
+      zlog_warn ("%s: v6 Unimplmented", __PRETTY_FUNCTION__);
+      return 1;
+      break;
+    default:
+      return 0;
+      break;
+    }
+
+  return 0;
+}

diff --git a/pimd/pim_rpf.h b/pimd/pim_rpf.h
index 9e183a0895a75fbd8001f7e06b44797f0ace1693..fddc74a725e6cc1d7c43645c425f7bcac1eacc5f 100644 (file)
--- a/pimd/pim_rpf.h
+++ b/pimd/pim_rpf.h
@@ -41,14 +41,14 @@
 */
 struct pim_nexthop {
   struct interface *interface;              /* RPF_interface(S) */
-  struct in_addr    mrib_nexthop_addr;      /* MRIB.next_hop(S) */
+  struct prefix     mrib_nexthop_addr;      /* MRIB.next_hop(S) */
   uint32_t          mrib_metric_preference; /* MRIB.pref(S) */
   uint32_t          mrib_route_metric;      /* MRIB.metric(S) */
 };
 
 struct pim_rpf {
   struct pim_nexthop source_nexthop;
-  struct in_addr     rpf_addr;               /* RPF'(S,G) */
+  struct prefix      rpf_addr;               /* RPF'(S,G) */
 };
 
 enum pim_rpf_result {
@@ -62,4 +62,6 @@ struct pim_upstream;
 int pim_nexthop_lookup(struct pim_nexthop *nexthop, struct in_addr addr);
 enum pim_rpf_result pim_rpf_update(struct pim_upstream *up, struct in_addr *old_rpf_addr);
 
+int pim_rpf_addr_is_inaddr_none (struct pim_rpf *rpf);
+int pim_rpf_addr_is_inaddr_any (struct pim_rpf *rpf);
 #endif /* PIM_RPF_H */

diff --git a/pimd/pim_upstream.c b/pimd/pim_upstream.c
index 9a11eefd60bf0d5f1bbe25666a14cb8bad397459..13e7c55c55c0c5c8e3d31d1cf1502e4c7635ce71 100644 (file)
--- a/pimd/pim_upstream.c
+++ b/pimd/pim_upstream.c
@@ -174,11 +174,11 @@ pim_upstream_send_join (struct pim_upstream *up)
 {
   if (PIM_DEBUG_PIM_TRACE) {
     char rpf_str[100];
-    pim_inet4_dump("<rpf?>", up->rpf.rpf_addr, rpf_str, sizeof(rpf_str));
+    pim_addr_dump("<rpf?>", &up->rpf.rpf_addr, rpf_str, sizeof(rpf_str));
     zlog_debug ("%s: RPF'%s=%s(%s) for Interface %s", __PRETTY_FUNCTION__,
                pim_str_sg_dump (&up->sg), rpf_str, pim_upstream_state2str (up->join_state),
                up->rpf.source_nexthop.interface->name);
-    if (PIM_INADDR_IS_ANY(up->rpf.rpf_addr)) {
+    if (pim_rpf_addr_is_inaddr_any(&up->rpf)) {
       zlog_debug("%s: can't send join upstream: RPF'%s=%s",
                 __PRETTY_FUNCTION__,
                 pim_str_sg_dump (&up->sg), rpf_str);
@@ -188,7 +188,7 @@ pim_upstream_send_join (struct pim_upstream *up)
 
   /* send Join(S,G) to the current upstream neighbor */
   pim_joinprune_send(up->rpf.source_nexthop.interface,
-                    up->rpf.rpf_addr,
+                    up->rpf.rpf_addr.u.prefix4,
                     &up->sg,
                     1 /* join */);
 }
@@ -457,7 +457,7 @@ pim_upstream_switch(struct pim_upstream *up,
   else {
     forward_off(up);
     pim_joinprune_send(up->rpf.source_nexthop.interface,
-                      up->rpf.rpf_addr,
+                      up->rpf.rpf_addr.u.prefix4,
                       &up->sg,
                       0 /* prune */);
     if (up->t_join_timer)
@@ -501,10 +501,12 @@ static struct pim_upstream *pim_upstream_new(struct prefix_sg *sg,
   up->sptbit                     = PIM_UPSTREAM_SPTBIT_FALSE;
 
   up->rpf.source_nexthop.interface                = NULL;
-  up->rpf.source_nexthop.mrib_nexthop_addr.s_addr = PIM_NET_INADDR_ANY;
+  up->rpf.source_nexthop.mrib_nexthop_addr.family = AF_INET;
+  up->rpf.source_nexthop.mrib_nexthop_addr.u.prefix4.s_addr = PIM_NET_INADDR_ANY;
   up->rpf.source_nexthop.mrib_metric_preference   = qpim_infinite_assert_metric.metric_preference;
   up->rpf.source_nexthop.mrib_route_metric        = qpim_infinite_assert_metric.route_metric;
-  up->rpf.rpf_addr.s_addr                         = PIM_NET_INADDR_ANY;
+  up->rpf.rpf_addr.family                         = AF_INET;
+  up->rpf.rpf_addr.u.prefix4.s_addr               = PIM_NET_INADDR_ANY;
 
   rpf_result = pim_rpf_update(up, NULL);
   if (rpf_result == PIM_RPF_FAILURE) {
@@ -703,7 +705,7 @@ void pim_upstream_rpf_genid_changed(struct in_addr neigh_addr)
       char neigh_str[100];
       char rpf_addr_str[100];
       pim_inet4_dump("<neigh?>", neigh_addr, neigh_str, sizeof(neigh_str));
-      pim_inet4_dump("<rpf?>", up->rpf.rpf_addr, rpf_addr_str, sizeof(rpf_addr_str));
+      pim_addr_dump("<rpf?>", &up->rpf.rpf_addr, rpf_addr_str, sizeof(rpf_addr_str));
       zlog_debug("%s: matching neigh=%s against upstream (S,G)=%s joined=%d rpf_addr=%s",
                 __PRETTY_FUNCTION__,
                 neigh_str, pim_str_sg_dump (&up->sg),
@@ -716,7 +718,7 @@ void pim_upstream_rpf_genid_changed(struct in_addr neigh_addr)
       continue;
 
     /* match RPF'(S,G)=neigh_addr */
-    if (up->rpf.rpf_addr.s_addr != neigh_addr.s_addr)
+    if (up->rpf.rpf_addr.u.prefix4.s_addr != neigh_addr.s_addr)
       continue;
 
     pim_upstream_join_timer_decrease_to_t_override("RPF'(S,G) GenID change",
@@ -878,7 +880,7 @@ pim_upstream_keep_alive_timer (struct thread *t)
       THREAD_OFF (up->t_ka_timer);
       THREAD_OFF (up->t_rs_timer);
       THREAD_OFF (up->t_join_timer);
-      pim_joinprune_send (up->rpf.source_nexthop.interface, up->rpf.rpf_addr,
+      pim_joinprune_send (up->rpf.source_nexthop.interface, up->rpf.rpf_addr.u.prefix4,
                           &up->sg, 0);
       pim_upstream_del (up);
     }
@@ -1121,7 +1123,7 @@ pim_upstream_find_new_rpf (void)
   */
   for (ALL_LIST_ELEMENTS(qpim_upstream_list, up_node, up_nextnode, up))
     {
-      if (PIM_INADDR_IS_ANY(up->rpf.rpf_addr))
+      if (pim_rpf_addr_is_inaddr_any(&up->rpf))
        {
          if (PIM_DEBUG_PIM_TRACE)
            zlog_debug ("Upstream %s without a path to send join, checking",

diff --git a/pimd/pim_zebra.c b/pimd/pim_zebra.c
index 8a466e4035cf3c007ad612edb519c2fd88c45f56..68df086a1bde901104dee592c7439e4402ee4ed7 100644 (file)
--- a/pimd/pim_zebra.c
+++ b/pimd/pim_zebra.c
@@ -371,7 +371,7 @@ static void scan_upstream_rpf_cache()
        
        /* send Join(S,G) to the current upstream neighbor */
        pim_joinprune_send(up->rpf.source_nexthop.interface,
-                          up->rpf.rpf_addr,
+                          up->rpf.rpf_addr.u.prefix4,
                           &up->sg,
                           1 /* join */);