ldp_fec.c

实现了MPLS中的标签分发协议（LDP 3036 )的基本功能

/*
 *  Copyright (C) James R. Leu 2000
 *  [e-mail]
 *
 *  This software is covered under the LGPL, for more
 *  info check out http://www.gnu.org/copyleft/lgpl.html
 */

#include "ldp_struct.h"
#include "ldp_fec.h"
#include "ldp_if.h"
#include "ldp_attr.h"
#include "ldp_addr.h"
#include "ldp_nexthop.h"
#include "ldp_session.h"
#include "ldp_inlabel.h"
#include "ldp_outlabel.h"
#include "ldp_global.h"
#include "ldp_label_mapping.h"
#include "ldp_label_request.h"
#include "ldp_label_abort.h"
#include "ldp_label_rel_with.h"
#include "mpls_assert.h"
#include "mpls_compare.h"
#include "mpls_mm_impl.h"
#include "mpls_tree_impl.h"
#include "mpls_policy_impl.h"
#include "mpls_trace_impl.h"

#if MPLS_USE_LSR
#include "lsr_cfg.h"
#else
#include "mpls_mpls_impl.h"
#endif

static uint32_t _ldp_fec_next_index = 1;

static mpls_return_enum ldp_fec_insert(ldp_global *g, ldp_fec * fec)
{
  mpls_return_enum retval = MPLS_SUCCESS;
  uint32_t key;
  uint8_t len;

  MPLS_ASSERT(g && fec);
  LDP_ENTER(g->user_data, "ldp_fec_insert");

  switch(fec->info.type) {
    case MPLS_FEC_PREFIX:
      key = fec->info.u.prefix.network.u.ipv4;
      len = fec->info.u.prefix.length;
      break;
    case MPLS_FEC_HOST:
      key = fec->info.u.host.u.ipv4;
      len = 32;
      break;
    case MPLS_FEC_L2CC:
      /* they had better insert it into the global list */
      LDP_EXIT(g->user_data, "ldp_fec_insert: l2cc");
      return MPLS_SUCCESS;
    default:
      MPLS_ASSERT(0);
  }

  if (mpls_tree_insert(g->fec_tree, key, len, (void *)fec) != MPLS_SUCCESS) {
    LDP_PRINT(g->user_data, "ldp_fec_insert: error adding fec\n");
    retval = MPLS_FATAL;
  }

  LDP_EXIT(g->user_data, "ldp_fec_insert");
  return retval;
}

static void ldp_fec_remove(ldp_global *g, mpls_fec *fec)
{
  ldp_fec *f = NULL;
  uint32_t key;
  uint8_t len;

  MPLS_ASSERT(g && fec);
  LDP_ENTER(g->user_data, "ldp_fec_remove");

  switch(fec->type) {
    case MPLS_FEC_PREFIX:
      key = fec->u.prefix.network.u.ipv4;
      len = fec->u.prefix.length;
      break;
    case MPLS_FEC_HOST:
      key = fec->u.host.u.ipv4;
      len = 32;
      break;
    case MPLS_FEC_L2CC:
      /* they had better remove it from the global list */
      LDP_EXIT(g->user_data, "ldp_fec_remove");
      return;
    default:
      MPLS_ASSERT(0);
  }

  mpls_tree_remove(g->fec_tree, key, len, (void **)&f);

  MPLS_ASSERT(f);

  LDP_EXIT(g->user_data, "ldp_fec_remove");
}

static uint32_t _ldp_fec_get_next_index()
{
  uint32_t retval = _ldp_fec_next_index;

  _ldp_fec_next_index++;
  if (retval > _ldp_fec_next_index) {
    _ldp_fec_next_index = 1;
  }
  return retval;
}

ldp_fec *ldp_fec_create(ldp_global *g, mpls_fec *f)
{
  ldp_fec *fec = (ldp_fec *) mpls_malloc(sizeof(ldp_fec));

  if (fec != NULL) {
    memset(fec, 0, sizeof(ldp_fec));
    /*
     * note: this is init to 1 for a reason!
     * We're placing it in the global list, so this is our refcnt
     * when this refcnt gets to zero, it will be removed from the
     * global list and deleted
     */
    /*
     * TESTING: jleu 6/7/2004, since I want the FEC to be cleaned up
     * when it no longer has a nexthop, addr, or label, the only things that
     * should increment the ref are those (nh, addr, label etc), not global
     * nor inserting into the tree.  I also added this comment in
     * _ldp_global_add_fec()
    MPLS_REFCNT_INIT(fec, 1);
     */
    MPLS_LIST_ELEM_INIT(fec, _global);
    MPLS_LIST_ELEM_INIT(fec, _inlabel);
    MPLS_LIST_ELEM_INIT(fec, _outlabel);
    MPLS_LIST_ELEM_INIT(fec, _fec);
    MPLS_LIST_INIT(&fec->nh_root, ldp_nexthop);
    MPLS_LIST_INIT(&fec->fs_root_us, ldp_fs);
    MPLS_LIST_INIT(&fec->fs_root_ds, ldp_fs);
    fec->index = _ldp_fec_get_next_index();
    mpls_fec2ldp_fec(f,fec);

    _ldp_global_add_fec(g, fec);
    ldp_fec_insert(g, fec);
  }
  return fec;
}

void ldp_fec_delete(ldp_global *g, ldp_fec * fec)
{
  fprintf(stderr, "fec delete: %08x/%d\n", fec->info.u.prefix.network.u.ipv4,
    fec->info.u.prefix.length);
  ldp_fec_remove(g, &fec->info);
  _ldp_global_del_fec(g, fec);
  mpls_free(fec);
}

ldp_fec *ldp_fec_find(ldp_global *g, mpls_fec *fec)
{
  ldp_fec *f = NULL;
  uint32_t key;
  uint8_t len;

  switch(fec->type) {
    case MPLS_FEC_PREFIX:
      key = fec->u.prefix.network.u.ipv4;
      len = fec->u.prefix.length;
      break;
    case MPLS_FEC_HOST:
      key = fec->u.host.u.ipv4;
      len = 32;
      break;
    case MPLS_FEC_L2CC:
      if (ldp_global_find_fec(g, fec, &f) == MPLS_SUCCESS) {
	return f;
      }
      return NULL;
    default:
      MPLS_ASSERT(0);
  }

  if (mpls_tree_get(g->fec_tree, key, len, (void **)&f) != MPLS_SUCCESS) {
    return NULL;
  }
  return f;
}

ldp_fec *ldp_fec_find2(ldp_global *g, mpls_fec *fec)
{
  ldp_fec *f = NULL;
  f = ldp_fec_find(g, fec);
  if (!f) {
    f = ldp_fec_create(g, fec);
  }
  return f;
}

ldp_nexthop *ldp_fec_nexthop_find(ldp_fec *f, mpls_nexthop *n)
{
  ldp_nexthop *nh = NULL;

  MPLS_ASSERT(f && n);

  nh = MPLS_LIST_HEAD(&f->nh_root);
  while (nh) {
    if (!mpls_nexthop_compare(&nh->info, n)) {
      return nh;
    }
    nh = MPLS_LIST_NEXT(&f->nh_root, nh, _fec);
  }

  return NULL;
}

mpls_return_enum ldp_fec_find_nexthop_index(ldp_fec *f, int index,
  ldp_nexthop **n)
{
  ldp_nexthop *nh = NULL;

  MPLS_ASSERT(f);

  if (index > 0) {

    /* because we sort our inserts by index, this lets us know
       if we've "walked" past the end of the list */

    nh = MPLS_LIST_TAIL(&f->nh_root);
    if (!nh || nh->index < index) {
      *n = NULL;
      return MPLS_END_OF_LIST;
    }

    nh = MPLS_LIST_HEAD(&f->nh_root);
    do {
      if (nh->index == index) {
        *n = nh;
        return MPLS_SUCCESS;
      }
    } while((nh = MPLS_LIST_NEXT(&f->nh_root, nh, _fec)));
  }
  *n = NULL;
  return MPLS_FAILURE;
}

mpls_return_enum ldp_fec_add_nexthop(ldp_global *g, ldp_fec * f,
  ldp_nexthop * nh)
{
  MPLS_ASSERT(f && nh);

  MPLS_REFCNT_HOLD(nh);
  MPLS_LIST_ADD_HEAD(&f->nh_root, nh, _fec, ldp_nexthop);

  ldp_nexthop_add_fec(nh, f);

  if (nh->info.type & MPLS_NH_IP) {
    ldp_addr *addr = NULL;
    if (!(addr = ldp_addr_find(g, &nh->info.ip))) {
      if (!(addr = ldp_addr_insert(g, &nh->info.ip))) {
        goto ldp_fec_add_nexthop_error;
      }
    }

    ldp_addr_add_nexthop(addr, nh);
  }

  if (nh->info.type & MPLS_NH_IF) {
    ldp_if *iff = NULL;
    if ((iff = ldp_global_find_if_handle(g, nh->info.if_handle))) {
      ldp_if_add_nexthop(iff, nh);
    }
  }

  if (nh->info.type & MPLS_NH_OUTSEGMENT) {
    ldp_outlabel *out = NULL;
    MPLS_ASSERT((out = ldp_global_find_outlabel_handle(g,
      nh->info.outsegment_handle)));

    ldp_outlabel_add_nexthop(out, nh);
  }
  return MPLS_SUCCESS;

ldp_fec_add_nexthop_error:

  ldp_fec_del_nexthop(g, f, nh);
  return MPLS_FATAL;
}

void ldp_fec_del_nexthop(ldp_global *g, ldp_fec * f, ldp_nexthop *nh)
{
  MPLS_ASSERT(f && nh);

  if (nh->addr) {
    ldp_addr_del_nexthop(g, nh->addr, nh);
  }
  if (nh->iff) {
    ldp_if_del_nexthop(g, nh->iff, nh);
  }
  if (nh->outlabel) {
    ldp_outlabel_del_nexthop(g, nh->outlabel, nh);
  }

  MPLS_LIST_REMOVE(&f->nh_root, nh, _fec);
  ldp_nexthop_del_fec(g, nh);