]> git.proxmox.com Git - mirror_frr.git/blob - pimd/pim_rp.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
tests: Test if `distance bgp (1-255) (1-255) (1-255)` works
[mirror_frr.git] / pimd / pim_rp.c
1 /*
2 * PIM for Quagga
3 * Copyright (C) 2015 Cumulus Networks, Inc.
4 * Donald Sharp
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20 #include <zebra.h>
21
22 #include "lib/json.h"
23 #include "log.h"
24 #include "network.h"
25 #include "if.h"
26 #include "linklist.h"
27 #include "prefix.h"
28 #include "memory.h"
29 #include "vty.h"
30 #include "vrf.h"
31 #include "plist.h"
32 #include "nexthop.h"
33 #include "table.h"
34 #include "lib_errors.h"
35
36 #include "pimd.h"
37 #include "pim_vty.h"
38 #include "pim_str.h"
39 #include "pim_iface.h"
40 #include "pim_rp.h"
41 #include "pim_str.h"
42 #include "pim_rpf.h"
43 #include "pim_sock.h"
44 #include "pim_memory.h"
45 #include "pim_iface.h"
46 #include "pim_msdp.h"
47 #include "pim_nht.h"
48 #include "pim_mroute.h"
49 #include "pim_oil.h"
50 #include "pim_zebra.h"
51
52 /* Cleanup pim->rpf_hash each node data */
53 void pim_rp_list_hash_clean(void *data)
54 {
55 struct pim_nexthop_cache *pnc = (struct pim_nexthop_cache *)data;
56
57 list_delete(&pnc->rp_list);
58
59 hash_clean(pnc->upstream_hash, NULL);
60 hash_free(pnc->upstream_hash);
61 pnc->upstream_hash = NULL;
62 if (pnc->nexthop)
63 nexthops_free(pnc->nexthop);
64
65 XFREE(MTYPE_PIM_NEXTHOP_CACHE, pnc);
66 }
67
68 static void pim_rp_info_free(struct rp_info *rp_info)
69 {
70 XFREE(MTYPE_PIM_FILTER_NAME, rp_info->plist);
71
72 XFREE(MTYPE_PIM_RP, rp_info);
73 }
74
75 int pim_rp_list_cmp(void *v1, void *v2)
76 {
77 struct rp_info *rp1 = (struct rp_info *)v1;
78 struct rp_info *rp2 = (struct rp_info *)v2;
79
80 /*
81 * Sort by RP IP address
82 */
83 if (rp1->rp.rpf_addr.u.prefix4.s_addr
84 < rp2->rp.rpf_addr.u.prefix4.s_addr)
85 return -1;
86
87 if (rp1->rp.rpf_addr.u.prefix4.s_addr
88 > rp2->rp.rpf_addr.u.prefix4.s_addr)
89 return 1;
90
91 /*
92 * Sort by group IP address
93 */
94 if (rp1->group.u.prefix4.s_addr < rp2->group.u.prefix4.s_addr)
95 return -1;
96
97 if (rp1->group.u.prefix4.s_addr > rp2->group.u.prefix4.s_addr)
98 return 1;
99
100 return 0;
101 }
102
103 void pim_rp_init(struct pim_instance *pim)
104 {
105 struct rp_info *rp_info;
106 struct route_node *rn;
107
108 pim->rp_list = list_new();
109 pim->rp_list->del = (void (*)(void *))pim_rp_info_free;
110 pim->rp_list->cmp = pim_rp_list_cmp;
111
112 pim->rp_table = route_table_init();
113
114 rp_info = XCALLOC(MTYPE_PIM_RP, sizeof(*rp_info));
115
116 if (!str2prefix("224.0.0.0/4", &rp_info->group)) {
117 flog_err(EC_LIB_DEVELOPMENT,
118 "Unable to convert 224.0.0.0/4 to prefix");
119 list_delete(&pim->rp_list);
120 route_table_finish(pim->rp_table);
121 XFREE(MTYPE_PIM_RP, rp_info);
122 return;
123 }
124 rp_info->group.family = AF_INET;
125 rp_info->rp.rpf_addr.family = AF_INET;
126 rp_info->rp.rpf_addr.prefixlen = IPV4_MAX_PREFIXLEN;
127 rp_info->rp.rpf_addr.u.prefix4.s_addr = INADDR_NONE;
128
129 listnode_add(pim->rp_list, rp_info);
130
131 rn = route_node_get(pim->rp_table, &rp_info->group);
132 rn->info = rp_info;
133 if (PIM_DEBUG_TRACE)
134 zlog_debug(
135 "Allocated: %p for rp_info: %p(224.0.0.0/4) Lock: %d",
136 rn, rp_info, rn->lock);
137 }
138
139 void pim_rp_free(struct pim_instance *pim)
140 {
141 if (pim->rp_list)
142 list_delete(&pim->rp_list);
143 }
144
145 /*
146 * Given an RP's prefix-list, return the RP's rp_info for that prefix-list
147 */
148 static struct rp_info *pim_rp_find_prefix_list(struct pim_instance *pim,
149 struct in_addr rp,
150 const char *plist)
151 {
152 struct listnode *node;
153 struct rp_info *rp_info;
154
155 for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
156 if (rp.s_addr == rp_info->rp.rpf_addr.u.prefix4.s_addr
157 && rp_info->plist && strcmp(rp_info->plist, plist) == 0) {
158 return rp_info;
159 }
160 }
161
162 return NULL;
163 }
164
165 /*
166 * Return true if plist is used by any rp_info
167 */
168 static int pim_rp_prefix_list_used(struct pim_instance *pim, const char *plist)
169 {
170 struct listnode *node;
171 struct rp_info *rp_info;
172
173 for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
174 if (rp_info->plist && strcmp(rp_info->plist, plist) == 0) {
175 return 1;
176 }
177 }
178
179 return 0;
180 }
181
182 /*
183 * Given an RP's address, return the RP's rp_info that is an exact match for
184 * 'group'
185 */
186 static struct rp_info *pim_rp_find_exact(struct pim_instance *pim,
187 struct in_addr rp,
188 const struct prefix *group)
189 {
190 struct listnode *node;
191 struct rp_info *rp_info;
192
193 for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
194 if (rp.s_addr == rp_info->rp.rpf_addr.u.prefix4.s_addr
195 && prefix_same(&rp_info->group, group))
196 return rp_info;
197 }
198
199 return NULL;
200 }
201
202 /*
203 * Given a group, return the rp_info for that group
204 */
205 struct rp_info *pim_rp_find_match_group(struct pim_instance *pim,
206 const struct prefix *group)
207 {
208 struct listnode *node;
209 struct rp_info *best = NULL;
210 struct rp_info *rp_info;
211 struct prefix_list *plist;
212 const struct prefix *p, *bp;
213 struct route_node *rn;
214
215 bp = NULL;
216 for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
217 if (rp_info->plist) {
218 plist = prefix_list_lookup(AFI_IP, rp_info->plist);
219
220 if (prefix_list_apply_which_prefix(plist, &p, group)
221 == PREFIX_DENY)
222 continue;
223
224 if (!best) {
225 best = rp_info;
226 bp = p;
227 continue;
228 }
229
230 if (bp && bp->prefixlen < p->prefixlen) {
231 best = rp_info;
232 bp = p;
233 }
234 }
235 }
236
237 rn = route_node_match(pim->rp_table, group);
238 if (!rn) {
239 flog_err(
240 EC_LIB_DEVELOPMENT,
241 "%s: BUG We should have found default group information\n",
242 __PRETTY_FUNCTION__);
243 return best;
244 }
245
246 rp_info = rn->info;
247 if (PIM_DEBUG_TRACE) {
248 char buf[PREFIX_STRLEN];
249
250 route_unlock_node(rn);
251 zlog_debug("Lookedup: %p for rp_info: %p(%s) Lock: %d", rn,
252 rp_info,
253 prefix2str(&rp_info->group, buf, sizeof(buf)),
254 rn->lock);
255 }
256
257 if (!best)
258 return rp_info;
259
260 if (rp_info->group.prefixlen < best->group.prefixlen)
261 best = rp_info;
262
263 return best;
264 }
265
266 /*
267 * When the user makes "ip pim rp" configuration changes or if they change the
268 * prefix-list(s) used by these statements we must tickle the upstream state
269 * for each group to make them re-lookup who their RP should be.
270 *
271 * This is a placeholder function for now.
272 */
273 static void pim_rp_refresh_group_to_rp_mapping(struct pim_instance *pim)
274 {
275 pim_msdp_i_am_rp_changed(pim);
276 }
277
278 void pim_rp_prefix_list_update(struct pim_instance *pim,
279 struct prefix_list *plist)
280 {
281 struct listnode *node;
282 struct rp_info *rp_info;
283 int refresh_needed = 0;
284
285 for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
286 if (rp_info->plist
287 && strcmp(rp_info->plist, prefix_list_name(plist)) == 0) {
288 refresh_needed = 1;
289 break;
290 }
291 }
292
293 if (refresh_needed)
294 pim_rp_refresh_group_to_rp_mapping(pim);
295 }
296
297 static int pim_rp_check_interface_addrs(struct rp_info *rp_info,
298 struct pim_interface *pim_ifp)
299 {
300 struct listnode *node;
301 struct pim_secondary_addr *sec_addr;
302
303 if (pim_ifp->primary_address.s_addr
304 == rp_info->rp.rpf_addr.u.prefix4.s_addr)
305 return 1;
306
307 if (!pim_ifp->sec_addr_list) {
308 return 0;
309 }
310
311 for (ALL_LIST_ELEMENTS_RO(pim_ifp->sec_addr_list, node, sec_addr)) {
312 if (prefix_same(&sec_addr->addr, &rp_info->rp.rpf_addr)) {
313 return 1;
314 }
315 }
316
317 return 0;
318 }
319
320 static void pim_rp_check_interfaces(struct pim_instance *pim,
321 struct rp_info *rp_info)
322 {
323 struct interface *ifp;
324
325 rp_info->i_am_rp = 0;
326 FOR_ALL_INTERFACES (pim->vrf, ifp) {
327 struct pim_interface *pim_ifp = ifp->info;
328
329 if (!pim_ifp)
330 continue;
331
332 if (pim_rp_check_interface_addrs(rp_info, pim_ifp)) {
333 rp_info->i_am_rp = 1;
334 }
335 }
336 }
337
338 void pim_upstream_update(struct pim_instance *pim, struct pim_upstream *up)
339 {
340 struct pim_rpf old_rpf;
341 enum pim_rpf_result rpf_result;
342 struct in_addr old_upstream_addr;
343 struct in_addr new_upstream_addr;
344 struct prefix nht_p;
345
346 old_upstream_addr = up->upstream_addr;
347 pim_rp_set_upstream_addr(pim, &new_upstream_addr, up->sg.src,
348 up->sg.grp);
349
350 if (PIM_DEBUG_TRACE)
351 zlog_debug("%s: pim upstream update for old upstream %s",
352 __PRETTY_FUNCTION__,
353 inet_ntoa(old_upstream_addr));
354
355 if (old_upstream_addr.s_addr == new_upstream_addr.s_addr)
356 return;
357
358 /* Lets consider a case, where a PIM upstream has a better RP as a
359 * result of a new RP configuration with more precise group range.
360 * This upstream has to be added to the upstream hash of new RP's
361 * NHT(pnc) and has to be removed from old RP's NHT upstream hash
362 */
363 if (old_upstream_addr.s_addr != INADDR_ANY) {
364 /* Deregister addr with Zebra NHT */
365 nht_p.family = AF_INET;
366 nht_p.prefixlen = IPV4_MAX_BITLEN;
367 nht_p.u.prefix4 = old_upstream_addr;
368 if (PIM_DEBUG_TRACE) {
369 char buf[PREFIX2STR_BUFFER];
370
371 prefix2str(&nht_p, buf, sizeof(buf));
372 zlog_debug("%s: Deregister upstream %s addr %s with Zebra NHT",
373 __PRETTY_FUNCTION__, up->sg_str, buf);
374 }
375 pim_delete_tracked_nexthop(pim, &nht_p, up, NULL);
376 }
377
378 /* Update the upstream address */
379 up->upstream_addr = new_upstream_addr;
380
381 old_rpf.source_nexthop.interface = up->rpf.source_nexthop.interface;
382
383 rpf_result = pim_rpf_update(pim, up, &old_rpf, 1);
384 if (rpf_result == PIM_RPF_FAILURE)
385 pim_mroute_del(up->channel_oil, __PRETTY_FUNCTION__);
386
387 /* update kernel multicast forwarding cache (MFC) */
388 if (up->rpf.source_nexthop.interface && up->channel_oil) {
389 ifindex_t ifindex = up->rpf.source_nexthop.interface->ifindex;
390 int vif_index = pim_if_find_vifindex_by_ifindex(pim, ifindex);
391 /* Pass Current selected NH vif index to mroute download */
392 if (vif_index)
393 pim_scan_individual_oil(up->channel_oil, vif_index);
394 else {
395 if (PIM_DEBUG_PIM_NHT)
396 zlog_debug(
397 "%s: NHT upstream %s channel_oil IIF %s vif_index is not valid",
398 __PRETTY_FUNCTION__, up->sg_str,
399 up->rpf.source_nexthop.interface->name);
400 }
401 }
402
403 if (rpf_result == PIM_RPF_CHANGED)
404 pim_zebra_upstream_rpf_changed(pim, up, &old_rpf);
405
406 pim_zebra_update_all_interfaces(pim);
407 }
408
409 int pim_rp_new(struct pim_instance *pim, const char *rp,
410 const char *group_range, const char *plist)
411 {
412 int result = 0;
413 struct rp_info *rp_info;
414 struct rp_info *rp_all;
415 struct prefix group_all;
416 struct listnode *node, *nnode;
417 struct rp_info *tmp_rp_info;
418 char buffer[BUFSIZ];
419 struct prefix nht_p;
420 struct prefix temp;
421 struct route_node *rn;
422 struct pim_upstream *up;
423 struct listnode *upnode;
424
425 rp_info = XCALLOC(MTYPE_PIM_RP, sizeof(*rp_info));
426
427 if (group_range == NULL)
428 result = str2prefix("224.0.0.0/4", &rp_info->group);
429 else {
430 result = str2prefix(group_range, &rp_info->group);
431 if (result) {
432 prefix_copy(&temp, &rp_info->group);
433 apply_mask(&temp);
434 if (!prefix_same(&rp_info->group, &temp)) {
435 XFREE(MTYPE_PIM_RP, rp_info);
436 return PIM_GROUP_BAD_ADDR_MASK_COMBO;
437 }
438 }
439 }
440
441 if (!result) {
442 XFREE(MTYPE_PIM_RP, rp_info);
443 return PIM_GROUP_BAD_ADDRESS;
444 }
445
446 rp_info->rp.rpf_addr.family = AF_INET;
447 rp_info->rp.rpf_addr.prefixlen = IPV4_MAX_PREFIXLEN;
448 result = inet_pton(rp_info->rp.rpf_addr.family, rp,
449 &rp_info->rp.rpf_addr.u.prefix4);
450
451 if (result <= 0) {
452 XFREE(MTYPE_PIM_RP, rp_info);
453 return PIM_RP_BAD_ADDRESS;
454 }
455
456 if (plist) {
457 /*
458 * Return if the prefix-list is already configured for this RP
459 */
460 if (pim_rp_find_prefix_list(pim, rp_info->rp.rpf_addr.u.prefix4,
461 plist)) {
462 XFREE(MTYPE_PIM_RP, rp_info);
463 return PIM_SUCCESS;
464 }
465
466 /*
467 * Barf if the prefix-list is already configured for an RP
468 */
469 if (pim_rp_prefix_list_used(pim, plist)) {
470 XFREE(MTYPE_PIM_RP, rp_info);
471 return PIM_RP_PFXLIST_IN_USE;
472 }
473
474 /*
475 * Free any existing rp_info entries for this RP
476 */
477 for (ALL_LIST_ELEMENTS(pim->rp_list, node, nnode,
478 tmp_rp_info)) {
479 if (rp_info->rp.rpf_addr.u.prefix4.s_addr
480 == tmp_rp_info->rp.rpf_addr.u.prefix4.s_addr) {
481 if (tmp_rp_info->plist)
482 pim_rp_del(pim, rp, NULL,
483 tmp_rp_info->plist);
484 else
485 pim_rp_del(
486 pim, rp,
487 prefix2str(&tmp_rp_info->group,
488 buffer, BUFSIZ),
489 NULL);
490 }
491 }
492
493 rp_info->plist = XSTRDUP(MTYPE_PIM_FILTER_NAME, plist);
494 } else {
495
496 if (!str2prefix("224.0.0.0/4", &group_all)) {
497 XFREE(MTYPE_PIM_RP, rp_info);
498 return PIM_GROUP_BAD_ADDRESS;
499 }
500 rp_all = pim_rp_find_match_group(pim, &group_all);
501
502 /*
503 * Barf if group is a non-multicast subnet
504 */
505 if (!prefix_match(&rp_all->group, &rp_info->group)) {
506 XFREE(MTYPE_PIM_RP, rp_info);
507 return PIM_GROUP_BAD_ADDRESS;
508 }
509
510 /*
511 * Remove any prefix-list rp_info entries for this RP
512 */
513 for (ALL_LIST_ELEMENTS(pim->rp_list, node, nnode,
514 tmp_rp_info)) {
515 if (tmp_rp_info->plist
516 && rp_info->rp.rpf_addr.u.prefix4.s_addr
517 == tmp_rp_info->rp.rpf_addr.u.prefix4
518 .s_addr) {
519 pim_rp_del(pim, rp, NULL, tmp_rp_info->plist);
520 }
521 }
522
523 /*
524 * Take over the 224.0.0.0/4 group if the rp is INADDR_NONE
525 */
526 if (prefix_same(&rp_all->group, &rp_info->group)
527 && pim_rpf_addr_is_inaddr_none(&rp_all->rp)) {
528 rp_all->rp.rpf_addr = rp_info->rp.rpf_addr;
529 XFREE(MTYPE_PIM_RP, rp_info);
530
531 /* Register addr with Zebra NHT */
532 nht_p.family = AF_INET;
533 nht_p.prefixlen = IPV4_MAX_BITLEN;
534 nht_p.u.prefix4 =
535 rp_all->rp.rpf_addr.u.prefix4; // RP address
536 if (PIM_DEBUG_PIM_NHT_RP) {
537 char buf[PREFIX2STR_BUFFER];
538 char buf1[PREFIX2STR_BUFFER];
539 prefix2str(&nht_p, buf, sizeof(buf));
540 prefix2str(&rp_all->group, buf1, sizeof(buf1));
541 zlog_debug(
542 "%s: NHT Register rp_all addr %s grp %s ",
543 __PRETTY_FUNCTION__, buf, buf1);
544 }
545
546 for (ALL_LIST_ELEMENTS_RO(pim->upstream_list, upnode,
547 up)) {
548 /* Find (*, G) upstream whose RP is not
549 * configured yet
550 */
551 if ((up->upstream_addr.s_addr == INADDR_ANY)
552 && (up->sg.src.s_addr == INADDR_ANY)) {
553 struct prefix grp;
554 struct rp_info *trp_info;
555
556 grp.family = AF_INET;
557 grp.prefixlen = IPV4_MAX_BITLEN;
558 grp.u.prefix4 = up->sg.grp;
559 trp_info = pim_rp_find_match_group(pim,
560 &grp);
561 if (trp_info == rp_all)
562 pim_upstream_update(pim, up);
563 }
564 }
565
566 pim_rp_check_interfaces(pim, rp_all);
567 pim_rp_refresh_group_to_rp_mapping(pim);
568
569 pim_find_or_track_nexthop(pim, &nht_p, NULL, rp_all,
570 NULL);
571 if (!pim_ecmp_nexthop_lookup(pim,
572 &rp_all->rp.source_nexthop,
573 &nht_p, &rp_all->group, 1))
574 return PIM_RP_NO_PATH;
575
576 return PIM_SUCCESS;
577 }
578
579 /*
580 * Return if the group is already configured for this RP
581 */
582 if (pim_rp_find_exact(pim, rp_info->rp.rpf_addr.u.prefix4,
583 &rp_info->group)) {
584 XFREE(MTYPE_PIM_RP, rp_info);
585 return PIM_SUCCESS;
586 }
587
588 /*
589 * Barf if this group is already covered by some other RP
590 */
591 tmp_rp_info = pim_rp_find_match_group(pim, &rp_info->group);
592
593 if (tmp_rp_info) {
594 if (tmp_rp_info->plist) {
595 XFREE(MTYPE_PIM_RP, rp_info);
596 return PIM_GROUP_PFXLIST_OVERLAP;
597 } else {
598 /*
599 * If the only RP that covers this group is an
600 * RP configured for
601 * 224.0.0.0/4 that is fine, ignore that one.
602 * For all others
603 * though we must return PIM_GROUP_OVERLAP
604 */
605 if (prefix_same(&rp_info->group,
606 &tmp_rp_info->group)) {
607 XFREE(MTYPE_PIM_RP, rp_info);
608 return PIM_GROUP_OVERLAP;
609 }
610 }
611 }
612 }
613
614 listnode_add_sort(pim->rp_list, rp_info);
615 rn = route_node_get(pim->rp_table, &rp_info->group);
616 rn->info = rp_info;
617
618 if (PIM_DEBUG_TRACE) {
619 char buf[PREFIX_STRLEN];
620
621 zlog_debug("Allocated: %p for rp_info: %p(%s) Lock: %d", rn,
622 rp_info,
623 prefix2str(&rp_info->group, buf, sizeof(buf)),
624 rn->lock);
625 }
626
627 for (ALL_LIST_ELEMENTS_RO(pim->upstream_list, upnode, up)) {
628 if (up->sg.src.s_addr == INADDR_ANY) {
629 struct prefix grp;
630 struct rp_info *trp_info;
631
632 grp.family = AF_INET;
633 grp.prefixlen = IPV4_MAX_BITLEN;
634 grp.u.prefix4 = up->sg.grp;
635 trp_info = pim_rp_find_match_group(pim, &grp);
636
637 if (trp_info == rp_info)
638 pim_upstream_update(pim, up);
639 }
640 }
641
642 pim_rp_check_interfaces(pim, rp_info);
643 pim_rp_refresh_group_to_rp_mapping(pim);
644
645 /* Register addr with Zebra NHT */
646 nht_p.family = AF_INET;
647 nht_p.prefixlen = IPV4_MAX_BITLEN;
648 nht_p.u.prefix4 = rp_info->rp.rpf_addr.u.prefix4;
649 if (PIM_DEBUG_PIM_NHT_RP) {
650 char buf[PREFIX2STR_BUFFER];
651 char buf1[PREFIX2STR_BUFFER];
652 prefix2str(&nht_p, buf, sizeof(buf));
653 prefix2str(&rp_info->group, buf1, sizeof(buf1));
654 zlog_debug("%s: NHT Register RP addr %s grp %s with Zebra ",
655 __PRETTY_FUNCTION__, buf, buf1);
656 }
657
658 pim_find_or_track_nexthop(pim, &nht_p, NULL, rp_info, NULL);
659 if (!pim_ecmp_nexthop_lookup(pim, &rp_info->rp.source_nexthop, &nht_p,
660 &rp_info->group, 1))
661 return PIM_RP_NO_PATH;
662
663 return PIM_SUCCESS;
664 }
665
666 int pim_rp_del(struct pim_instance *pim, const char *rp,
667 const char *group_range, const char *plist)
668 {
669 struct prefix group;
670 struct in_addr rp_addr;
671 struct prefix g_all;
672 struct rp_info *rp_info;
673 struct rp_info *rp_all;
674 int result;
675 struct prefix nht_p;
676 struct route_node *rn;
677 bool was_plist = false;
678 struct rp_info *trp_info;
679 struct pim_upstream *up;
680 struct listnode *upnode;
681
682 if (group_range == NULL)
683 result = str2prefix("224.0.0.0/4", &group);
684 else
685 result = str2prefix(group_range, &group);
686
687 if (!result)
688 return PIM_GROUP_BAD_ADDRESS;
689
690 result = inet_pton(AF_INET, rp, &rp_addr);
691 if (result <= 0)
692 return PIM_RP_BAD_ADDRESS;
693
694 if (plist)
695 rp_info = pim_rp_find_prefix_list(pim, rp_addr, plist);
696 else
697 rp_info = pim_rp_find_exact(pim, rp_addr, &group);
698
699 if (!rp_info)
700 return PIM_RP_NOT_FOUND;
701
702 if (rp_info->plist) {
703 XFREE(MTYPE_PIM_FILTER_NAME, rp_info->plist);
704 was_plist = true;
705 }
706
707 /* Deregister addr with Zebra NHT */
708 nht_p.family = AF_INET;
709 nht_p.prefixlen = IPV4_MAX_BITLEN;
710 nht_p.u.prefix4 = rp_info->rp.rpf_addr.u.prefix4;
711 if (PIM_DEBUG_PIM_NHT_RP) {
712 char buf[PREFIX2STR_BUFFER];
713 prefix2str(&nht_p, buf, sizeof(buf));
714 zlog_debug("%s: Deregister RP addr %s with Zebra ",
715 __PRETTY_FUNCTION__, buf);
716 }
717 pim_delete_tracked_nexthop(pim, &nht_p, NULL, rp_info);
718
719 if (!str2prefix("224.0.0.0/4", &g_all))
720 return PIM_RP_BAD_ADDRESS;
721
722 rp_all = pim_rp_find_match_group(pim, &g_all);
723
724 if (rp_all == rp_info) {
725 for (ALL_LIST_ELEMENTS_RO(pim->upstream_list, upnode, up)) {
726 /* Find the upstream (*, G) whose upstream address is
727 * same as the deleted RP
728 */
729 if ((up->upstream_addr.s_addr == rp_addr.s_addr) &&
730 (up->sg.src.s_addr == INADDR_ANY)) {
731 struct prefix grp;
732 grp.family = AF_INET;
733 grp.prefixlen = IPV4_MAX_BITLEN;
734 grp.u.prefix4 = up->sg.grp;
735 trp_info = pim_rp_find_match_group(pim, &grp);
736 if (trp_info == rp_all) {
737 pim_upstream_rpf_clear(pim, up);
738 up->upstream_addr.s_addr = INADDR_ANY;
739 }
740 }
741 }
742 rp_all->rp.rpf_addr.family = AF_INET;
743 rp_all->rp.rpf_addr.u.prefix4.s_addr = INADDR_NONE;
744 rp_all->i_am_rp = 0;
745 return PIM_SUCCESS;
746 }
747
748 listnode_delete(pim->rp_list, rp_info);
749
750 if (!was_plist) {
751 rn = route_node_get(pim->rp_table, &rp_info->group);
752 if (rn) {
753 if (rn->info != rp_info)
754 flog_err(
755 EC_LIB_DEVELOPMENT,
756 "Expected rn->info to be equal to rp_info");
757
758 if (PIM_DEBUG_TRACE) {
759 char buf[PREFIX_STRLEN];
760
761 zlog_debug(
762 "%s:Found for Freeing: %p for rp_info: %p(%s) Lock: %d",
763 __PRETTY_FUNCTION__, rn, rp_info,
764 prefix2str(&rp_info->group, buf,
765 sizeof(buf)),
766 rn->lock);
767 }
768 rn->info = NULL;
769 route_unlock_node(rn);
770 route_unlock_node(rn);
771 }
772 }
773
774 pim_rp_refresh_group_to_rp_mapping(pim);
775
776 for (ALL_LIST_ELEMENTS_RO(pim->upstream_list, upnode, up)) {
777 /* Find the upstream (*, G) whose upstream address is same as
778 * the deleted RP
779 */
780 if ((up->upstream_addr.s_addr == rp_addr.s_addr) &&
781 (up->sg.src.s_addr == INADDR_ANY)) {
782 struct prefix grp;
783
784 grp.family = AF_INET;
785 grp.prefixlen = IPV4_MAX_BITLEN;
786 grp.u.prefix4 = up->sg.grp;
787
788 trp_info = pim_rp_find_match_group(pim, &grp);
789
790 /* RP not found for the group grp */
791 if (pim_rpf_addr_is_inaddr_none(&trp_info->rp)) {
792 pim_upstream_rpf_clear(pim, up);
793 pim_rp_set_upstream_addr(pim,
794 &up->upstream_addr,
795 up->sg.src, up->sg.grp);
796 }
797
798 /* RP found for the group grp */
799 else
800 pim_upstream_update(pim, up);
801 }
802 }
803
804 XFREE(MTYPE_PIM_RP, rp_info);
805 return PIM_SUCCESS;
806 }
807
808 void pim_rp_setup(struct pim_instance *pim)
809 {
810 struct listnode *node;
811 struct rp_info *rp_info;
812 struct prefix nht_p;
813
814 for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
815 if (rp_info->rp.rpf_addr.u.prefix4.s_addr == INADDR_NONE)
816 continue;
817
818 nht_p.family = AF_INET;
819 nht_p.prefixlen = IPV4_MAX_BITLEN;
820 nht_p.u.prefix4 = rp_info->rp.rpf_addr.u.prefix4;
821
822 pim_find_or_track_nexthop(pim, &nht_p, NULL, rp_info, NULL);
823 if (!pim_ecmp_nexthop_lookup(pim, &rp_info->rp.source_nexthop,
824 &nht_p, &rp_info->group, 1))
825 if (PIM_DEBUG_PIM_NHT_RP)
826 zlog_debug(
827 "Unable to lookup nexthop for rp specified");
828 }
829 }
830
831 /*
832 * Checks to see if we should elect ourself the actual RP when new if
833 * addresses are added against an interface.
834 */
835 void pim_rp_check_on_if_add(struct pim_interface *pim_ifp)
836 {
837 struct listnode *node;
838 struct rp_info *rp_info;
839 bool i_am_rp_changed = false;
840 struct pim_instance *pim = pim_ifp->pim;
841
842 if (pim->rp_list == NULL)
843 return;
844
845 for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
846 if (pim_rpf_addr_is_inaddr_none(&rp_info->rp))
847 continue;
848
849 /* if i_am_rp is already set nothing to be done (adding new
850 * addresses
851 * is not going to make a difference). */
852 if (rp_info->i_am_rp) {
853 continue;
854 }
855
856 if (pim_rp_check_interface_addrs(rp_info, pim_ifp)) {
857 i_am_rp_changed = true;
858 rp_info->i_am_rp = 1;
859 if (PIM_DEBUG_PIM_NHT_RP) {
860 char rp[PREFIX_STRLEN];
861 pim_addr_dump("<rp?>", &rp_info->rp.rpf_addr,
862 rp, sizeof(rp));
863 zlog_debug("%s: %s: i am rp", __func__, rp);
864 }
865 }
866 }
867
868 if (i_am_rp_changed) {
869 pim_msdp_i_am_rp_changed(pim);
870 }
871 }
872
873 /* up-optimized re-evaluation of "i_am_rp". this is used when ifaddresses
874 * are removed. Removing numbers is an uncommon event in an active network
875 * so I have made no attempt to optimize it. */
876 void pim_i_am_rp_re_evaluate(struct pim_instance *pim)
877 {
878 struct listnode *node;
879 struct rp_info *rp_info;
880 bool i_am_rp_changed = false;
881 int old_i_am_rp;
882
883 if (pim->rp_list == NULL)
884 return;
885
886 for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
887 if (pim_rpf_addr_is_inaddr_none(&rp_info->rp))
888 continue;
889
890 old_i_am_rp = rp_info->i_am_rp;
891 pim_rp_check_interfaces(pim, rp_info);
892
893 if (old_i_am_rp != rp_info->i_am_rp) {
894 i_am_rp_changed = true;
895 if (PIM_DEBUG_PIM_NHT_RP) {
896 char rp[PREFIX_STRLEN];
897 pim_addr_dump("<rp?>", &rp_info->rp.rpf_addr,
898 rp, sizeof(rp));
899 if (rp_info->i_am_rp) {
900 zlog_debug("%s: %s: i am rp", __func__,
901 rp);
902 } else {
903 zlog_debug("%s: %s: i am no longer rp",
904 __func__, rp);
905 }
906 }
907 }
908 }
909
910 if (i_am_rp_changed) {
911 pim_msdp_i_am_rp_changed(pim);
912 }
913 }
914
915 /*
916 * I_am_RP(G) is true if the group-to-RP mapping indicates that
917 * this router is the RP for the group.
918 *
919 * Since we only have static RP, all groups are part of this RP
920 */
921 int pim_rp_i_am_rp(struct pim_instance *pim, struct in_addr group)
922 {
923 struct prefix g;
924 struct rp_info *rp_info;
925
926 memset(&g, 0, sizeof(g));
927 g.family = AF_INET;
928 g.prefixlen = 32;
929 g.u.prefix4 = group;
930
931 rp_info = pim_rp_find_match_group(pim, &g);
932
933 if (rp_info)
934 return rp_info->i_am_rp;
935
936 return 0;
937 }
938
939 /*
940 * RP(G)
941 *
942 * Return the RP that the Group belongs too.
943 */
944 struct pim_rpf *pim_rp_g(struct pim_instance *pim, struct in_addr group)
945 {
946 struct prefix g;
947 struct rp_info *rp_info;
948
949 memset(&g, 0, sizeof(g));
950 g.family = AF_INET;
951 g.prefixlen = 32;
952 g.u.prefix4 = group;
953
954 rp_info = pim_rp_find_match_group(pim, &g);
955
956 if (rp_info) {
957 struct prefix nht_p;
958
959 /* Register addr with Zebra NHT */
960 nht_p.family = AF_INET;
961 nht_p.prefixlen = IPV4_MAX_BITLEN;
962 nht_p.u.prefix4 = rp_info->rp.rpf_addr.u.prefix4;
963 if (PIM_DEBUG_PIM_NHT_RP) {
964 char buf[PREFIX2STR_BUFFER];
965 char buf1[PREFIX2STR_BUFFER];
966 prefix2str(&nht_p, buf, sizeof(buf));
967 prefix2str(&rp_info->group, buf1, sizeof(buf1));
968 zlog_debug(
969 "%s: NHT Register RP addr %s grp %s with Zebra",
970 __PRETTY_FUNCTION__, buf, buf1);
971 }
972
973 pim_find_or_track_nexthop(pim, &nht_p, NULL, rp_info, NULL);
974 pim_rpf_set_refresh_time(pim);
975 (void)pim_ecmp_nexthop_lookup(pim, &rp_info->rp.source_nexthop,
976 &nht_p, &rp_info->group, 1);
977 return (&rp_info->rp);
978 }
979
980 // About to Go Down
981 return NULL;
982 }
983
984 /*
985 * Set the upstream IP address we want to talk to based upon
986 * the rp configured and the source address
987 *
988 * If we have don't have a RP configured and the source address is *
989 * then set the upstream addr as INADDR_ANY and return failure.
990 *
991 */
992 int pim_rp_set_upstream_addr(struct pim_instance *pim, struct in_addr *up,
993 struct in_addr source, struct in_addr group)
994 {
995 struct rp_info *rp_info;
996 struct prefix g;
997
998 memset(&g, 0, sizeof(g));
999 g.family = AF_INET;
1000 g.prefixlen = 32;
1001 g.u.prefix4 = group;
1002
1003 rp_info = pim_rp_find_match_group(pim, &g);
1004
1005 if (!rp_info || ((pim_rpf_addr_is_inaddr_none(&rp_info->rp))
1006 && (source.s_addr == INADDR_ANY))) {
1007 if (PIM_DEBUG_PIM_NHT_RP)
1008 zlog_debug("%s: Received a (*,G) with no RP configured",
1009 __PRETTY_FUNCTION__);
1010 up->s_addr = INADDR_ANY;
1011 return 0;
1012 }
1013
1014 *up = (source.s_addr == INADDR_ANY) ? rp_info->rp.rpf_addr.u.prefix4
1015 : source;
1016
1017 return 1;
1018 }
1019
1020 int pim_rp_config_write(struct pim_instance *pim, struct vty *vty,
1021 const char *spaces)
1022 {
1023 struct listnode *node;
1024 struct rp_info *rp_info;
1025 char rp_buffer[32];
1026 char group_buffer[32];
1027 int count = 0;
1028
1029 for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
1030 if (pim_rpf_addr_is_inaddr_none(&rp_info->rp))
1031 continue;
1032
1033 if (rp_info->plist)
1034 vty_out(vty, "%sip pim rp %s prefix-list %s\n", spaces,
1035 inet_ntop(AF_INET,
1036 &rp_info->rp.rpf_addr.u.prefix4,
1037 rp_buffer, 32),
1038 rp_info->plist);
1039 else
1040 vty_out(vty, "%sip pim rp %s %s\n", spaces,
1041 inet_ntop(AF_INET,
1042 &rp_info->rp.rpf_addr.u.prefix4,
1043 rp_buffer, 32),
1044 prefix2str(&rp_info->group, group_buffer, 32));
1045 count++;
1046 }
1047
1048 return count;
1049 }
1050
1051 bool pim_rp_check_is_my_ip_address(struct pim_instance *pim,
1052 struct in_addr dest_addr)
1053 {
1054 if (if_lookup_exact_address(&dest_addr, AF_INET, pim->vrf_id))
1055 return true;
1056
1057 return false;
1058 }
1059
1060 void pim_rp_show_information(struct pim_instance *pim, struct vty *vty, bool uj)
1061 {
1062 struct rp_info *rp_info;
1063 struct rp_info *prev_rp_info = NULL;
1064 struct listnode *node;
1065
1066 json_object *json = NULL;
1067 json_object *json_rp_rows = NULL;
1068 json_object *json_row = NULL;
1069
1070 if (uj)
1071 json = json_object_new_object();
1072 else
1073 vty_out(vty,
1074 "RP address group/prefix-list OIF I am RP\n");
1075
1076 for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
1077 if (!pim_rpf_addr_is_inaddr_none(&rp_info->rp)) {
1078 char buf[48];
1079
1080 if (uj) {
1081 /*
1082 * If we have moved on to a new RP then add the
1083 * entry for the previous RP
1084 */
1085 if (prev_rp_info
1086 && prev_rp_info->rp.rpf_addr.u.prefix4
1087 .s_addr
1088 != rp_info->rp.rpf_addr.u.prefix4
1089 .s_addr) {
1090 json_object_object_add(
1091 json,
1092 inet_ntoa(prev_rp_info->rp
1093 .rpf_addr.u
1094 .prefix4),
1095 json_rp_rows);
1096 json_rp_rows = NULL;
1097 }
1098
1099 if (!json_rp_rows)
1100 json_rp_rows = json_object_new_array();
1101
1102 json_row = json_object_new_object();
1103 if (rp_info->rp.source_nexthop.interface)
1104 json_object_string_add(
1105 json_row, "outboundInterface",
1106 rp_info->rp.source_nexthop
1107 .interface->name);
1108
1109 if (rp_info->i_am_rp)
1110 json_object_boolean_true_add(json_row,
1111 "iAmRP");
1112
1113 if (rp_info->plist)
1114 json_object_string_add(json_row,
1115 "prefixList",
1116 rp_info->plist);
1117 else
1118 json_object_string_add(
1119 json_row, "group",
1120 prefix2str(&rp_info->group, buf,
1121 48));
1122
1123 json_object_array_add(json_rp_rows, json_row);
1124 } else {
1125 vty_out(vty, "%-15s ",
1126 inet_ntoa(rp_info->rp.rpf_addr.u
1127 .prefix4));
1128
1129 if (rp_info->plist)
1130 vty_out(vty, "%-18s ", rp_info->plist);
1131 else
1132 vty_out(vty, "%-18s ",
1133 prefix2str(&rp_info->group, buf,
1134 48));
1135
1136 if (rp_info->rp.source_nexthop.interface)
1137 vty_out(vty, "%-16s ",
1138 rp_info->rp.source_nexthop
1139 .interface->name);
1140 else
1141 vty_out(vty, "%-16s ", "(Unknown)");
1142
1143 if (rp_info->i_am_rp)
1144 vty_out(vty, "yes\n");
1145 else
1146 vty_out(vty, "no\n");
1147 }
1148
1149 prev_rp_info = rp_info;
1150 }
1151 }
1152
1153 if (uj) {
1154 if (prev_rp_info && json_rp_rows)
1155 json_object_object_add(
1156 json,
1157 inet_ntoa(prev_rp_info->rp.rpf_addr.u.prefix4),
1158 json_rp_rows);
1159
1160 vty_out(vty, "%s\n", json_object_to_json_string_ext(
1161 json, JSON_C_TO_STRING_PRETTY));
1162 json_object_free(json);
1163 }
1164 }
1165
1166 void pim_resolve_rp_nh(struct pim_instance *pim, struct pim_neighbor *nbr)
1167 {
1168 struct listnode *node = NULL;
1169 struct rp_info *rp_info = NULL;
1170 struct nexthop *nh_node = NULL;
1171 struct prefix nht_p;
1172 struct pim_nexthop_cache pnc;
1173
1174 for (ALL_LIST_ELEMENTS_RO(pim->rp_list, node, rp_info)) {
1175 if (rp_info->rp.rpf_addr.u.prefix4.s_addr == INADDR_NONE)
1176 continue;
1177
1178 nht_p.family = AF_INET;
1179 nht_p.prefixlen = IPV4_MAX_BITLEN;
1180 nht_p.u.prefix4 = rp_info->rp.rpf_addr.u.prefix4;
1181 memset(&pnc, 0, sizeof(struct pim_nexthop_cache));
1182 if (!pim_find_or_track_nexthop(pim, &nht_p, NULL, rp_info,
1183 &pnc))
1184 continue;
1185
1186 for (nh_node = pnc.nexthop; nh_node; nh_node = nh_node->next) {
1187 if (nh_node->gate.ipv4.s_addr != 0)
1188 continue;
1189
1190 struct interface *ifp1 = if_lookup_by_index(
1191 nh_node->ifindex, pim->vrf_id);
1192
1193 if (nbr->interface != ifp1)
1194 continue;
1195
1196 nh_node->gate.ipv4 = nbr->source_addr;
1197 if (PIM_DEBUG_PIM_NHT_RP) {
1198 char str[PREFIX_STRLEN];
1199 char str1[INET_ADDRSTRLEN];
1200 pim_inet4_dump("<nht_nbr?>", nbr->source_addr,
1201 str1, sizeof(str1));
1202 pim_addr_dump("<nht_addr?>", &nht_p, str,
1203 sizeof(str));
1204 zlog_debug(
1205 "%s: addr %s new nexthop addr %s interface %s",
1206 __PRETTY_FUNCTION__, str, str1,
1207 ifp1->name);
1208 }
1209 }
1210 }
1211 }
FRRouting mirror