bgpd/bgp_mpath.c

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