ldp_global.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 <stdlib.h>
#include <netinet/in.h>
#include "ldp_struct.h"
#include "ldp_inet_addr.h"
#include "ldp_session.h"
#include "ldp_entity.h"
#include "ldp_global.h"
#include "ldp_nexthop.h"
#include "ldp_outlabel.h"
#include "ldp_inlabel.h"
#include "ldp_hello.h"
#include "ldp_peer.h"
#include "ldp_attr.h"
#include "ldp_addr.h"
#include "ldp_adj.h"
#include "ldp_fec.h"
#include "ldp_if.h"
#include "ldp_label_mapping.h"
#include "ldp_tunnel.h"
#include "ldp_resource.h"
#include "ldp_hop_list.h"

#include "mpls_compare.h"

#include "mpls_socket_impl.h"
#include "mpls_timer_impl.h"
#include "mpls_ifmgr_impl.h"
#include "mpls_tree_impl.h"
#include "mpls_lock_impl.h"
#include "mpls_fib_impl.h"
#include "mpls_policy_impl.h"
#include "mpls_mm_impl.h"
#include "mpls_trace_impl.h"

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

void _ldp_global_ifmgr_callback(mpls_cfg_handle handle, const mpls_update_enum type, mpls_inet_addr *addr)
{
  ldp_session *s = NULL;
  ldp_global *cfg = (ldp_global*)handle;

  LDP_ENTER(cfg->user_data, "_ldp_global_ifmgr_callback");

  mpls_lock_get(cfg->global_lock);

  if (mpls_policy_address_export_check(cfg->user_data, addr) == MPLS_BOOL_TRUE) {
    s = MPLS_LIST_HEAD(&cfg->session);
    while (s != NULL) {
      switch (type) {
        case MPLS_UPDATE_ADD:
          LDP_TRACE_LOG(cfg->user_data, MPLS_TRACE_STATE_ALL,
            LDP_TRACE_FLAG_EVENT, "ADD\n");
          ldp_addr_send(cfg, s, addr);
          break;
        case MPLS_UPDATE_DEL:
          LDP_TRACE_LOG(cfg->user_data, MPLS_TRACE_STATE_ALL,
            LDP_TRACE_FLAG_EVENT, "DEL\n");
          ldp_waddr_send(cfg, s, addr);
          break;
        default:
          MPLS_ASSERT(0);
      }
      s = MPLS_LIST_NEXT(&cfg->session, s, _global);
    }
  }

  mpls_lock_release(cfg->global_lock);

  LDP_EXIT(cfg->user_data, "_ldp_global_ifmgr_callback");
}

ldp_global *ldp_global_create(mpls_instance_handle data)
{
  ldp_global *g = (ldp_global *) mpls_malloc(sizeof(ldp_global));

  if (g) {
    memset(g, 0, sizeof(ldp_global));

    LDP_ENTER(g->user_data, "ldp_global_create");

    g->global_lock = mpls_lock_create("_ldp_global_lock_");
    mpls_lock_get(g->global_lock);

    MPLS_LIST_INIT(&g->hop_list, ldp_hop_list);
    MPLS_LIST_INIT(&g->outlabel, ldp_outlabel);
    MPLS_LIST_INIT(&g->resource, ldp_resource);
    MPLS_LIST_INIT(&g->inlabel, ldp_inlabel);
    MPLS_LIST_INIT(&g->session, ldp_session);
    MPLS_LIST_INIT(&g->nexthop, ldp_nexthop);
    MPLS_LIST_INIT(&g->tunnel, ldp_tunnel);
    MPLS_LIST_INIT(&g->entity, ldp_entity);
    MPLS_LIST_INIT(&g->addr, ldp_addr);
    MPLS_LIST_INIT(&g->attr, ldp_attr);
    MPLS_LIST_INIT(&g->peer, ldp_peer);
    MPLS_LIST_INIT(&g->fec, ldp_fec);
    MPLS_LIST_INIT(&g->adj, ldp_adj);
    MPLS_LIST_INIT(&g->iff, ldp_if);

    g->message_identifier = 1;
    g->configuration_sequence_number = 1;
    g->lsp_control_mode = LDP_GLOBAL_DEF_CONTROL_MODE;
    g->label_retention_mode = LDP_GLOBAL_DEF_RETENTION_MODE;
    g->lsp_repair_mode = LDP_GLOBAL_DEF_REPAIR_MODE;
    g->propagate_release = LDP_GLOBAL_DEF_PROPOGATE_RELEASE;
    g->label_merge = LDP_GLOBAL_DEF_LABEL_MERGE;
    g->loop_detection_mode = LDP_GLOBAL_DEF_LOOP_DETECTION_MODE;
    g->ttl_less_domain = LDP_GLOBAL_DEF_TTLLESS_DOMAIN;
    g->local_tcp_port = LDP_GLOBAL_DEF_LOCAL_TCP_PORT;
    g->local_udp_port = LDP_GLOBAL_DEF_LOCAL_UDP_PORT;
    g->send_address_messages = LDP_GLOBAL_DEF_SEND_ADDR_MSG;
    g->backoff_step = LDP_GLOBAL_DEF_BACKOFF_STEP;
    g->send_lsrid_mapping = LDP_GLOBAL_DEF_SEND_LSRID_MAPPING;
    g->no_route_to_peer_time = LDP_GLOBAL_DEF_NO_ROUTE_RETRY_TIME;

    g->keepalive_timer = LDP_ENTITY_DEF_KEEPALIVE_TIMER;
    g->keepalive_interval = LDP_ENTITY_DEF_KEEPALIVE_INTERVAL;
    g->hellotime_timer = LDP_ENTITY_DEF_HELLOTIME_TIMER;
    g->hellotime_interval = LDP_ENTITY_DEF_HELLOTIME_INTERVAL;

    g->admin_state = MPLS_ADMIN_DISABLE;
    g->user_data = data;

    mpls_lock_release(g->global_lock);

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

  return g;
}

mpls_return_enum ldp_global_startup(ldp_global * g)
{
  ldp_entity *e = NULL;
  mpls_dest dest;

  MPLS_ASSERT(g != NULL);

  LDP_ENTER(g->user_data, "ldp_global_startup");

  if (g->lsr_identifier.type == MPLS_FAMILY_NONE) {
    LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_ERROR,
      "ldp_global_startup: invalid LSRID\n");
    goto ldp_global_startup_cleanup;
  }

  g->timer_handle = mpls_timer_open(g->user_data);
  if (mpls_timer_mgr_handle_verify(g->timer_handle) == MPLS_BOOL_FALSE) {
    goto ldp_global_startup_cleanup;
  }

  g->socket_handle = mpls_socket_mgr_open(g->user_data);
  if (mpls_socket_mgr_handle_verify(g->socket_handle) == MPLS_BOOL_FALSE) {
    goto ldp_global_startup_cleanup;
  }

  g->ifmgr_handle = mpls_ifmgr_open(g->user_data, g);
  if (mpls_ifmgr_handle_verify(g->ifmgr_handle) == MPLS_BOOL_FALSE) {
    goto ldp_global_startup_cleanup;
  }

  g->fib_handle = mpls_fib_open(g->user_data, g);
  if (mpls_fib_handle_verify(g->fib_handle) == MPLS_BOOL_FALSE) {
    goto ldp_global_startup_cleanup;
  }

#if MPLS_USE_LSR
  if (!g->lsr_handle) {
    goto ldp_global_startup_cleanup;
  }
#else
  g->mpls_handle = mpls_mpls_open(g->user_data);
  if (mpls_mpls_handle_verify(g->mpls_handle) == MPLS_BOOL_FALSE) {
    goto ldp_global_startup_cleanup;
  }
#endif

  g->addr_tree = mpls_tree_create(32);
  g->fec_tree = mpls_tree_create(32);

  g->hello_socket = mpls_socket_create_udp(g->socket_handle);
  if (mpls_socket_handle_verify(g->socket_handle, g->hello_socket) == MPLS_BOOL_FALSE) {
    LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_DEBUG,
      "ldp_global_startup: error creating UDP socket\n");
    goto ldp_global_startup_cleanup;
  }

  dest.addr.type = MPLS_FAMILY_IPV4;
  dest.port = g->local_udp_port;
  dest.addr.u.ipv4 = INADDR_ANY;
  // dest.addr.u.ipv4 = INADDR_ALLRTRS_GROUP;

  if (mpls_socket_bind(g->socket_handle, g->hello_socket, &dest) == MPLS_FAILURE) {
    LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_DEBUG,
      "ldp_global_startup: error binding UDP socket\n");
    goto ldp_global_startup_cleanup;
  }

  if (mpls_socket_options(g->socket_handle, g->hello_socket,
      MPLS_SOCKOP_NONBLOCK | MPLS_SOCKOP_REUSE) == MPLS_FAILURE) {
    LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_DEBUG,
      "ldp_global_startup: error setting UDP socket options\n");
    goto ldp_global_startup_cleanup;
  }
  if (mpls_socket_multicast_options(g->socket_handle, g->hello_socket, 1, 0) ==
    MPLS_FAILURE) {
    LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_DEBUG,
      "ldp_global_startup: error setting UDP socket multicast options\n");
    goto ldp_global_startup_cleanup;
  }
  mpls_socket_readlist_add(g->socket_handle, g->hello_socket, 0, MPLS_SOCKET_UDP_DATA);

  g->listen_socket = mpls_socket_create_tcp(g->socket_handle);
  if (mpls_socket_handle_verify(g->socket_handle, g->listen_socket) == MPLS_BOOL_FALSE) {
    LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_DEBUG,
      "ldp_global_startup: error creating TCP socket\n");
    goto ldp_global_startup_cleanup;
  }
  if (mpls_socket_options(g->socket_handle, g->listen_socket,
      MPLS_SOCKOP_NONBLOCK | MPLS_SOCKOP_REUSE) == MPLS_FAILURE) {
    LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_DEBUG,
      "ldp_global_startup: error setting TCP socket options\n");
    goto ldp_global_startup_cleanup;
  }

  dest.addr.type = MPLS_FAMILY_IPV4;
  dest.port = g->local_tcp_port;
  dest.addr.u.ipv4 = INADDR_ANY;

  if (mpls_socket_bind(g->socket_handle, g->listen_socket, &dest) == MPLS_FAILURE) {
    LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_DEBUG,
      "ldp_global_startup: error binding TCP socket\n");
    goto ldp_global_startup_cleanup;
  }

  if (mpls_socket_tcp_listen(g->socket_handle, g->listen_socket, 15) ==
    MPLS_FAILURE) {
    LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_DEBUG,
      "ldp_global_startup: error setting listen buffer for TCP socket\n");
    goto ldp_global_startup_cleanup;
  }

  mpls_socket_readlist_add(g->socket_handle, g->listen_socket, 0,
    MPLS_SOCKET_TCP_LISTEN);

#if 0
  {
    mpls_if_handle iff;
    mpls_inet_addr addr;
    mpls_return_enum retval;

    retval = mpls_ifmgr_getfirst_address(g->ifmgr_handle, &iff, &addr);
    if (retval == MPLS_FATAL) {
      goto ldp_global_startup_cleanup;
    }
    if (retval == MPLS_SUCCESS) {
      do {
	ldp_addr *a;
	ldp_if *i;
	if (!(a = ldp_addr_create(g, &addr))) {
          goto ldp_global_startup_cleanup;
	}
	a->if_handle = iff;
	if ((i = ldp_global_find_if_handle(g, iff))) {
	  ldp_if_add_addr(i, a);
	}
      } while (mpls_ifmgr_getnext_address(g->ifmgr_handle, &iff, &addr) ==
        MPLS_SUCCESS);
    }
  }
  {
    mpls_fec fec;
    mpls_nexthop nexthop;
    mpls_return_enum retval;

    retval = mpls_fib_getfirst_route(g->fib_handle, &fec, &nexthop);
    if (retval == MPLS_FATAL) {
      goto ldp_global_startup_cleanup;
    }
    if (retval == MPLS_SUCCESS) {
      do {
	ldp_nexthop *n;
	ldp_fec *f;

	if (!(f = ldp_fec_find(g, &fec))) {
	    f = ldp_fec_create(g, &fec);
	    if (!f) {
              goto ldp_global_startup_cleanup;
	    }
	}

        n = ldp_nexthop_create();
	if (!n) {
          goto ldp_global_startup_cleanup;
	}

	memcpy(&n->info, &nexthop, sizeof(mpls_nexthop));
	if (ldp_fec_add_nexthop(g, f, n) != MPLS_SUCCESS) {
          goto ldp_global_startup_cleanup;
	}
	_ldp_global_add_nexthop(g, n);
      } while (mpls_fib_getnext_route(g->fib_handle, &fec, &nexthop) ==
        MPLS_SUCCESS);
    }
  }
#endif

  e = MPLS_LIST_HEAD(&g->entity);
  while (e != NULL) {
    ldp_entity_startup(g, e);
    e = MPLS_LIST_NEXT(&g->entity, e, _global);
  }

  g->admin_state = MPLS_ADMIN_ENABLE;

  LDP_EXIT(g->user_data, "ldp_global_startup");
  return MPLS_SUCCESS;

ldp_global_startup_cleanup:
  ldp_global_shutdown(g);
  mpls_socket_close(g->socket_handle, g->hello_socket);
  mpls_socket_close(g->socket_handle, g->listen_socket);
  g->hello_socket = 0;
  g->listen_socket = 0;

  LDP_EXIT(g->user_data, "ldp_global_startup-error");

  return MPLS_FAILURE;
}

mpls_return_enum ldp_global_shutdown(ldp_global * g)
{
  ldp_entity *e = NULL;
  ldp_nexthop *n;
  ldp_fec *f;
  ldp_addr *a;
  ldp_if *i;

  MPLS_ASSERT(g);

  LDP_ENTER(g->user_data, "ldp_global_shutdown");

  e = MPLS_LIST_HEAD(&g->entity);
  while (e != NULL) {
    ldp_entity_shutdown(g, e, 1);
    e = MPLS_LIST_NEXT(&g->entity, e, _global);
  }

  g->admin_state = MPLS_ADMIN_DISABLE;

  while ((f = MPLS_LIST_HEAD(&g->fec))) {
    while ((n = MPLS_LIST_HEAD(&f->nh_root))) {
      ldp_fec_del_nexthop(g, f, n);
    }
    MPLS_REFCNT_RELEASE2(g, f, ldp_fec_delete);
  }

  while ((i = MPLS_LIST_HEAD(&g->iff))) {
    while ((a = MPLS_LIST_HEAD(&i->addr_root))) {
      ldp_if_del_addr(g, i, a);
    }
    MPLS_REFCNT_RELEASE2(g, i, ldp_if_delete);
  }

  mpls_socket_readlist_del(g->socket_handle, g->hello_socket);
  mpls_socket_close(g->socket_handle, g->hello_socket);

  mpls_socket_readlist_del(g->socket_handle, g->listen_socket);
  mpls_socket_close(g->socket_handle, g->listen_socket);

  mpls_tree_delete(g->addr_tree);
  mpls_tree_delete(g->fec_tree);

  mpls_lock_release(g->global_lock);
  mpls_timer_close(g->timer_handle);
  mpls_lock_get(g->global_lock);

  mpls_socket_mgr_close(g->socket_handle);
  mpls_ifmgr_close(g->ifmgr_handle);
  mpls_fib_close(g->fib_handle);

#if MPLS_USE_LSR
#else
  mpls_mpls_close(g->mpls_handle);
#endif

  LDP_EXIT(g->user_data, "ldp_global_shutdown");

  return MPLS_SUCCESS;
}

mpls_return_enum ldp_global_delete(ldp_global * g)
{
  if (g) {
    mpls_lock_delete(g->global_lock);
    LDP_PRINT(g->user_data, "global delete\n");
    mpls_free(g);
  }
  return MPLS_SUCCESS;
}

void _ldp_global_add_attr(ldp_global * g, ldp_attr * a)
{
  ldp_attr *ap = NULL;

  MPLS_ASSERT(g && a);
  MPLS_REFCNT_HOLD(a);
  ap = MPLS_LIST_HEAD(&g->attr);
  while (ap != NULL) {
    if (ap->index > a->index) {
      MPLS_LIST_INSERT_BEFORE(&g->attr, ap, a, _global);
      return;
    }
    ap = MPLS_LIST_NEXT(&g->attr, ap, _global);
  }
  MPLS_LIST_ADD_TAIL(&g->attr, a, _global, ldp_attr);
}