Annotation of embedaddon/quagga/bgpd/bgp_mpath.c, revision 1.1.1.2
1.1 misho 1: /* $QuaggaId: Format:%an, %ai, %h$ $
2: *
3: * BGP Multipath
4: * Copyright (C) 2010 Google Inc.
5: *
6: * This file is part of Quagga
7: *
8: * Quagga is free software; you can redistribute it and/or modify it
9: * under the terms of the GNU General Public License as published by the
10: * Free Software Foundation; either version 2, or (at your option) any
11: * later version.
12: *
13: * Quagga is distributed in the hope that it will be useful, but
14: * WITHOUT ANY WARRANTY; without even the implied warranty of
15: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16: * General Public License for more details.
17: *
18: * You should have received a copy of the GNU General Public License
19: * along with Quagga; see the file COPYING. If not, write to the Free
20: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
21: * 02111-1307, USA.
22: */
23:
24: #include <zebra.h>
25:
26: #include "command.h"
27: #include "prefix.h"
28: #include "linklist.h"
29: #include "sockunion.h"
30: #include "memory.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_mpath.h"
41:
42: /*
43: * bgp_maximum_paths_set
44: *
45: * Record maximum-paths configuration for BGP instance
46: */
47: int
48: bgp_maximum_paths_set (struct bgp *bgp, afi_t afi, safi_t safi,
49: int peertype, u_int16_t maxpaths)
50: {
51: if (!bgp || (afi >= AFI_MAX) || (safi >= SAFI_MAX))
52: return -1;
53:
54: switch (peertype)
55: {
56: case BGP_PEER_IBGP:
57: bgp->maxpaths[afi][safi].maxpaths_ibgp = maxpaths;
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
75: bgp_maximum_paths_unset (struct bgp *bgp, afi_t afi, safi_t safi,
76: int peertype)
77: {
78: if (!bgp || (afi >= AFI_MAX) || (safi >= SAFI_MAX))
79: return -1;
80:
81: switch (peertype)
82: {
83: case BGP_PEER_IBGP:
84: bgp->maxpaths[afi][safi].maxpaths_ibgp = BGP_DEFAULT_MAXPATHS;
85: break;
86: case BGP_PEER_EBGP:
87: bgp->maxpaths[afi][safi].maxpaths_ebgp = BGP_DEFAULT_MAXPATHS;
88: break;
89: default:
90: return -1;
91: }
92:
93: return 0;
94: }
95:
96: /*
97: * bgp_info_nexthop_cmp
98: *
99: * Compare the nexthops of two paths. Return value is less than, equal to,
100: * or greater than zero if bi1 is respectively less than, equal to,
101: * or greater than bi2.
102: */
103: static int
104: bgp_info_nexthop_cmp (struct bgp_info *bi1, struct bgp_info *bi2)
105: {
106: struct attr_extra *ae1, *ae2;
107: int compare;
108:
109: ae1 = bi1->attr->extra;
110: ae2 = bi2->attr->extra;
111:
112: compare = IPV4_ADDR_CMP (&bi1->attr->nexthop, &bi2->attr->nexthop);
113:
114: if (!compare && ae1 && ae2 && (ae1->mp_nexthop_len == ae2->mp_nexthop_len))
115: {
116: switch (ae1->mp_nexthop_len)
117: {
118: case 4:
119: case 12:
120: compare = IPV4_ADDR_CMP (&ae1->mp_nexthop_global_in,
121: &ae2->mp_nexthop_global_in);
122: break;
123: #ifdef HAVE_IPV6
124: case 16:
125: compare = IPV6_ADDR_CMP (&ae1->mp_nexthop_global,
126: &ae2->mp_nexthop_global);
127: break;
128: case 32:
129: compare = IPV6_ADDR_CMP (&ae1->mp_nexthop_global,
130: &ae2->mp_nexthop_global);
131: if (!compare)
132: compare = IPV6_ADDR_CMP (&ae1->mp_nexthop_local,
133: &ae2->mp_nexthop_local);
134: break;
135: #endif /* HAVE_IPV6 */
136: }
137: }
138:
139: return compare;
140: }
141:
142: /*
143: * bgp_info_mpath_cmp
144: *
145: * This function determines our multipath list ordering. By ordering
146: * the list we can deterministically select which paths are included
147: * in the multipath set. The ordering also helps in detecting changes
148: * in the multipath selection so we can detect whether to send an
149: * update to zebra.
150: *
151: * The order of paths is determined first by received nexthop, and then
152: * by peer address if the nexthops are the same.
153: */
154: static int
155: bgp_info_mpath_cmp (void *val1, void *val2)
156: {
157: struct bgp_info *bi1, *bi2;
158: int compare;
159:
160: bi1 = val1;
161: bi2 = val2;
162:
163: compare = bgp_info_nexthop_cmp (bi1, bi2);
164:
165: if (!compare)
166: compare = sockunion_cmp (bi1->peer->su_remote, bi2->peer->su_remote);
167:
168: return compare;
169: }
170:
171: /*
172: * bgp_mp_list_init
173: *
174: * Initialize the mp_list, which holds the list of multipaths
175: * selected by bgp_best_selection
176: */
177: void
178: bgp_mp_list_init (struct list *mp_list)
179: {
180: assert (mp_list);
181: memset (mp_list, 0, sizeof (struct list));
182: mp_list->cmp = bgp_info_mpath_cmp;
183: }
184:
185: /*
186: * bgp_mp_list_clear
187: *
188: * Clears all entries out of the mp_list
189: */
190: void
191: bgp_mp_list_clear (struct list *mp_list)
192: {
193: assert (mp_list);
194: list_delete_all_node (mp_list);
195: }
196:
197: /*
198: * bgp_mp_list_add
199: *
200: * Adds a multipath entry to the mp_list
201: */
202: void
203: bgp_mp_list_add (struct list *mp_list, struct bgp_info *mpinfo)
204: {
205: assert (mp_list && mpinfo);
206: listnode_add_sort (mp_list, mpinfo);
207: }
208:
209: /*
210: * bgp_info_mpath_new
211: *
212: * Allocate and zero memory for a new bgp_info_mpath element
213: */
214: static struct bgp_info_mpath *
215: bgp_info_mpath_new (void)
216: {
217: struct bgp_info_mpath *new_mpath;
218: new_mpath = XCALLOC (MTYPE_BGP_MPATH_INFO, sizeof (struct bgp_info_mpath));
219: return new_mpath;
220: }
221:
222: /*
223: * bgp_info_mpath_free
224: *
225: * Release resources for a bgp_info_mpath element and zero out pointer
226: */
227: void
228: bgp_info_mpath_free (struct bgp_info_mpath **mpath)
229: {
230: if (mpath && *mpath)
231: {
232: if ((*mpath)->mp_attr)
233: bgp_attr_unintern (&(*mpath)->mp_attr);
234: XFREE (MTYPE_BGP_MPATH_INFO, *mpath);
235: *mpath = NULL;
236: }
237: }
238:
239: /*
240: * bgp_info_mpath_get
241: *
242: * Fetch the mpath element for the given bgp_info. Used for
243: * doing lazy allocation.
244: */
245: static struct bgp_info_mpath *
246: bgp_info_mpath_get (struct bgp_info *binfo)
247: {
248: struct bgp_info_mpath *mpath;
249: if (!binfo->mpath)
250: {
251: mpath = bgp_info_mpath_new();
252: if (!mpath)
253: return NULL;
254: binfo->mpath = mpath;
255: mpath->mp_info = binfo;
256: }
257: return binfo->mpath;
258: }
259:
260: /*
261: * bgp_info_mpath_enqueue
262: *
263: * Enqueue a path onto the multipath list given the previous multipath
264: * list entry
265: */
266: static void
267: bgp_info_mpath_enqueue (struct bgp_info *prev_info, struct bgp_info *binfo)
268: {
269: struct bgp_info_mpath *prev, *mpath;
270:
271: prev = bgp_info_mpath_get (prev_info);
272: mpath = bgp_info_mpath_get (binfo);
273: if (!prev || !mpath)
274: return;
275:
276: mpath->mp_next = prev->mp_next;
277: mpath->mp_prev = prev;
278: if (prev->mp_next)
279: prev->mp_next->mp_prev = mpath;
280: prev->mp_next = mpath;
281:
282: SET_FLAG (binfo->flags, BGP_INFO_MULTIPATH);
283: }
284:
285: /*
286: * bgp_info_mpath_dequeue
287: *
288: * Remove a path from the multipath list
289: */
290: void
291: bgp_info_mpath_dequeue (struct bgp_info *binfo)
292: {
293: struct bgp_info_mpath *mpath = binfo->mpath;
294: if (!mpath)
295: return;
296: if (mpath->mp_prev)
297: mpath->mp_prev->mp_next = mpath->mp_next;
298: if (mpath->mp_next)
299: mpath->mp_next->mp_prev = mpath->mp_prev;
300: mpath->mp_next = mpath->mp_prev = NULL;
301: UNSET_FLAG (binfo->flags, BGP_INFO_MULTIPATH);
302: }
303:
304: /*
305: * bgp_info_mpath_next
306: *
307: * Given a bgp_info, return the next multipath entry
308: */
309: struct bgp_info *
310: bgp_info_mpath_next (struct bgp_info *binfo)
311: {
312: if (!binfo->mpath || !binfo->mpath->mp_next)
313: return NULL;
314: return binfo->mpath->mp_next->mp_info;
315: }
316:
317: /*
318: * bgp_info_mpath_first
319: *
320: * Given bestpath bgp_info, return the first multipath entry.
321: */
322: struct bgp_info *
323: bgp_info_mpath_first (struct bgp_info *binfo)
324: {
325: return bgp_info_mpath_next (binfo);
326: }
327:
328: /*
329: * bgp_info_mpath_count
330: *
331: * Given the bestpath bgp_info, return the number of multipath entries
332: */
333: u_int32_t
334: bgp_info_mpath_count (struct bgp_info *binfo)
335: {
336: if (!binfo->mpath)
337: return 0;
338: return binfo->mpath->mp_count;
339: }
340:
341: /*
342: * bgp_info_mpath_count_set
343: *
344: * Sets the count of multipaths into bestpath's mpath element
345: */
346: static void
347: bgp_info_mpath_count_set (struct bgp_info *binfo, u_int32_t count)
348: {
349: struct bgp_info_mpath *mpath;
350: if (!count && !binfo->mpath)
351: return;
352: mpath = bgp_info_mpath_get (binfo);
353: if (!mpath)
354: return;
355: mpath->mp_count = count;
356: }
357:
358: /*
359: * bgp_info_mpath_attr
360: *
361: * Given bestpath bgp_info, return aggregated attribute set used
362: * for advertising the multipath route
363: */
364: struct attr *
365: bgp_info_mpath_attr (struct bgp_info *binfo)
366: {
367: if (!binfo->mpath)
368: return NULL;
369: return binfo->mpath->mp_attr;
370: }
371:
372: /*
373: * bgp_info_mpath_attr_set
374: *
375: * Sets the aggregated attribute into bestpath's mpath element
376: */
377: static void
378: bgp_info_mpath_attr_set (struct bgp_info *binfo, struct attr *attr)
379: {
380: struct bgp_info_mpath *mpath;
381: if (!attr && !binfo->mpath)
382: return;
383: mpath = bgp_info_mpath_get (binfo);
384: if (!mpath)
385: return;
386: mpath->mp_attr = attr;
387: }
388:
389: /*
390: * bgp_info_mpath_update
391: *
392: * Compare and sync up the multipath list with the mp_list generated by
393: * bgp_best_selection
394: */
395: void
396: bgp_info_mpath_update (struct bgp_node *rn, struct bgp_info *new_best,
397: struct bgp_info *old_best, struct list *mp_list,
398: struct bgp_maxpaths_cfg *mpath_cfg)
399: {
400: u_int16_t maxpaths, mpath_count, old_mpath_count;
401: struct listnode *mp_node, *mp_next_node;
402: struct bgp_info *cur_mpath, *new_mpath, *next_mpath, *prev_mpath;
403: int mpath_changed, debug;
404: char pfx_buf[INET_ADDRSTRLEN], nh_buf[2][INET_ADDRSTRLEN];
405:
406: mpath_changed = 0;
407: maxpaths = BGP_DEFAULT_MAXPATHS;
408: mpath_count = 0;
409: cur_mpath = NULL;
410: old_mpath_count = 0;
411: prev_mpath = new_best;
412: mp_node = listhead (mp_list);
413: debug = BGP_DEBUG (events, EVENTS);
414:
415: if (debug)
416: prefix2str (&rn->p, pfx_buf, sizeof (pfx_buf));
417:
418: if (new_best)
419: {
420: mpath_count++;
421: if (new_best != old_best)
422: bgp_info_mpath_dequeue (new_best);
1.1.1.2 ! misho 423: maxpaths = (new_best->peer->sort == BGP_PEER_IBGP) ?
1.1 misho 424: mpath_cfg->maxpaths_ibgp : mpath_cfg->maxpaths_ebgp;
425: }
426:
427: if (old_best)
428: {
429: cur_mpath = bgp_info_mpath_first (old_best);
430: old_mpath_count = bgp_info_mpath_count (old_best);
431: bgp_info_mpath_count_set (old_best, 0);
432: bgp_info_mpath_dequeue (old_best);
433: }
434:
435: /*
436: * We perform an ordered walk through both lists in parallel.
437: * The reason for the ordered walk is that if there are paths
438: * that were previously multipaths and are still multipaths, the walk
439: * should encounter them in both lists at the same time. Otherwise
440: * there will be paths that are in one list or another, and we
441: * will deal with these separately.
442: *
443: * Note that new_best might be somewhere in the mp_list, so we need
444: * to skip over it
445: */
446: while (mp_node || cur_mpath)
447: {
448: /*
449: * We can bail out of this loop if all existing paths on the
450: * multipath list have been visited (for cleanup purposes) and
451: * the maxpath requirement is fulfulled
452: */
453: if (!cur_mpath && (mpath_count >= maxpaths))
454: break;
455:
456: mp_next_node = mp_node ? listnextnode (mp_node) : NULL;
457: next_mpath = cur_mpath ? bgp_info_mpath_next (cur_mpath) : NULL;
458:
459: /*
460: * If equal, the path was a multipath and is still a multipath.
461: * Insert onto new multipath list if maxpaths allows.
462: */
463: if (mp_node && (listgetdata (mp_node) == cur_mpath))
464: {
465: list_delete_node (mp_list, mp_node);
466: bgp_info_mpath_dequeue (cur_mpath);
467: if ((mpath_count < maxpaths) &&
468: bgp_info_nexthop_cmp (prev_mpath, cur_mpath))
469: {
470: bgp_info_mpath_enqueue (prev_mpath, cur_mpath);
471: prev_mpath = cur_mpath;
472: mpath_count++;
473: }
474: else
475: {
476: mpath_changed = 1;
477: if (debug)
478: zlog_debug ("%s remove mpath nexthop %s peer %s", pfx_buf,
479: inet_ntop (AF_INET, &cur_mpath->attr->nexthop,
480: nh_buf[0], sizeof (nh_buf[0])),
481: sockunion2str (cur_mpath->peer->su_remote,
482: nh_buf[1], sizeof (nh_buf[1])));
483: }
484: mp_node = mp_next_node;
485: cur_mpath = next_mpath;
486: continue;
487: }
488:
489: if (cur_mpath && (!mp_node ||
490: (bgp_info_mpath_cmp (cur_mpath,
491: listgetdata (mp_node)) < 0)))
492: {
493: /*
494: * If here, we have an old multipath and either the mp_list
495: * is finished or the next mp_node points to a later
496: * multipath, so we need to purge this path from the
497: * multipath list
498: */
499: bgp_info_mpath_dequeue (cur_mpath);
500: mpath_changed = 1;
501: if (debug)
502: zlog_debug ("%s remove mpath nexthop %s peer %s", pfx_buf,
503: inet_ntop (AF_INET, &cur_mpath->attr->nexthop,
504: nh_buf[0], sizeof (nh_buf[0])),
505: sockunion2str (cur_mpath->peer->su_remote,
506: nh_buf[1], sizeof (nh_buf[1])));
507: cur_mpath = next_mpath;
508: }
509: else
510: {
511: /*
512: * If here, we have a path on the mp_list that was not previously
513: * a multipath (due to non-equivalance or maxpaths exceeded),
514: * or the matching multipath is sorted later in the multipath
515: * list. Before we enqueue the path on the new multipath list,
516: * make sure its not on the old_best multipath list or referenced
517: * via next_mpath:
518: * - If next_mpath points to this new path, update next_mpath to
519: * point to the multipath after this one
520: * - Dequeue the path from the multipath list just to make sure
521: */
522: new_mpath = listgetdata (mp_node);
523: list_delete_node (mp_list, mp_node);
524: if ((mpath_count < maxpaths) && (new_mpath != new_best) &&
525: bgp_info_nexthop_cmp (prev_mpath, new_mpath))
526: {
527: if (new_mpath == next_mpath)
528: next_mpath = bgp_info_mpath_next (new_mpath);
529: bgp_info_mpath_dequeue (new_mpath);
530:
531: bgp_info_mpath_enqueue (prev_mpath, new_mpath);
532: prev_mpath = new_mpath;
533: mpath_changed = 1;
534: mpath_count++;
535: if (debug)
536: zlog_debug ("%s add mpath nexthop %s peer %s", pfx_buf,
537: inet_ntop (AF_INET, &new_mpath->attr->nexthop,
538: nh_buf[0], sizeof (nh_buf[0])),
539: sockunion2str (new_mpath->peer->su_remote,
540: nh_buf[1], sizeof (nh_buf[1])));
541: }
542: mp_node = mp_next_node;
543: }
544: }
545:
546: if (new_best)
547: {
548: bgp_info_mpath_count_set (new_best, mpath_count-1);
549: if (mpath_changed || (bgp_info_mpath_count (new_best) != old_mpath_count))
550: SET_FLAG (new_best->flags, BGP_INFO_MULTIPATH_CHG);
551: }
552: }
553:
554: /*
555: * bgp_mp_dmed_deselect
556: *
557: * Clean up multipath information for BGP_INFO_DMED_SELECTED path that
558: * is not selected as best path
559: */
560: void
561: bgp_mp_dmed_deselect (struct bgp_info *dmed_best)
562: {
563: struct bgp_info *mpinfo, *mpnext;
564:
565: if (!dmed_best)
566: return;
567:
568: for (mpinfo = bgp_info_mpath_first (dmed_best); mpinfo; mpinfo = mpnext)
569: {
570: mpnext = bgp_info_mpath_next (mpinfo);
571: bgp_info_mpath_dequeue (mpinfo);
572: }
573:
574: bgp_info_mpath_count_set (dmed_best, 0);
575: UNSET_FLAG (dmed_best->flags, BGP_INFO_MULTIPATH_CHG);
576: assert (bgp_info_mpath_first (dmed_best) == 0);
577: }
578:
579: /*
580: * bgp_info_mpath_aggregate_update
581: *
582: * Set the multipath aggregate attribute. We need to see if the
583: * aggregate has changed and then set the ATTR_CHANGED flag on the
584: * bestpath info so that a peer update will be generated. The
585: * change is detected by generating the current attribute,
586: * interning it, and then comparing the interned pointer with the
587: * current value. We can skip this generate/compare step if there
588: * is no change in multipath selection and no attribute change in
589: * any multipath.
590: */
591: void
592: bgp_info_mpath_aggregate_update (struct bgp_info *new_best,
593: struct bgp_info *old_best)
594: {
595: struct bgp_info *mpinfo;
596: struct aspath *aspath;
597: struct aspath *asmerge;
598: struct attr *new_attr, *old_attr;
599: u_char origin, attr_chg;
600: struct community *community, *commerge;
601: struct ecommunity *ecomm, *ecommerge;
602: struct attr_extra *ae;
603: struct attr attr = { 0 };
604:
605: if (old_best && (old_best != new_best) &&
606: (old_attr = bgp_info_mpath_attr (old_best)))
607: {
608: bgp_attr_unintern (&old_attr);
609: bgp_info_mpath_attr_set (old_best, NULL);
610: }
611:
612: if (!new_best)
613: return;
614:
615: if (!bgp_info_mpath_count (new_best))
616: {
617: if ((new_attr = bgp_info_mpath_attr (new_best)))
618: {
619: bgp_attr_unintern (&new_attr);
620: bgp_info_mpath_attr_set (new_best, NULL);
621: SET_FLAG (new_best->flags, BGP_INFO_ATTR_CHANGED);
622: }
623: return;
624: }
625:
626: /*
627: * Bail out here if the following is true:
628: * - MULTIPATH_CHG bit is not set on new_best, and
629: * - No change in bestpath, and
630: * - ATTR_CHANGED bit is not set on new_best or any of the multipaths
631: */
632: if (!CHECK_FLAG (new_best->flags, BGP_INFO_MULTIPATH_CHG) &&
633: (old_best == new_best))
634: {
635: attr_chg = 0;
636:
637: if (CHECK_FLAG (new_best->flags, BGP_INFO_ATTR_CHANGED))
638: attr_chg = 1;
639: else
640: for (mpinfo = bgp_info_mpath_first (new_best); mpinfo;
641: mpinfo = bgp_info_mpath_next (mpinfo))
642: {
643: if (CHECK_FLAG (mpinfo->flags, BGP_INFO_ATTR_CHANGED))
644: {
645: attr_chg = 1;
646: break;
647: }
648: }
649:
650: if (!attr_chg)
651: {
652: assert (bgp_info_mpath_attr (new_best));
653: return;
654: }
655: }
656:
657: bgp_attr_dup (&attr, new_best->attr);
658:
659: /* aggregate attribute from multipath constituents */
660: aspath = aspath_dup (attr.aspath);
661: origin = attr.origin;
662: community = attr.community ? community_dup (attr.community) : NULL;
663: ae = attr.extra;
664: ecomm = (ae && ae->ecommunity) ? ecommunity_dup (ae->ecommunity) : NULL;
665:
666: for (mpinfo = bgp_info_mpath_first (new_best); mpinfo;
667: mpinfo = bgp_info_mpath_next (mpinfo))
668: {
669: asmerge = aspath_aggregate (aspath, mpinfo->attr->aspath);
670: aspath_free (aspath);
671: aspath = asmerge;
672:
673: if (origin < mpinfo->attr->origin)
674: origin = mpinfo->attr->origin;
675:
676: if (mpinfo->attr->community)
677: {
678: if (community)
679: {
680: commerge = community_merge (community, mpinfo->attr->community);
681: community = community_uniq_sort (commerge);
682: community_free (commerge);
683: }
684: else
685: community = community_dup (mpinfo->attr->community);
686: }
687:
688: ae = mpinfo->attr->extra;
689: if (ae && ae->ecommunity)
690: {
691: if (ecomm)
692: {
693: ecommerge = ecommunity_merge (ecomm, ae->ecommunity);
694: ecomm = ecommunity_uniq_sort (ecommerge);
695: ecommunity_free (&ecommerge);
696: }
697: else
698: ecomm = ecommunity_dup (ae->ecommunity);
699: }
700: }
701:
702: attr.aspath = aspath;
703: attr.origin = origin;
704: if (community)
705: {
706: attr.community = community;
707: attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES);
708: }
709: if (ecomm)
710: {
711: ae = bgp_attr_extra_get (&attr);
712: ae->ecommunity = ecomm;
713: attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES);
714: }
715:
716: /* Zap multipath attr nexthop so we set nexthop to self */
717: attr.nexthop.s_addr = 0;
718: #ifdef HAVE_IPV6
719: if (attr.extra)
720: memset (&attr.extra->mp_nexthop_global, 0, sizeof (struct in6_addr));
721: #endif /* HAVE_IPV6 */
722:
723: /* TODO: should we set ATOMIC_AGGREGATE and AGGREGATOR? */
724:
725: new_attr = bgp_attr_intern (&attr);
726: bgp_attr_extra_free (&attr);
727:
728: if (new_attr != bgp_info_mpath_attr (new_best))
729: {
730: if ((old_attr = bgp_info_mpath_attr (new_best)))
731: bgp_attr_unintern (&old_attr);
732: bgp_info_mpath_attr_set (new_best, new_attr);
733: SET_FLAG (new_best->flags, BGP_INFO_ATTR_CHANGED);
734: }
735: else
736: bgp_attr_unintern (&new_attr);
737: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bgp_mpath.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / bgpd