vnet/vnet/fib/fib_entry_src.c

   1 /*
   2  * Copyright (c) 2016 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vnet/adj/adj.h>
  17 #include <vnet/dpo/load_balance.h>
  18 #include <vnet/dpo/mpls_label_dpo.h>
  19 #include <vnet/dpo/drop_dpo.h>
  20
  21 #include <vnet/fib/fib_entry_src.h>
  22 #include <vnet/fib/fib_table.h>
  23 #include <vnet/fib/fib_path_ext.h>
  24 #include <vnet/fib/fib_urpf_list.h>
  25
  26 /*
  27  * per-source type vft
  28  */
  29 static fib_entry_src_vft_t fib_entry_src_vft[FIB_SOURCE_MAX];
  30
  31 static fib_protocol_t
  32 fib_entry_get_proto (const fib_entry_t * fib_entry)
  33 {
  34     return (fib_entry->fe_prefix.fp_proto);
  35 }
  36
  37 void
  38 fib_entry_src_register (fib_source_t source,
  39                         const fib_entry_src_vft_t *vft)
  40 {
  41     fib_entry_src_vft[source] = *vft;
  42 }
  43
  44 static int
  45 fib_entry_src_cmp_for_sort (void * v1,
  46                             void * v2)
  47 {
  48     fib_entry_src_t *esrc1 = v1, *esrc2 = v2;
  49
  50     return (esrc1->fes_src - esrc2->fes_src);
  51 }
  52
  53 void
  54 fib_entry_src_action_init (fib_entry_t *fib_entry,
  55                            fib_source_t source)
  56
  57 {
  58     fib_entry_src_t esrc = {
  59         .fes_pl = FIB_NODE_INDEX_INVALID,
  60         .fes_flags = FIB_ENTRY_SRC_FLAG_NONE,
  61         .fes_src = source,
  62     };
  63
  64     if (NULL != fib_entry_src_vft[source].fesv_init)
  65     {
  66         fib_entry_src_vft[source].fesv_init(&esrc);
  67     }
  68
  69     vec_add1(fib_entry->fe_srcs, esrc);
  70     vec_sort_with_function(fib_entry->fe_srcs,
  71                            fib_entry_src_cmp_for_sort);
  72 }
  73
  74 static fib_entry_src_t *
  75 fib_entry_src_find (const fib_entry_t *fib_entry,
  76                     fib_source_t source,
  77                     u32 *index)
  78
  79 {
  80     fib_entry_src_t *esrc;
  81     int ii;
  82
  83     ii = 0;
  84     vec_foreach(esrc, fib_entry->fe_srcs)
  85     {
  86         if (esrc->fes_src == source)
  87         {
  88             if (NULL != index)
  89             {
  90                 *index = ii;
  91             }
  92             return (esrc);
  93         }
  94         else
  95         {
  96             ii++;
  97         }
  98     }
  99
 100     return (NULL);
 101 }
 102
 103 int
 104 fib_entry_is_sourced (fib_node_index_t fib_entry_index,
 105                       fib_source_t source)
 106 {
 107     fib_entry_t *fib_entry;
 108
 109     fib_entry = fib_entry_get(fib_entry_index);
 110
 111     return (NULL != fib_entry_src_find(fib_entry, source, NULL));
 112 }
 113
 114 static fib_entry_src_t *
 115 fib_entry_src_find_or_create (fib_entry_t *fib_entry,
 116                               fib_source_t source,
 117                               u32 *index)
 118 {
 119     fib_entry_src_t *esrc;
 120
 121     esrc = fib_entry_src_find(fib_entry, source, NULL);
 122
 123     if (NULL == esrc)
 124     {
 125         fib_entry_src_action_init(fib_entry, source);
 126     }
 127
 128     return (fib_entry_src_find(fib_entry, source, NULL));
 129 }
 130
 131 void
 132 fib_entry_src_action_deinit (fib_entry_t *fib_entry,
 133                              fib_source_t source)
 134
 135 {
 136     fib_entry_src_t *esrc;
 137     u32 index = ~0;
 138
 139     esrc = fib_entry_src_find(fib_entry, source, &index);
 140
 141     ASSERT(NULL != esrc);
 142
 143     if (NULL != fib_entry_src_vft[source].fesv_deinit)
 144     {
 145         fib_entry_src_vft[source].fesv_deinit(esrc);
 146     }
 147
 148     vec_free(esrc->fes_path_exts);
 149     vec_del1(fib_entry->fe_srcs, index);
 150 }
 151
 152 fib_entry_src_cover_res_t
 153 fib_entry_src_action_cover_change (fib_entry_t *fib_entry,
 154                                    fib_source_t source)
 155 {
 156     if (NULL != fib_entry_src_vft[source].fesv_cover_change)
 157     {
 158         return (fib_entry_src_vft[source].fesv_cover_change(
 159                     fib_entry_src_find(fib_entry, source, NULL),
 160                     fib_entry));
 161     }
 162
 163     fib_entry_src_cover_res_t res = {
 164         .install = !0,
 165         .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
 166     };
 167     return (res);
 168 }
 169
 170 fib_entry_src_cover_res_t
 171 fib_entry_src_action_cover_update (fib_entry_t *fib_entry,
 172                                    fib_source_t source)
 173 {
 174     if (NULL != fib_entry_src_vft[source].fesv_cover_update)
 175     {
 176         return (fib_entry_src_vft[source].fesv_cover_update(
 177                     fib_entry_src_find(fib_entry, source, NULL),
 178                     fib_entry));
 179     }
 180
 181     fib_entry_src_cover_res_t res = {
 182         .install = !0,
 183         .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
 184     };
 185     return (res);
 186 }
 187
 188 typedef struct fib_entry_src_collect_forwarding_ctx_t_
 189 {
 190     load_balance_path_t * next_hops;
 191     const fib_entry_t *fib_entry;
 192     const fib_entry_src_t *esrc;
 193     fib_forward_chain_type_t fct;
 194     int is_recursive;
 195 } fib_entry_src_collect_forwarding_ctx_t;
 196
 197 /**
 198  * @brief Determine whether this FIB entry should use a load-balance MAP
 199  * to support PIC edge fast convergence
 200  */
 201 load_balance_flags_t
 202 fib_entry_calc_lb_flags (fib_entry_src_collect_forwarding_ctx_t *ctx)
 203 {
 204     /**
 205      * We'll use a LB map is the path-list has recursive paths.
 206      * recursive paths implies BGP, and hence scale.
 207      */
 208     if (ctx->is_recursive)
 209     {
 210         return (LOAD_BALANCE_FLAG_USES_MAP);
 211     }
 212     return (LOAD_BALANCE_FLAG_NONE);
 213 }
 214
 215 static int
 216 fib_entry_src_valid_out_label (mpls_label_t label)
 217 {
 218     return ((MPLS_LABEL_IS_REAL(label) ||
 219              MPLS_IETF_IPV4_EXPLICIT_NULL_LABEL == label ||
 220              MPLS_IETF_IPV6_EXPLICIT_NULL_LABEL == label ||
 221              MPLS_IETF_IMPLICIT_NULL_LABEL == label));
 222 }
 223
 224 /**
 225  * @brief Turn the chain type requested by the client into the one they
 226  * really wanted
 227  */
 228 fib_forward_chain_type_t
 229 fib_entry_chain_type_fixup (const fib_entry_t *entry,
 230                             fib_forward_chain_type_t fct)
 231 {
 232     ASSERT(FIB_FORW_CHAIN_TYPE_MPLS_EOS == fct);
 233
 234     /*
 235      * The EOS chain is a tricky since one cannot know the adjacency
 236      * to link to without knowing what the packets payload protocol
 237      * will be once the label is popped.
 238      */
 239     fib_forward_chain_type_t dfct;
 240
 241     dfct = fib_entry_get_default_chain_type(entry);
 242
 243     if (FIB_FORW_CHAIN_TYPE_MPLS_EOS == dfct)
 244     {
 245         /*
 246          * If the entry being asked is a eos-MPLS label entry,
 247          * then use the payload-protocol field, that we stashed there
 248          * for just this purpose
 249          */
 250         return (fib_forw_chain_type_from_dpo_proto(
 251                     entry->fe_prefix.fp_payload_proto));
 252     }
 253     /*
 254      * else give them what this entry would be by default. i.e. if it's a v6
 255      * entry, then the label its local labelled should be carrying v6 traffic.
 256      * If it's a non-EOS label entry, then there are more labels and we want
 257      * a non-eos chain.
 258      */
 259     return (dfct);
 260 }
 261
 262 static int
 263 fib_entry_src_collect_forwarding (fib_node_index_t pl_index,
 264                                   fib_node_index_t path_index,
 265                                   void *arg)
 266 {
 267     fib_entry_src_collect_forwarding_ctx_t *ctx;
 268     fib_path_ext_t *path_ext;
 269
 270     ctx = arg;
 271
 272     /*
 273      * if the path is not resolved, don't include it.
 274      */
 275     if (!fib_path_is_resolved(path_index))
 276     {
 277         return (!0);
 278     }
 279
 280     if (fib_path_is_recursive(path_index))
 281     {
 282         ctx->is_recursive = 1;
 283     }
 284
 285     /*
 286      * get the matching path-extension for the path being visited.
 287      */
 288     vec_foreach(path_ext, ctx->esrc->fes_path_exts)
 289     {
 290         if (path_ext->fpe_path_index == path_index)
 291             break;
 292     }
 293
 294     if (NULL != path_ext &&
 295         path_ext->fpe_path_index == path_index &&
 296         fib_entry_src_valid_out_label(path_ext->fpe_label_stack[0]))
 297     {
 298         /*
 299          * found a matching extension. stack it to obtain the forwarding
 300          * info for this path.
 301          */
 302         ctx->next_hops = fib_path_ext_stack(path_ext, ctx->fib_entry, ctx->fct, ctx->next_hops);
 303     }
 304     else
 305     {
 306         load_balance_path_t *nh;
 307
 308         /*
 309          * no extension => no out-going label for this path. that's OK
 310          * in the case of an IP or EOS chain, but not for non-EOS
 311          */
 312         switch (ctx->fct)
 313         {
 314         case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
 315         case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
 316             /*
 317              * EOS traffic with no label to stack, we need the IP Adj
 318              */
 319             vec_add2(ctx->next_hops, nh, 1);
 320
 321             nh->path_index = path_index;
 322             nh->path_weight = fib_path_get_weight(path_index);
 323             fib_path_contribute_forwarding(path_index, ctx->fct, &nh->path_dpo);
 324
 325             break;
 326         case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
 327             if (fib_path_is_exclusive(path_index) ||
 328                 fib_path_is_deag(path_index))
 329             {
 330                 vec_add2(ctx->next_hops, nh, 1);
 331
 332                 nh->path_index = path_index;
 333                 nh->path_weight = fib_path_get_weight(path_index);
 334                 fib_path_contribute_forwarding(path_index,
 335                                                FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
 336                                                &nh->path_dpo);
 337             }
 338             break;
 339         case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
 340         {
 341             /*
 342              * no label. we need a chain based on the payload. fixup.
 343              */
 344             vec_add2(ctx->next_hops, nh, 1);
 345
 346             nh->path_index = path_index;
 347             nh->path_weight = fib_path_get_weight(path_index);
 348             fib_path_contribute_forwarding(path_index,
 349                                            fib_entry_chain_type_fixup(ctx->fib_entry,
 350                                                                       ctx->fct),
 351                                            &nh->path_dpo);
 352
 353             break;
 354         }
 355         case FIB_FORW_CHAIN_TYPE_ETHERNET:
 356             ASSERT(0);
 357             break;
 358         }
 359     }
 360
 361     return (!0);
 362 }
 363
 364 void
 365 fib_entry_src_mk_lb (fib_entry_t *fib_entry,
 366                      const fib_entry_src_t *esrc,
 367                      fib_forward_chain_type_t fct,
 368                      dpo_id_t *dpo_lb)
 369 {
 370     dpo_proto_t lb_proto;
 371
 372     /*
 373      * If the entry has path extensions then we construct a load-balance
 374      * by stacking the extensions on the forwarding chains of the paths.
 375      * Otherwise we use the load-balance of the path-list
 376      */
 377     fib_entry_src_collect_forwarding_ctx_t ctx = {
 378         .esrc = esrc,
 379         .fib_entry = fib_entry,
 380         .next_hops = NULL,
 381         .is_recursive = 0,
 382         .fct = fct,
 383     };
 384
 385     lb_proto = fib_proto_to_dpo(fib_entry->fe_prefix.fp_proto);
 386
 387     fib_path_list_walk(esrc->fes_pl,
 388                        fib_entry_src_collect_forwarding,
 389                        &ctx);
 390
 391     if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_EXCLUSIVE)
 392     {
 393         /*
 394          * the client provided the DPO that the entry should link to.
 395          * all entries must link to a LB, so if it is an LB already
 396          * then we can use it.
 397          */
 398         if ((1 == vec_len(ctx.next_hops)) &&
 399             (DPO_LOAD_BALANCE == ctx.next_hops[0].path_dpo.dpoi_type))
 400         {
 401             dpo_copy(dpo_lb, &ctx.next_hops[0].path_dpo);
 402             dpo_reset(&ctx.next_hops[0].path_dpo);
 403             return;
 404         }
 405     }
 406
 407     if (!dpo_id_is_valid(dpo_lb))
 408     {
 409         /*
 410          * first time create
 411          */
 412         flow_hash_config_t fhc;
 413
 414         fhc = fib_table_get_flow_hash_config(fib_entry->fe_fib_index,
 415                                              dpo_proto_to_fib(lb_proto));
 416         dpo_set(dpo_lb,
 417                 DPO_LOAD_BALANCE,
 418                 lb_proto,
 419                 load_balance_create(0, lb_proto, fhc));
 420     }
 421
 422     load_balance_multipath_update(dpo_lb,
 423                                   ctx.next_hops,
 424                                   fib_entry_calc_lb_flags(&ctx));
 425     vec_free(ctx.next_hops);
 426
 427     /*
 428      * if this entry is sourced by the uRPF-exempt source then we
 429      * append the always present local0 interface (index 0) to the
 430      * uRPF list so it is not empty. that way packets pass the loose check.
 431      */
 432     index_t ui = fib_path_list_get_urpf(esrc->fes_pl);
 433
 434     if (fib_entry_is_sourced(fib_entry_get_index(fib_entry),
 435                              FIB_SOURCE_URPF_EXEMPT) &&
 436         (0 == fib_urpf_check_size(ui)))
 437     {
 438         /*
 439          * The uRPF list we get from the path-list is shared by all
 440          * other users of the list, but the uRPF exemption applies
 441          * only to this prefix. So we need our own list.
 442          */
 443         ui = fib_urpf_list_alloc_and_lock();
 444         fib_urpf_list_append(ui, 0);
 445         fib_urpf_list_bake(ui);
 446         load_balance_set_urpf(dpo_lb->dpoi_index, ui);
 447         fib_urpf_list_unlock(ui);
 448     }
 449     else
 450     {
 451         load_balance_set_urpf(dpo_lb->dpoi_index, ui);
 452     }
 453 }
 454
 455 void
 456 fib_entry_src_action_install (fib_entry_t *fib_entry,
 457                               fib_source_t source)
 458 {
 459     /*
 460      * Install the forwarding chain for the given source into the forwarding
 461      * tables
 462      */
 463     fib_forward_chain_type_t fct;
 464     fib_entry_src_t *esrc;
 465     int insert;
 466
 467     fct = fib_entry_get_default_chain_type(fib_entry);
 468     esrc = fib_entry_src_find(fib_entry, source, NULL);
 469
 470     /*
 471      * Every entry has its own load-balance object. All changes to the entry's
 472      * forwarding result in an inplace modify of the load-balance. This means
 473      * the load-balance object only needs to be added to the forwarding
 474      * DB once, when it is created.
 475      */
 476     insert = !dpo_id_is_valid(&fib_entry->fe_lb);
 477
 478     fib_entry_src_mk_lb(fib_entry, esrc, fct, &fib_entry->fe_lb);
 479
 480     ASSERT(dpo_id_is_valid(&fib_entry->fe_lb));
 481     FIB_ENTRY_DBG(fib_entry, "install: %d", fib_entry->fe_lb);
 482
 483     /*
 484      * insert the adj into the data-plane forwarding trie
 485      */
 486     if (insert)
 487     {
 488        fib_table_fwding_dpo_update(fib_entry->fe_fib_index,
 489                                    &fib_entry->fe_prefix,
 490                                    &fib_entry->fe_lb);
 491     }
 492
 493     /*
 494      * if any of the other chain types are already created they will need
 495      * updating too
 496      */
 497     fib_entry_delegate_type_t fdt;
 498     fib_entry_delegate_t *fed;
 499
 500     FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed,
 501     {
 502         fib_entry_src_mk_lb(fib_entry, esrc,
 503                             fib_entry_delegate_type_to_chain_type(fdt),
 504                             &fed->fd_dpo);
 505     });
 506 }
 507
 508 void
 509 fib_entry_src_action_uninstall (fib_entry_t *fib_entry)
 510 {
 511     /*
 512      * uninstall the forwarding chain from the forwarding tables
 513      */
 514     FIB_ENTRY_DBG(fib_entry, "uninstall: %d",
 515                   fib_entry->fe_adj_index);
 516
 517     if (dpo_id_is_valid(&fib_entry->fe_lb))
 518     {
 519         fib_table_fwding_dpo_remove(
 520             fib_entry->fe_fib_index,
 521             &fib_entry->fe_prefix,
 522             &fib_entry->fe_lb);
 523
 524         dpo_reset(&fib_entry->fe_lb);
 525     }
 526 }
 527
 528 static void
 529 fib_entry_recursive_loop_detect_i (fib_node_index_t path_list_index)
 530 {
 531     fib_node_index_t *entries = NULL;
 532
 533     fib_path_list_recursive_loop_detect(path_list_index, &entries);
 534
 535     vec_free(entries);
 536 }
 537
 538 void
 539 fib_entry_src_action_activate (fib_entry_t *fib_entry,
 540                                fib_source_t source)
 541
 542 {
 543     int houston_we_are_go_for_install;
 544     fib_entry_src_t *esrc;
 545
 546     esrc = fib_entry_src_find(fib_entry, source, NULL);
 547
 548     ASSERT(!(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE));
 549     ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ADDED);
 550
 551     esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ACTIVE;
 552
 553     if (NULL != fib_entry_src_vft[source].fesv_activate)
 554     {
 555         houston_we_are_go_for_install =
 556             fib_entry_src_vft[source].fesv_activate(esrc, fib_entry);
 557     }
 558     else
 559     {
 560         /*
 561          * the source is not providing an activate function, we'll assume
 562          * therefore it has no objection to installing the entry
 563          */
 564         houston_we_are_go_for_install = !0;
 565     }
 566
 567     /*
 568      * link to the path-list provided by the source, and go check
 569      * if that forms any loops in the graph.
 570      */
 571     fib_entry->fe_parent = esrc->fes_pl;
 572     fib_entry->fe_sibling =
 573         fib_path_list_child_add(fib_entry->fe_parent,
 574                                 FIB_NODE_TYPE_ENTRY,
 575                                 fib_entry_get_index(fib_entry));
 576
 577     fib_entry_recursive_loop_detect_i(fib_entry->fe_parent);
 578
 579     FIB_ENTRY_DBG(fib_entry, "activate: %d",
 580                   fib_entry->fe_parent);
 581
 582     if (0 != houston_we_are_go_for_install)
 583     {
 584         fib_entry_src_action_install(fib_entry, source);
 585     }
 586     else
 587     {
 588         fib_entry_src_action_uninstall(fib_entry);
 589     }
 590 }
 591
 592 void
 593 fib_entry_src_action_deactivate (fib_entry_t *fib_entry,
 594                                  fib_source_t source)
 595
 596 {
 597     fib_node_index_t path_list_index;
 598     fib_entry_src_t *esrc;
 599
 600     esrc = fib_entry_src_find(fib_entry, source, NULL);
 601
 602     ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE);
 603
 604     if (NULL != fib_entry_src_vft[source].fesv_deactivate)
 605     {
 606         fib_entry_src_vft[source].fesv_deactivate(esrc, fib_entry);
 607     }
 608
 609     esrc->fes_flags &= ~FIB_ENTRY_SRC_FLAG_ACTIVE;
 610
 611     FIB_ENTRY_DBG(fib_entry, "deactivate: %d", fib_entry->fe_parent);
 612
 613     /*
 614      * un-link from an old path-list. Check for any loops this will clear
 615      */
 616     path_list_index = fib_entry->fe_parent;
 617     fib_entry->fe_parent = FIB_NODE_INDEX_INVALID;
 618
 619     fib_entry_recursive_loop_detect_i(path_list_index);
 620
 621     /*
 622      * this will unlock the path-list, so it may be invalid thereafter.
 623      */
 624     fib_path_list_child_remove(path_list_index, fib_entry->fe_sibling);
 625     fib_entry->fe_sibling = FIB_NODE_INDEX_INVALID;
 626 }
 627
 628 static void
 629 fib_entry_src_action_fwd_update (const fib_entry_t *fib_entry,
 630                                  fib_source_t source)
 631 {
 632     fib_entry_src_t *esrc;
 633
 634     vec_foreach(esrc, fib_entry->fe_srcs)
 635     {
 636         if (NULL != fib_entry_src_vft[esrc->fes_src].fesv_fwd_update)
 637         {
 638             fib_entry_src_vft[esrc->fes_src].fesv_fwd_update(esrc,
 639                                                              fib_entry,
 640                                                              source);
 641         }
 642     }
 643 }
 644
 645 void
 646 fib_entry_src_action_reactivate (fib_entry_t *fib_entry,
 647                                  fib_source_t source)
 648 {
 649     fib_node_index_t path_list_index;
 650     fib_entry_src_t *esrc;
 651
 652     esrc = fib_entry_src_find(fib_entry, source, NULL);
 653
 654     ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE);
 655
 656     FIB_ENTRY_DBG(fib_entry, "reactivate: %d to %d",
 657                   fib_entry->fe_parent,
 658                   esrc->fes_pl);
 659
 660     if (fib_entry->fe_parent != esrc->fes_pl)
 661     {
 662         /*
 663          * un-link from an old path-list. Check for any loops this will clear
 664          */
 665         path_list_index = fib_entry->fe_parent;
 666         fib_entry->fe_parent = FIB_NODE_INDEX_INVALID;
 667
 668         /*
 669          * temporary lock so it doesn't get deleted when this entry is no
 670          * longer a child.
 671          */
 672         fib_path_list_lock(path_list_index);
 673
 674         /*
 675          * this entry is no longer a child. after unlinking check if any loops
 676          * were broken
 677          */
 678         fib_path_list_child_remove(path_list_index,
 679                                    fib_entry->fe_sibling);
 680
 681         fib_entry_recursive_loop_detect_i(path_list_index);
 682
 683         /*
 684          * link to the path-list provided by the source, and go check
 685          * if that forms any loops in the graph.
 686          */
 687         fib_entry->fe_parent = esrc->fes_pl;
 688         fib_entry->fe_sibling =
 689             fib_path_list_child_add(fib_entry->fe_parent,
 690                                     FIB_NODE_TYPE_ENTRY,
 691                                     fib_entry_get_index(fib_entry));
 692
 693         fib_entry_recursive_loop_detect_i(fib_entry->fe_parent);
 694         fib_path_list_unlock(path_list_index);
 695     }
 696     fib_entry_src_action_install(fib_entry, source);
 697     fib_entry_src_action_fwd_update(fib_entry, source);
 698 }
 699
 700 void
 701 fib_entry_src_action_installed (const fib_entry_t *fib_entry,
 702                                 fib_source_t source)
 703 {
 704     fib_entry_src_t *esrc;
 705
 706     esrc = fib_entry_src_find(fib_entry, source, NULL);
 707
 708     if (NULL != fib_entry_src_vft[source].fesv_installed)
 709     {
 710         fib_entry_src_vft[source].fesv_installed(esrc,
 711                                                  fib_entry);
 712     }
 713
 714     fib_entry_src_action_fwd_update(fib_entry, source);
 715 }
 716
 717 /*
 718  * fib_entry_src_action_add
 719  *
 720  * Adding a source can result in a new fib_entry being created, which
 721  * can inturn mean the pool is realloc'd and thus the entry passed as
 722  * an argument it also realloc'd
 723  * @return the original entry
 724  */
 725 fib_entry_t *
 726 fib_entry_src_action_add (fib_entry_t *fib_entry,
 727                           fib_source_t source,
 728                           fib_entry_flag_t flags,
 729                           const dpo_id_t *dpo)
 730 {
 731     fib_node_index_t fib_entry_index;
 732     fib_entry_src_t *esrc;
 733
 734     esrc = fib_entry_src_find_or_create(fib_entry, source, NULL);
 735
 736     esrc->fes_ref_count++;
 737
 738     if (1 != esrc->fes_ref_count)
 739     {
 740         /*
 741          * we only want to add the source on the 0->1 transition
 742          */
 743         return (fib_entry);
 744     }
 745
 746     esrc->fes_entry_flags = flags;
 747
 748     /*
 749      * save variable so we can recover from a fib_entry realloc.
 750      */
 751     fib_entry_index = fib_entry_get_index(fib_entry);
 752
 753     if (NULL != fib_entry_src_vft[source].fesv_add)
 754     {
 755         fib_entry_src_vft[source].fesv_add(esrc,
 756                                            fib_entry,
 757                                            flags,
 758                                            fib_entry_get_proto(fib_entry),
 759                                            dpo);
 760     }
 761
 762     fib_entry = fib_entry_get(fib_entry_index);
 763
 764     esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ADDED;
 765
 766     fib_path_list_lock(esrc->fes_pl);
 767
 768     /*
 769      * the source owns a lock on the entry
 770      */
 771     fib_entry_lock(fib_entry_get_index(fib_entry));
 772
 773     return (fib_entry);
 774 }
 775
 776 /*
 777  * fib_entry_src_action_update
 778  *
 779  * Adding a source can result in a new fib_entry being created, which
 780  * can inturn mean the pool is realloc'd and thus the entry passed as
 781  * an argument it also realloc'd
 782  * @return the original entry
 783  */
 784 fib_entry_t *
 785 fib_entry_src_action_update (fib_entry_t *fib_entry,
 786                              fib_source_t source,
 787                              fib_entry_flag_t flags,
 788                              const dpo_id_t *dpo)
 789 {
 790     fib_node_index_t fib_entry_index, old_path_list_index;
 791     fib_entry_src_t *esrc;
 792
 793     esrc = fib_entry_src_find_or_create(fib_entry, source, NULL);
 794
 795     if (NULL == esrc)
 796         return (fib_entry_src_action_add(fib_entry, source, flags, dpo));
 797
 798     old_path_list_index = esrc->fes_pl;
 799     esrc->fes_entry_flags = flags;
 800
 801     /*
 802      * save variable so we can recover from a fib_entry realloc.
 803      */
 804     fib_entry_index = fib_entry_get_index(fib_entry);
 805
 806     if (NULL != fib_entry_src_vft[source].fesv_add)
 807     {
 808         fib_entry_src_vft[source].fesv_add(esrc,
 809                                            fib_entry,
 810                                            flags,
 811                                            fib_entry_get_proto(fib_entry),
 812                                            dpo);
 813     }
 814
 815     fib_entry = fib_entry_get(fib_entry_index);
 816
 817     esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ADDED;
 818
 819     fib_path_list_lock(esrc->fes_pl);
 820     fib_path_list_unlock(old_path_list_index);
 821
 822     return (fib_entry);
 823 }
 824
 825
 826 fib_entry_src_flag_t
 827 fib_entry_src_action_remove (fib_entry_t *fib_entry,
 828                              fib_source_t source)
 829
 830 {
 831     fib_node_index_t old_path_list;
 832     fib_entry_src_flag_t sflags;
 833     fib_entry_src_t *esrc;
 834
 835     esrc = fib_entry_src_find(fib_entry, source, NULL);
 836
 837     if (NULL == esrc)
 838         return (FIB_ENTRY_SRC_FLAG_ACTIVE);
 839
 840     esrc->fes_ref_count--;
 841     sflags = esrc->fes_flags;
 842
 843     if (0 != esrc->fes_ref_count)
 844     {
 845         /*
 846          * only remove the source on the 1->0 transisition
 847          */
 848         return (sflags);
 849     }
 850
 851     if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE)
 852     {
 853         fib_entry_src_action_deactivate(fib_entry, source);
 854     }
 855
 856     old_path_list = esrc->fes_pl;
 857
 858     if (NULL != fib_entry_src_vft[source].fesv_remove)
 859     {
 860         fib_entry_src_vft[source].fesv_remove(esrc);
 861     }
 862
 863     fib_path_list_unlock(old_path_list);
 864     fib_entry_unlock(fib_entry_get_index(fib_entry));
 865
 866     sflags &= ~FIB_ENTRY_SRC_FLAG_ADDED;
 867     fib_entry_src_action_deinit(fib_entry, source);
 868
 869     return (sflags);
 870 }
 871
 872 static inline int
 873 fib_route_recurses_via_self (const fib_prefix_t *prefix,
 874                              const fib_route_path_t *rpath)
 875 {
 876     /*
 877      * not all zeros next hop &&
 878      * is recursive path &&
 879      * nexthop is same as the route's address
 880      */
 881     return ((!ip46_address_is_zero(&rpath->frp_addr)) &&
 882             (~0 == rpath->frp_sw_if_index) &&
 883             (0 == ip46_address_cmp(&rpath->frp_addr, &prefix->fp_addr)));
 884
 885 }
 886
 887 /*
 888  * fib_route_attached_cross_table
 889  *
 890  * Return true the the route is attached via an interface that
 891  * is not in the same table as the route
 892  */
 893 static inline int
 894 fib_route_attached_cross_table (const fib_entry_t *fib_entry,
 895                                 const fib_route_path_t *rpath)
 896 {
 897     /*
 898      * - All zeros next-hop
 899      * - a valid interface
 900      * - entry's fib index not equeal to interface's index
 901      */
 902     if (ip46_address_is_zero(&rpath->frp_addr) &&
 903         (~0 != rpath->frp_sw_if_index) &&
 904         (fib_entry->fe_fib_index !=
 905          fib_table_get_index_for_sw_if_index(fib_entry_get_proto(fib_entry),
 906                                              rpath->frp_sw_if_index)))
 907     {
 908         return (!0);
 909     }
 910     return (0);
 911 }
 912
 913 /*
 914  * fib_route_attached_cross_table
 915  *
 916  * Return true the the route is attached via an interface that
 917  * is not in the same table as the route
 918  */
 919 static inline int
 920 fib_path_is_attached (const fib_route_path_t *rpath)
 921 {
 922     /*
 923      * - All zeros next-hop
 924      * - a valid interface
 925      */
 926     if (ip46_address_is_zero(&rpath->frp_addr) &&
 927         (~0 != rpath->frp_sw_if_index))
 928     {
 929         return (!0);
 930     }
 931     return (0);
 932 }
 933
 934 fib_path_list_flags_t
 935 fib_entry_src_flags_2_path_list_flags (fib_entry_flag_t eflags)
 936 {
 937     fib_path_list_flags_t plf = FIB_PATH_LIST_FLAG_NONE;
 938
 939     if (eflags & FIB_ENTRY_FLAG_DROP)
 940     {
 941         plf |= FIB_PATH_LIST_FLAG_DROP;
 942     }
 943     if (eflags & FIB_ENTRY_FLAG_LOCAL)
 944     {
 945         plf |= FIB_PATH_LIST_FLAG_LOCAL;
 946     }
 947     if (eflags & FIB_ENTRY_FLAG_EXCLUSIVE)
 948     {
 949         plf |= FIB_PATH_LIST_FLAG_EXCLUSIVE;
 950     }
 951
 952     return (plf);
 953 }
 954
 955 static void
 956 fib_entry_flags_update (const fib_entry_t *fib_entry,
 957                         const fib_route_path_t *rpath,
 958                         fib_path_list_flags_t *pl_flags,
 959                         fib_entry_src_t *esrc)
 960 {
 961     /*
 962      * don't allow the addition of a recursive looped path for prefix
 963      * via itself.
 964      */
 965     if (fib_route_recurses_via_self(&fib_entry->fe_prefix, rpath))
 966     {
 967         /*
 968          * force the install of a drop path-list.
 969          * we want the entry to have some path-list, mainly so
 970          * the dodgy path can be rmeoved when the source stops playing
 971          * silly buggers.
 972          */
 973         *pl_flags |= FIB_PATH_LIST_FLAG_DROP;
 974     }
 975     else
 976     {
 977         *pl_flags &= ~FIB_PATH_LIST_FLAG_DROP;
 978     }
 979
 980     if ((esrc->fes_src == FIB_SOURCE_API) ||
 981         (esrc->fes_src == FIB_SOURCE_CLI))
 982     {
 983         if (fib_path_is_attached(rpath))
 984         {
 985             esrc->fes_entry_flags |= FIB_ENTRY_FLAG_ATTACHED;
 986         }
 987         else
 988         {
 989             esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_ATTACHED;
 990         }
 991     }
 992     if (fib_route_attached_cross_table(fib_entry, rpath))
 993     {
 994         esrc->fes_entry_flags |= FIB_ENTRY_FLAG_IMPORT;
 995     }
 996     else
 997     {
 998         esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_IMPORT;
 999     }
1000 }
1001
1002 /*
1003  * fib_entry_src_path_ext_add
1004  *
1005  * append a path extension to the entry's list
1006  */
1007 static void
1008 fib_entry_src_path_ext_append (fib_entry_src_t *esrc,
1009                                const fib_route_path_t *rpath)
1010 {
1011     if (NULL != rpath->frp_label_stack)
1012     {
1013         fib_path_ext_t *path_ext;
1014
1015         vec_add2(esrc->fes_path_exts, path_ext, 1);
1016
1017         fib_path_ext_init(path_ext, esrc->fes_pl, rpath);
1018     }
1019 }
1020
1021 /*
1022  * fib_entry_src_path_ext_insert
1023  *
1024  * insert, sorted, a path extension to the entry's list.
1025  * It's not strictly necessary in sort the path extensions, since each
1026  * extension has the path index to which it resolves. However, by being
1027  * sorted the load-balance produced has a deterministic order, not an order
1028  * based on the sequence of extension additions. this is a considerable benefit.
1029  */
1030 static void
1031 fib_entry_src_path_ext_insert (fib_entry_src_t *esrc,
1032                                const fib_route_path_t *rpath)
1033 {
1034     if (0 == vec_len(esrc->fes_path_exts))
1035         return (fib_entry_src_path_ext_append(esrc, rpath));
1036
1037     if (NULL != rpath->frp_label_stack)
1038     {
1039         fib_path_ext_t path_ext;
1040         int i = 0;
1041
1042         fib_path_ext_init(&path_ext, esrc->fes_pl, rpath);
1043
1044         while (i < vec_len(esrc->fes_path_exts) &&
1045                (fib_path_ext_cmp(&esrc->fes_path_exts[i], rpath) < 0))
1046         {
1047             i++;
1048         }
1049
1050         vec_insert_elts(esrc->fes_path_exts, &path_ext, 1, i);
1051     }
1052 }
1053
1054 /*
1055  * fib_entry_src_action_add
1056  *
1057  * Adding a source can result in a new fib_entry being created, which
1058  * can inturn mean the pool is realloc'd and thus the entry passed as
1059  * an argument it also realloc'd
1060  * @return the entry
1061  */
1062 fib_entry_t*
1063 fib_entry_src_action_path_add (fib_entry_t *fib_entry,
1064                                fib_source_t source,
1065                                fib_entry_flag_t flags,
1066                                const fib_route_path_t *rpath)
1067 {
1068     fib_node_index_t old_path_list, fib_entry_index;
1069     fib_path_list_flags_t pl_flags;
1070     fib_path_ext_t *path_ext;
1071     fib_entry_src_t *esrc;
1072
1073     /*
1074      * save variable so we can recover from a fib_entry realloc.
1075      */
1076     fib_entry_index = fib_entry_get_index(fib_entry);
1077
1078     esrc = fib_entry_src_find(fib_entry, source, NULL);
1079     if (NULL == esrc)
1080     {
1081         fib_entry =
1082             fib_entry_src_action_add(fib_entry,
1083                                      source,
1084                                      flags,
1085                                      drop_dpo_get(
1086                                          fib_proto_to_dpo(
1087                                              fib_entry_get_proto(fib_entry))));
1088         esrc = fib_entry_src_find(fib_entry, source, NULL);
1089     }
1090
1091     /*
1092      * we are no doubt modifying a path-list. If the path-list
1093      * is shared, and hence not modifiable, then the index returned
1094      * will be for a different path-list. This FIB entry to needs
1095      * to maintain its lock appropriately.
1096      */
1097     old_path_list = esrc->fes_pl;
1098
1099     ASSERT(NULL != fib_entry_src_vft[source].fesv_path_add);
1100
1101     pl_flags = fib_entry_src_flags_2_path_list_flags(fib_entry_get_flags_i(fib_entry));
1102     fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1103
1104     fib_entry_src_vft[source].fesv_path_add(esrc, fib_entry, pl_flags, rpath);
1105     fib_entry = fib_entry_get(fib_entry_index);
1106
1107     /*
1108      * re-resolve all the path-extensions with the new path-list
1109      */
1110     vec_foreach(path_ext, esrc->fes_path_exts)
1111     {
1112         fib_path_ext_resolve(path_ext, esrc->fes_pl);
1113     }
1114     /*
1115      * if the path has a label we need to add a path extension
1116      */
1117     fib_entry_src_path_ext_insert(esrc, rpath);
1118
1119     fib_path_list_lock(esrc->fes_pl);
1120     fib_path_list_unlock(old_path_list);
1121
1122     return (fib_entry);
1123 }
1124
1125 /*
1126  * fib_entry_src_action_swap
1127  *
1128  * The source is providing new paths to replace the old ones.
1129  * Adding a source can result in a new fib_entry being created, which
1130  * can inturn mean the pool is realloc'd and thus the entry passed as
1131  * an argument it also realloc'd
1132  * @return the entry
1133  */
1134 fib_entry_t*
1135 fib_entry_src_action_path_swap (fib_entry_t *fib_entry,
1136                                 fib_source_t source,
1137                                 fib_entry_flag_t flags,
1138                                 const fib_route_path_t *rpaths)
1139 {
1140     fib_node_index_t old_path_list, fib_entry_index;
1141     fib_path_list_flags_t pl_flags;
1142     const fib_route_path_t *rpath;
1143     fib_path_ext_t *path_ext;
1144     fib_entry_src_t *esrc;
1145
1146     esrc = fib_entry_src_find(fib_entry, source, NULL);
1147
1148     /*
1149      * save variable so we can recover from a fib_entry realloc.
1150      */
1151     fib_entry_index = fib_entry_get_index(fib_entry);
1152
1153     if (NULL == esrc)
1154     {
1155         fib_entry = fib_entry_src_action_add(fib_entry,
1156                                              source,
1157                                              flags,
1158                                              drop_dpo_get(
1159                                                  fib_proto_to_dpo(
1160                                                      fib_entry_get_proto(fib_entry))));
1161         esrc = fib_entry_src_find(fib_entry, source, NULL);
1162     }
1163
1164     /*
1165      * swapping paths may create a new path-list (or may use an existing shared)
1166      * but we are certainly getting a different one. This FIB entry to needs
1167      * to maintain its lock appropriately.
1168      */
1169     old_path_list = esrc->fes_pl;
1170
1171     ASSERT(NULL != fib_entry_src_vft[source].fesv_path_swap);
1172
1173     pl_flags = fib_entry_src_flags_2_path_list_flags(flags);
1174
1175     vec_foreach(rpath, rpaths)
1176     {
1177         fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1178     }
1179
1180     fib_entry_src_vft[source].fesv_path_swap(esrc,
1181                                              fib_entry,
1182                                              pl_flags,
1183                                              rpaths);
1184
1185     vec_foreach(path_ext, esrc->fes_path_exts)
1186     {
1187         vec_free(path_ext->fpe_label_stack);
1188     }
1189     vec_free(esrc->fes_path_exts);
1190
1191     vec_foreach(rpath, rpaths)
1192     {
1193         fib_entry_src_path_ext_append(esrc, rpath);
1194     }
1195
1196     fib_entry = fib_entry_get(fib_entry_index);
1197
1198     fib_path_list_lock(esrc->fes_pl);
1199     fib_path_list_unlock(old_path_list);
1200
1201     return (fib_entry);
1202 }
1203
1204 fib_entry_src_flag_t
1205 fib_entry_src_action_path_remove (fib_entry_t *fib_entry,
1206                                   fib_source_t source,
1207                                   const fib_route_path_t *rpath)
1208 {
1209     fib_path_list_flags_t pl_flags;
1210     fib_node_index_t old_path_list;
1211     fib_path_ext_t *path_ext;
1212     fib_entry_src_t *esrc;
1213
1214     esrc = fib_entry_src_find(fib_entry, source, NULL);
1215
1216     ASSERT(NULL != esrc);
1217     ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ADDED);
1218
1219     /*
1220      * we no doubt modifying a path-list. If the path-list
1221      * is shared, and hence not modifiable, then the index returned
1222      * will be for a different path-list. This FIB entry to needs
1223      * to maintain its lock appropriately.
1224      */
1225     old_path_list = esrc->fes_pl;
1226
1227     ASSERT(NULL != fib_entry_src_vft[source].fesv_path_remove);
1228
1229     pl_flags = fib_entry_src_flags_2_path_list_flags(fib_entry_get_flags_i(fib_entry));
1230     fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1231
1232     fib_entry_src_vft[source].fesv_path_remove(esrc, pl_flags, rpath);
1233     /*
1234      * find the matching path extension and remove it
1235      */
1236     vec_foreach(path_ext, esrc->fes_path_exts)
1237     {
1238         if (!fib_path_ext_cmp(path_ext, rpath))
1239         {
1240             /*
1241              * delete the element moving the remaining elements down 1 position.
1242              * this preserves the sorted order.
1243              */
1244             vec_free(path_ext->fpe_label_stack);
1245             vec_delete(esrc->fes_path_exts, 1, (path_ext - esrc->fes_path_exts));
1246             break;
1247         }
1248     }
1249     /*
1250      * re-resolve all the path-extensions with the new path-list
1251      */
1252     vec_foreach(path_ext, esrc->fes_path_exts)
1253     {
1254         fib_path_ext_resolve(path_ext, esrc->fes_pl);
1255     }
1256
1257     /*
1258      * lock the new path-list, unlock the old if it had one
1259      */
1260     fib_path_list_unlock(old_path_list);
1261
1262     if (FIB_NODE_INDEX_INVALID != esrc->fes_pl) {
1263         fib_path_list_lock(esrc->fes_pl);
1264         return (FIB_ENTRY_SRC_FLAG_ADDED);
1265     }
1266     else
1267     {
1268         /*
1269          * no more paths left from this source
1270          */
1271         fib_entry_src_action_remove(fib_entry, source);
1272         return (FIB_ENTRY_SRC_FLAG_NONE);
1273     }
1274 }
1275
1276 u8*
1277 fib_entry_src_format (fib_entry_t *fib_entry,
1278                       fib_source_t source,
1279                       u8* s)
1280 {
1281     fib_entry_src_t *esrc;
1282
1283     esrc = fib_entry_src_find(fib_entry, source, NULL);
1284
1285     if (NULL != fib_entry_src_vft[source].fesv_format)
1286     {
1287         return (fib_entry_src_vft[source].fesv_format(esrc, s));
1288     }
1289     return (s);
1290 }
1291
1292 adj_index_t
1293 fib_entry_get_adj_for_source (fib_node_index_t fib_entry_index,
1294                               fib_source_t source)
1295 {
1296     fib_entry_t *fib_entry;
1297     fib_entry_src_t *esrc;
1298
1299     if (FIB_NODE_INDEX_INVALID == fib_entry_index)
1300         return (ADJ_INDEX_INVALID);
1301
1302     fib_entry = fib_entry_get(fib_entry_index);
1303     esrc = fib_entry_src_find(fib_entry, source, NULL);
1304
1305     if (NULL != esrc)
1306     {
1307         if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1308         {
1309             return (fib_path_list_get_adj(
1310                         esrc->fes_pl,
1311                         fib_entry_get_default_chain_type(fib_entry)));
1312         }
1313     }
1314     return (ADJ_INDEX_INVALID);
1315 }
1316
1317 const int
1318 fib_entry_get_dpo_for_source (fib_node_index_t fib_entry_index,
1319                               fib_source_t source,
1320                               dpo_id_t *dpo)
1321 {
1322     fib_entry_t *fib_entry;
1323     fib_entry_src_t *esrc;
1324
1325     if (FIB_NODE_INDEX_INVALID == fib_entry_index)
1326         return (0);
1327
1328     fib_entry = fib_entry_get(fib_entry_index);
1329     esrc = fib_entry_src_find(fib_entry, source, NULL);
1330
1331     if (NULL != esrc)
1332     {
1333         if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1334         {
1335             fib_path_list_contribute_forwarding(
1336                 esrc->fes_pl,
1337                 fib_entry_get_default_chain_type(fib_entry),
1338                 dpo);
1339
1340             return (dpo_id_is_valid(dpo));
1341         }
1342     }
1343     return (0);
1344 }
1345
1346 u32
1347 fib_entry_get_resolving_interface_for_source (fib_node_index_t entry_index,
1348                                               fib_source_t source)
1349 {
1350     fib_entry_t *fib_entry;
1351     fib_entry_src_t *esrc;
1352
1353     fib_entry = fib_entry_get(entry_index);
1354
1355     esrc = fib_entry_src_find(fib_entry, source, NULL);
1356
1357     if (NULL != esrc)
1358     {
1359         if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1360         {
1361             return (fib_path_list_get_resolving_interface(esrc->fes_pl));
1362         }
1363     }
1364     return (~0);
1365 }
1366
1367 fib_entry_flag_t
1368 fib_entry_get_flags_for_source (fib_node_index_t entry_index,
1369                                 fib_source_t source)
1370 {
1371     fib_entry_t *fib_entry;
1372     fib_entry_src_t *esrc;
1373
1374     fib_entry = fib_entry_get(entry_index);
1375
1376     esrc = fib_entry_src_find(fib_entry, source, NULL);
1377
1378     if (NULL != esrc)
1379     {
1380         return (esrc->fes_entry_flags);
1381     }
1382
1383     return (FIB_ENTRY_FLAG_NONE);
1384 }
1385
1386 fib_entry_flag_t
1387 fib_entry_get_flags_i (const fib_entry_t *fib_entry)
1388 {
1389     fib_entry_flag_t flags;
1390
1391     /*
1392      * the vector of sources is deliberately arranged in priority order
1393      */
1394     if (0 == vec_len(fib_entry->fe_srcs))
1395     {
1396         flags = FIB_ENTRY_FLAG_NONE;
1397     }
1398     else
1399     {
1400         fib_entry_src_t *esrc;
1401
1402         esrc = vec_elt_at_index(fib_entry->fe_srcs, 0);
1403         flags = esrc->fes_entry_flags;
1404     }
1405
1406     return (flags);
1407 }
1408
1409 void
1410 fib_entry_set_source_data (fib_node_index_t fib_entry_index,
1411                            fib_source_t source,
1412                            const void *data)
1413 {
1414     fib_entry_t *fib_entry;
1415     fib_entry_src_t *esrc;
1416
1417     fib_entry = fib_entry_get(fib_entry_index);
1418     esrc = fib_entry_src_find(fib_entry, source, NULL);
1419
1420     if (NULL != esrc &&
1421         NULL != fib_entry_src_vft[source].fesv_set_data)
1422     {
1423         fib_entry_src_vft[source].fesv_set_data(esrc, fib_entry, data);
1424     }
1425 }
1426
1427 const void*
1428 fib_entry_get_source_data (fib_node_index_t fib_entry_index,
1429                            fib_source_t source)
1430 {
1431     fib_entry_t *fib_entry;
1432     fib_entry_src_t *esrc;
1433
1434     fib_entry = fib_entry_get(fib_entry_index);
1435     esrc = fib_entry_src_find(fib_entry, source, NULL);
1436
1437     if (NULL != esrc &&
1438         NULL != fib_entry_src_vft[source].fesv_get_data)
1439     {
1440         return (fib_entry_src_vft[source].fesv_get_data(esrc, fib_entry));
1441     }
1442     return (NULL);
1443 }
1444
1445 void
1446 fib_entry_src_module_init (void)
1447 {
1448     fib_entry_src_rr_register();
1449     fib_entry_src_interface_register();
1450     fib_entry_src_default_route_register();
1451     fib_entry_src_special_register();
1452     fib_entry_src_api_register();
1453     fib_entry_src_adj_register();
1454     fib_entry_src_mpls_register();
1455     fib_entry_src_lisp_register();
1456 }