]> git.proxmox.com Git - mirror_frr.git/blob - bgpd/bgp_mpath.c
yang: change EIGRP authentication enum name
[mirror_frr.git] / bgpd / bgp_mpath.c
1 /*
2 * BGP Multipath
3 * Copyright (C) 2010 Google Inc.
4 *
5 * This file is part of Quagga
6 *
7 * Quagga is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
10 * later version.
11 *
12 * Quagga is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <zebra.h>
23
24 #include "command.h"
25 #include "prefix.h"
26 #include "linklist.h"
27 #include "sockunion.h"
28 #include "memory.h"
29 #include "queue.h"
30 #include "filter.h"
31
32 #include "bgpd/bgpd.h"
33 #include "bgpd/bgp_table.h"
34 #include "bgpd/bgp_route.h"
35 #include "bgpd/bgp_attr.h"
36 #include "bgpd/bgp_debug.h"
37 #include "bgpd/bgp_aspath.h"
38 #include "bgpd/bgp_community.h"
39 #include "bgpd/bgp_ecommunity.h"
40 #include "bgpd/bgp_lcommunity.h"
41 #include "bgpd/bgp_mpath.h"
42
43 /*
44 * bgp_maximum_paths_set
45 *
46 * Record maximum-paths configuration for BGP instance
47 */
48 int bgp_maximum_paths_set(struct bgp *bgp, afi_t afi, safi_t safi, int peertype,
49 uint16_t maxpaths, uint16_t options)
50 {
51 if (!bgp || (afi >= AFI_MAX) || (safi >= SAFI_MAX))
52 return -1;
53
54 switch (peertype) {
55 case BGP_PEER_IBGP:
56 bgp->maxpaths[afi][safi].maxpaths_ibgp = maxpaths;
57 bgp->maxpaths[afi][safi].ibgp_flags |= options;
58 break;
59 case BGP_PEER_EBGP:
60 bgp->maxpaths[afi][safi].maxpaths_ebgp = maxpaths;
61 break;
62 default:
63 return -1;
64 }
65
66 return 0;
67 }
68
69 /*
70 * bgp_maximum_paths_unset
71 *
72 * Remove maximum-paths configuration from BGP instance
73 */
74 int bgp_maximum_paths_unset(struct bgp *bgp, afi_t afi, safi_t safi,
75 int peertype)
76 {
77 if (!bgp || (afi >= AFI_MAX) || (safi >= SAFI_MAX))
78 return -1;
79
80 switch (peertype) {
81 case BGP_PEER_IBGP:
82 bgp->maxpaths[afi][safi].maxpaths_ibgp = multipath_num;
83 bgp->maxpaths[afi][safi].ibgp_flags = 0;
84 break;
85 case BGP_PEER_EBGP:
86 bgp->maxpaths[afi][safi].maxpaths_ebgp = multipath_num;
87 break;
88 default:
89 return -1;
90 }
91
92 return 0;
93 }
94
95 /*
96 * bgp_interface_same
97 *
98 * Return true if ifindex for ifp1 and ifp2 are the same, else return false.
99 */
100 static int bgp_interface_same(struct interface *ifp1, struct interface *ifp2)
101 {
102 if (!ifp1 && !ifp2)
103 return 1;
104
105 if (!ifp1 && ifp2)
106 return 0;
107
108 if (ifp1 && !ifp2)
109 return 0;
110
111 return (ifp1->ifindex == ifp2->ifindex);
112 }
113
114
115 /*
116 * bgp_path_info_nexthop_cmp
117 *
118 * Compare the nexthops of two paths. Return value is less than, equal to,
119 * or greater than zero if bpi1 is respectively less than, equal to,
120 * or greater than bpi2.
121 */
122 int bgp_path_info_nexthop_cmp(struct bgp_path_info *bpi1,
123 struct bgp_path_info *bpi2)
124 {
125 int compare;
126 struct in6_addr addr1, addr2;
127
128 compare = IPV4_ADDR_CMP(&bpi1->attr->nexthop, &bpi2->attr->nexthop);
129 if (!compare) {
130 if (bpi1->attr->mp_nexthop_len == bpi2->attr->mp_nexthop_len) {
131 switch (bpi1->attr->mp_nexthop_len) {
132 case BGP_ATTR_NHLEN_IPV4:
133 case BGP_ATTR_NHLEN_VPNV4:
134 compare = IPV4_ADDR_CMP(
135 &bpi1->attr->mp_nexthop_global_in,
136 &bpi2->attr->mp_nexthop_global_in);
137 break;
138 case BGP_ATTR_NHLEN_IPV6_GLOBAL:
139 case BGP_ATTR_NHLEN_VPNV6_GLOBAL:
140 compare = IPV6_ADDR_CMP(
141 &bpi1->attr->mp_nexthop_global,
142 &bpi2->attr->mp_nexthop_global);
143 break;
144 case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL:
145 addr1 = (bpi1->attr->mp_nexthop_prefer_global)
146 ? bpi1->attr->mp_nexthop_global
147 : bpi1->attr->mp_nexthop_local;
148 addr2 = (bpi2->attr->mp_nexthop_prefer_global)
149 ? bpi2->attr->mp_nexthop_global
150 : bpi2->attr->mp_nexthop_local;
151
152 if (!bpi1->attr->mp_nexthop_prefer_global
153 && !bpi2->attr->mp_nexthop_prefer_global)
154 compare = !bgp_interface_same(
155 bpi1->peer->ifp,
156 bpi2->peer->ifp);
157
158 if (!compare)
159 compare = IPV6_ADDR_CMP(&addr1, &addr2);
160 break;
161 }
162 }
163
164 /* This can happen if one IPv6 peer sends you global and
165 * link-local
166 * nexthops but another IPv6 peer only sends you global
167 */
168 else if (bpi1->attr->mp_nexthop_len
169 == BGP_ATTR_NHLEN_IPV6_GLOBAL
170 || bpi1->attr->mp_nexthop_len
171 == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) {
172 compare = IPV6_ADDR_CMP(&bpi1->attr->mp_nexthop_global,
173 &bpi2->attr->mp_nexthop_global);
174 if (!compare) {
175 if (bpi1->attr->mp_nexthop_len
176 < bpi2->attr->mp_nexthop_len)
177 compare = -1;
178 else
179 compare = 1;
180 }
181 }
182 }
183
184 return compare;
185 }
186
187 /*
188 * bgp_path_info_mpath_cmp
189 *
190 * This function determines our multipath list ordering. By ordering
191 * the list we can deterministically select which paths are included
192 * in the multipath set. The ordering also helps in detecting changes
193 * in the multipath selection so we can detect whether to send an
194 * update to zebra.
195 *
196 * The order of paths is determined first by received nexthop, and then
197 * by peer address if the nexthops are the same.
198 */
199 static int bgp_path_info_mpath_cmp(void *val1, void *val2)
200 {
201 struct bgp_path_info *bpi1, *bpi2;
202 int compare;
203
204 bpi1 = val1;
205 bpi2 = val2;
206
207 compare = bgp_path_info_nexthop_cmp(bpi1, bpi2);
208
209 if (!compare) {
210 if (!bpi1->peer->su_remote && !bpi2->peer->su_remote)
211 compare = 0;
212 else if (!bpi1->peer->su_remote)
213 compare = 1;
214 else if (!bpi2->peer->su_remote)
215 compare = -1;
216 else
217 compare = sockunion_cmp(bpi1->peer->su_remote,
218 bpi2->peer->su_remote);
219 }
220
221 return compare;
222 }
223
224 /*
225 * bgp_mp_list_init
226 *
227 * Initialize the mp_list, which holds the list of multipaths
228 * selected by bgp_best_selection
229 */
230 void bgp_mp_list_init(struct list *mp_list)
231 {
232 assert(mp_list);
233 memset(mp_list, 0, sizeof(struct list));
234 mp_list->cmp = bgp_path_info_mpath_cmp;
235 }
236
237 /*
238 * bgp_mp_list_clear
239 *
240 * Clears all entries out of the mp_list
241 */
242 void bgp_mp_list_clear(struct list *mp_list)
243 {
244 assert(mp_list);
245 list_delete_all_node(mp_list);
246 }
247
248 /*
249 * bgp_mp_list_add
250 *
251 * Adds a multipath entry to the mp_list
252 */
253 void bgp_mp_list_add(struct list *mp_list, struct bgp_path_info *mpinfo)
254 {
255 assert(mp_list && mpinfo);
256 listnode_add_sort(mp_list, mpinfo);
257 }
258
259 /*
260 * bgp_path_info_mpath_new
261 *
262 * Allocate and zero memory for a new bgp_path_info_mpath element
263 */
264 static struct bgp_path_info_mpath *bgp_path_info_mpath_new(void)
265 {
266 struct bgp_path_info_mpath *new_mpath;
267 new_mpath = XCALLOC(MTYPE_BGP_MPATH_INFO,
268 sizeof(struct bgp_path_info_mpath));
269 return new_mpath;
270 }
271
272 /*
273 * bgp_path_info_mpath_free
274 *
275 * Release resources for a bgp_path_info_mpath element and zero out pointer
276 */
277 void bgp_path_info_mpath_free(struct bgp_path_info_mpath **mpath)
278 {
279 if (mpath && *mpath) {
280 if ((*mpath)->mp_attr)
281 bgp_attr_unintern(&(*mpath)->mp_attr);
282 XFREE(MTYPE_BGP_MPATH_INFO, *mpath);
283 *mpath = NULL;
284 }
285 }
286
287 /*
288 * bgp_path_info_mpath_get
289 *
290 * Fetch the mpath element for the given bgp_path_info. Used for
291 * doing lazy allocation.
292 */
293 static struct bgp_path_info_mpath *
294 bgp_path_info_mpath_get(struct bgp_path_info *path)
295 {
296 struct bgp_path_info_mpath *mpath;
297
298 if (!path)
299 return NULL;
300
301 if (!path->mpath) {
302 mpath = bgp_path_info_mpath_new();
303 if (!mpath)
304 return NULL;
305 path->mpath = mpath;
306 mpath->mp_info = path;
307 }
308 return path->mpath;
309 }
310
311 /*
312 * bgp_path_info_mpath_enqueue
313 *
314 * Enqueue a path onto the multipath list given the previous multipath
315 * list entry
316 */
317 static void bgp_path_info_mpath_enqueue(struct bgp_path_info *prev_info,
318 struct bgp_path_info *path)
319 {
320 struct bgp_path_info_mpath *prev, *mpath;
321
322 prev = bgp_path_info_mpath_get(prev_info);
323 mpath = bgp_path_info_mpath_get(path);
324 if (!prev || !mpath)
325 return;
326
327 mpath->mp_next = prev->mp_next;
328 mpath->mp_prev = prev;
329 if (prev->mp_next)
330 prev->mp_next->mp_prev = mpath;
331 prev->mp_next = mpath;
332
333 SET_FLAG(path->flags, BGP_PATH_MULTIPATH);
334 }
335
336 /*
337 * bgp_path_info_mpath_dequeue
338 *
339 * Remove a path from the multipath list
340 */
341 void bgp_path_info_mpath_dequeue(struct bgp_path_info *path)
342 {
343 struct bgp_path_info_mpath *mpath = path->mpath;
344 if (!mpath)
345 return;
346 if (mpath->mp_prev)
347 mpath->mp_prev->mp_next = mpath->mp_next;
348 if (mpath->mp_next)
349 mpath->mp_next->mp_prev = mpath->mp_prev;
350 mpath->mp_next = mpath->mp_prev = NULL;
351 UNSET_FLAG(path->flags, BGP_PATH_MULTIPATH);
352 }
353
354 /*
355 * bgp_path_info_mpath_next
356 *
357 * Given a bgp_path_info, return the next multipath entry
358 */
359 struct bgp_path_info *bgp_path_info_mpath_next(struct bgp_path_info *path)
360 {
361 if (!path->mpath || !path->mpath->mp_next)
362 return NULL;
363 return path->mpath->mp_next->mp_info;
364 }
365
366 /*
367 * bgp_path_info_mpath_first
368 *
369 * Given bestpath bgp_path_info, return the first multipath entry.
370 */
371 struct bgp_path_info *bgp_path_info_mpath_first(struct bgp_path_info *path)
372 {
373 return bgp_path_info_mpath_next(path);
374 }
375
376 /*
377 * bgp_path_info_mpath_count
378 *
379 * Given the bestpath bgp_path_info, return the number of multipath entries
380 */
381 uint32_t bgp_path_info_mpath_count(struct bgp_path_info *path)
382 {
383 if (!path->mpath)
384 return 0;
385 return path->mpath->mp_count;
386 }
387
388 /*
389 * bgp_path_info_mpath_count_set
390 *
391 * Sets the count of multipaths into bestpath's mpath element
392 */
393 static void bgp_path_info_mpath_count_set(struct bgp_path_info *path,
394 uint32_t count)
395 {
396 struct bgp_path_info_mpath *mpath;
397 if (!count && !path->mpath)
398 return;
399 mpath = bgp_path_info_mpath_get(path);
400 if (!mpath)
401 return;
402 mpath->mp_count = count;
403 }
404
405 /*
406 * bgp_path_info_mpath_attr
407 *
408 * Given bestpath bgp_path_info, return aggregated attribute set used
409 * for advertising the multipath route
410 */
411 struct attr *bgp_path_info_mpath_attr(struct bgp_path_info *path)
412 {
413 if (!path->mpath)
414 return NULL;
415 return path->mpath->mp_attr;
416 }
417
418 /*
419 * bgp_path_info_mpath_attr_set
420 *
421 * Sets the aggregated attribute into bestpath's mpath element
422 */
423 static void bgp_path_info_mpath_attr_set(struct bgp_path_info *path,
424 struct attr *attr)
425 {
426 struct bgp_path_info_mpath *mpath;
427 if (!attr && !path->mpath)
428 return;
429 mpath = bgp_path_info_mpath_get(path);
430 if (!mpath)
431 return;
432 mpath->mp_attr = attr;
433 }
434
435 /*
436 * bgp_path_info_mpath_update
437 *
438 * Compare and sync up the multipath list with the mp_list generated by
439 * bgp_best_selection
440 */
441 void bgp_path_info_mpath_update(struct bgp_node *rn,
442 struct bgp_path_info *new_best,
443 struct bgp_path_info *old_best,
444 struct list *mp_list,
445 struct bgp_maxpaths_cfg *mpath_cfg)
446 {
447 uint16_t maxpaths, mpath_count, old_mpath_count;
448 struct listnode *mp_node, *mp_next_node;
449 struct bgp_path_info *cur_mpath, *new_mpath, *next_mpath, *prev_mpath;
450 int mpath_changed, debug;
451 char pfx_buf[PREFIX2STR_BUFFER], nh_buf[2][INET6_ADDRSTRLEN];
452 char path_buf[PATH_ADDPATH_STR_BUFFER];
453
454 mpath_changed = 0;
455 maxpaths = multipath_num;
456 mpath_count = 0;
457 cur_mpath = NULL;
458 old_mpath_count = 0;
459 prev_mpath = new_best;
460 mp_node = listhead(mp_list);
461 debug = bgp_debug_bestpath(&rn->p);
462
463 if (debug)
464 prefix2str(&rn->p, pfx_buf, sizeof(pfx_buf));
465
466 if (new_best) {
467 mpath_count++;
468 if (new_best != old_best)
469 bgp_path_info_mpath_dequeue(new_best);
470 maxpaths = (new_best->peer->sort == BGP_PEER_IBGP)
471 ? mpath_cfg->maxpaths_ibgp
472 : mpath_cfg->maxpaths_ebgp;
473 }
474
475 if (old_best) {
476 cur_mpath = bgp_path_info_mpath_first(old_best);
477 old_mpath_count = bgp_path_info_mpath_count(old_best);
478 bgp_path_info_mpath_count_set(old_best, 0);
479 bgp_path_info_mpath_dequeue(old_best);
480 }
481
482 if (debug)
483 zlog_debug(
484 "%s: starting mpath update, newbest %s num candidates %d old-mpath-count %d",
485 pfx_buf, new_best ? new_best->peer->host : "NONE",
486 mp_list ? listcount(mp_list) : 0, old_mpath_count);
487
488 /*
489 * We perform an ordered walk through both lists in parallel.
490 * The reason for the ordered walk is that if there are paths
491 * that were previously multipaths and are still multipaths, the walk
492 * should encounter them in both lists at the same time. Otherwise
493 * there will be paths that are in one list or another, and we
494 * will deal with these separately.
495 *
496 * Note that new_best might be somewhere in the mp_list, so we need
497 * to skip over it
498 */
499 while (mp_node || cur_mpath) {
500 struct bgp_path_info *tmp_info;
501
502 /*
503 * We can bail out of this loop if all existing paths on the
504 * multipath list have been visited (for cleanup purposes) and
505 * the maxpath requirement is fulfulled
506 */
507 if (!cur_mpath && (mpath_count >= maxpaths))
508 break;
509
510 mp_next_node = mp_node ? listnextnode(mp_node) : NULL;
511 next_mpath =
512 cur_mpath ? bgp_path_info_mpath_next(cur_mpath) : NULL;
513 tmp_info = mp_node ? listgetdata(mp_node) : NULL;
514
515 if (debug)
516 zlog_debug(
517 "%s: comparing candidate %s with existing mpath %s",
518 pfx_buf,
519 tmp_info ? tmp_info->peer->host : "NONE",
520 cur_mpath ? cur_mpath->peer->host : "NONE");
521
522 /*
523 * If equal, the path was a multipath and is still a multipath.
524 * Insert onto new multipath list if maxpaths allows.
525 */
526 if (mp_node && (listgetdata(mp_node) == cur_mpath)) {
527 list_delete_node(mp_list, mp_node);
528 bgp_path_info_mpath_dequeue(cur_mpath);
529 if ((mpath_count < maxpaths)
530 && prev_mpath
531 && bgp_path_info_nexthop_cmp(prev_mpath,
532 cur_mpath)) {
533 bgp_path_info_mpath_enqueue(prev_mpath,
534 cur_mpath);
535 prev_mpath = cur_mpath;
536 mpath_count++;
537 if (debug) {
538 bgp_path_info_path_with_addpath_rx_str(
539 cur_mpath, path_buf);
540 zlog_debug(
541 "%s: %s is still multipath, cur count %d",
542 pfx_buf, path_buf, mpath_count);
543 }
544 } else {
545 mpath_changed = 1;
546 if (debug) {
547 bgp_path_info_path_with_addpath_rx_str(
548 cur_mpath, path_buf);
549 zlog_debug(
550 "%s: remove mpath %s nexthop %s, cur count %d",
551 pfx_buf, path_buf,
552 inet_ntop(AF_INET,
553 &cur_mpath->attr
554 ->nexthop,
555 nh_buf[0],
556 sizeof(nh_buf[0])),
557 mpath_count);
558 }
559 }
560 mp_node = mp_next_node;
561 cur_mpath = next_mpath;
562 continue;
563 }
564
565 if (cur_mpath
566 && (!mp_node
567 || (bgp_path_info_mpath_cmp(cur_mpath,
568 listgetdata(mp_node))
569 < 0))) {
570 /*
571 * If here, we have an old multipath and either the
572 * mp_list
573 * is finished or the next mp_node points to a later
574 * multipath, so we need to purge this path from the
575 * multipath list
576 */
577 bgp_path_info_mpath_dequeue(cur_mpath);
578 mpath_changed = 1;
579 if (debug) {
580 bgp_path_info_path_with_addpath_rx_str(
581 cur_mpath, path_buf);
582 zlog_debug(
583 "%s: remove mpath %s nexthop %s, cur count %d",
584 pfx_buf, path_buf,
585 inet_ntop(AF_INET,
586 &cur_mpath->attr->nexthop,
587 nh_buf[0], sizeof(nh_buf[0])),
588 mpath_count);
589 }
590 cur_mpath = next_mpath;
591 } else {
592 /*
593 * If here, we have a path on the mp_list that was not
594 * previously
595 * a multipath (due to non-equivalance or maxpaths
596 * exceeded),
597 * or the matching multipath is sorted later in the
598 * multipath
599 * list. Before we enqueue the path on the new multipath
600 * list,
601 * make sure its not on the old_best multipath list or
602 * referenced
603 * via next_mpath:
604 * - If next_mpath points to this new path, update
605 * next_mpath to
606 * point to the multipath after this one
607 * - Dequeue the path from the multipath list just to
608 * make sure
609 */
610 new_mpath = listgetdata(mp_node);
611 list_delete_node(mp_list, mp_node);
612 assert(new_mpath);
613 assert(prev_mpath);
614 if ((mpath_count < maxpaths) && (new_mpath != new_best)
615 && bgp_path_info_nexthop_cmp(prev_mpath,
616 new_mpath)) {
617 if (new_mpath == next_mpath)
618 bgp_path_info_mpath_next(new_mpath);
619 bgp_path_info_mpath_dequeue(new_mpath);
620
621 bgp_path_info_mpath_enqueue(prev_mpath,
622 new_mpath);
623 prev_mpath = new_mpath;
624 mpath_changed = 1;
625 mpath_count++;
626 if (debug) {
627 bgp_path_info_path_with_addpath_rx_str(
628 new_mpath, path_buf);
629 zlog_debug(
630 "%s: add mpath %s nexthop %s, cur count %d",
631 pfx_buf, path_buf,
632 inet_ntop(AF_INET,
633 &new_mpath->attr
634 ->nexthop,
635 nh_buf[0],
636 sizeof(nh_buf[0])),
637 mpath_count);
638 }
639 }
640 mp_node = mp_next_node;
641 }
642 }
643
644 if (new_best) {
645 if (debug)
646 zlog_debug(
647 "%s: New mpath count (incl newbest) %d mpath-change %s",
648 pfx_buf, mpath_count,
649 mpath_changed ? "YES" : "NO");
650
651 bgp_path_info_mpath_count_set(new_best, mpath_count - 1);
652 if (mpath_changed
653 || (bgp_path_info_mpath_count(new_best) != old_mpath_count))
654 SET_FLAG(new_best->flags, BGP_PATH_MULTIPATH_CHG);
655 }
656 }
657
658 /*
659 * bgp_mp_dmed_deselect
660 *
661 * Clean up multipath information for BGP_PATH_DMED_SELECTED path that
662 * is not selected as best path
663 */
664 void bgp_mp_dmed_deselect(struct bgp_path_info *dmed_best)
665 {
666 struct bgp_path_info *mpinfo, *mpnext;
667
668 if (!dmed_best)
669 return;
670
671 for (mpinfo = bgp_path_info_mpath_first(dmed_best); mpinfo;
672 mpinfo = mpnext) {
673 mpnext = bgp_path_info_mpath_next(mpinfo);
674 bgp_path_info_mpath_dequeue(mpinfo);
675 }
676
677 bgp_path_info_mpath_count_set(dmed_best, 0);
678 UNSET_FLAG(dmed_best->flags, BGP_PATH_MULTIPATH_CHG);
679 assert(bgp_path_info_mpath_first(dmed_best) == NULL);
680 }
681
682 /*
683 * bgp_path_info_mpath_aggregate_update
684 *
685 * Set the multipath aggregate attribute. We need to see if the
686 * aggregate has changed and then set the ATTR_CHANGED flag on the
687 * bestpath info so that a peer update will be generated. The
688 * change is detected by generating the current attribute,
689 * interning it, and then comparing the interned pointer with the
690 * current value. We can skip this generate/compare step if there
691 * is no change in multipath selection and no attribute change in
692 * any multipath.
693 */
694 void bgp_path_info_mpath_aggregate_update(struct bgp_path_info *new_best,
695 struct bgp_path_info *old_best)
696 {
697 struct bgp_path_info *mpinfo;
698 struct aspath *aspath;
699 struct aspath *asmerge;
700 struct attr *new_attr, *old_attr;
701 uint8_t origin;
702 struct community *community, *commerge;
703 struct ecommunity *ecomm, *ecommerge;
704 struct lcommunity *lcomm, *lcommerge;
705 struct attr attr = {0};
706
707 if (old_best && (old_best != new_best)
708 && (old_attr = bgp_path_info_mpath_attr(old_best))) {
709 bgp_attr_unintern(&old_attr);
710 bgp_path_info_mpath_attr_set(old_best, NULL);
711 }
712
713 if (!new_best)
714 return;
715
716 if (!bgp_path_info_mpath_count(new_best)) {
717 if ((new_attr = bgp_path_info_mpath_attr(new_best))) {
718 bgp_attr_unintern(&new_attr);
719 bgp_path_info_mpath_attr_set(new_best, NULL);
720 SET_FLAG(new_best->flags, BGP_PATH_ATTR_CHANGED);
721 }
722 return;
723 }
724
725 bgp_attr_dup(&attr, new_best->attr);
726
727 if (new_best->peer && bgp_flag_check(new_best->peer->bgp,
728 BGP_FLAG_MULTIPATH_RELAX_AS_SET)) {
729
730 /* aggregate attribute from multipath constituents */
731 aspath = aspath_dup(attr.aspath);
732 origin = attr.origin;
733 community =
734 attr.community ? community_dup(attr.community) : NULL;
735 ecomm = (attr.ecommunity) ? ecommunity_dup(attr.ecommunity)
736 : NULL;
737 lcomm = (attr.lcommunity) ? lcommunity_dup(attr.lcommunity)
738 : NULL;
739
740 for (mpinfo = bgp_path_info_mpath_first(new_best); mpinfo;
741 mpinfo = bgp_path_info_mpath_next(mpinfo)) {
742 asmerge =
743 aspath_aggregate(aspath, mpinfo->attr->aspath);
744 aspath_free(aspath);
745 aspath = asmerge;
746
747 if (origin < mpinfo->attr->origin)
748 origin = mpinfo->attr->origin;
749
750 if (mpinfo->attr->community) {
751 if (community) {
752 commerge = community_merge(
753 community,
754 mpinfo->attr->community);
755 community =
756 community_uniq_sort(commerge);
757 community_free(&commerge);
758 } else
759 community = community_dup(
760 mpinfo->attr->community);
761 }
762
763 if (mpinfo->attr->ecommunity) {
764 if (ecomm) {
765 ecommerge = ecommunity_merge(
766 ecomm,
767 mpinfo->attr->ecommunity);
768 ecomm = ecommunity_uniq_sort(ecommerge);
769 ecommunity_free(&ecommerge);
770 } else
771 ecomm = ecommunity_dup(
772 mpinfo->attr->ecommunity);
773 }
774 if (mpinfo->attr->lcommunity) {
775 if (lcomm) {
776 lcommerge = lcommunity_merge(
777 lcomm,
778 mpinfo->attr->lcommunity);
779 lcomm = lcommunity_uniq_sort(lcommerge);
780 lcommunity_free(&lcommerge);
781 } else
782 lcomm = lcommunity_dup(
783 mpinfo->attr->lcommunity);
784 }
785 }
786
787 attr.aspath = aspath;
788 attr.origin = origin;
789 if (community) {
790 attr.community = community;
791 attr.flag |= ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES);
792 }
793 if (ecomm) {
794 attr.ecommunity = ecomm;
795 attr.flag |= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES);
796 }
797 if (lcomm) {
798 attr.lcommunity = lcomm;
799 attr.flag |= ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES);
800 }
801
802 /* Zap multipath attr nexthop so we set nexthop to self */
803 attr.nexthop.s_addr = 0;
804 memset(&attr.mp_nexthop_global, 0, sizeof(struct in6_addr));
805
806 /* TODO: should we set ATOMIC_AGGREGATE and AGGREGATOR? */
807 }
808
809 new_attr = bgp_attr_intern(&attr);
810
811 if (new_attr != bgp_path_info_mpath_attr(new_best)) {
812 if ((old_attr = bgp_path_info_mpath_attr(new_best)))
813 bgp_attr_unintern(&old_attr);
814 bgp_path_info_mpath_attr_set(new_best, new_attr);
815 SET_FLAG(new_best->flags, BGP_PATH_ATTR_CHANGED);
816 } else
817 bgp_attr_unintern(&new_attr);
818 }