ldp_global.c

Linux平台下

/*
 *  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

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;

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

    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->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);

  g->admin_state = MPLS_ADMIN_ENABLE;

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

  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;

  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_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)
{
  ldp_fec *fp;
  ldp_fec *nfp;
  ldp_if *ifp;
  ldp_if *nifp;
  ldp_addr *ap;
  ldp_addr *nap;
  ldp_nexthop *nhp;
  ldp_nexthop *nnhp;
  ldp_attr *atp;
  ldp_attr *natp;
  ldp_inlabel *inp;
  ldp_inlabel *ninp;
  ldp_outlabel *outp;
  ldp_outlabel *noutp;
  ldp_entity *ep;
  ldp_entity *nep;

  if (g) {
    /* clean up the entities that were configured, sessions and adj should
     * already have been cleaned up when the entity was shutdown
     */
    ep = MPLS_LIST_HEAD(&g->entity);
    while (ep != NULL) {
      nep = MPLS_LIST_NEXT(&g->entity, ep, _global);
      switch (ep->entity_type) {
        case LDP_DIRECT:
          ldp_entity_del_if(g,ep);
          break;
        case LDP_INDIRECT:
          ldp_entity_del_peer(ep);
          break;
        default:
          MPLS_ASSERT(0);
      }
      _ldp_global_del_entity(g, ep);
      ep = nep;
    }

    /* need to properly purge FECs/nexthops/interfaces/addresses */

    fp = MPLS_LIST_HEAD(&g->fec);
    while (fp != NULL) {
      nfp = MPLS_LIST_NEXT(&g->fec, fp, _global);

      nhp = MPLS_LIST_HEAD(&fp->nh_root);
      while (nhp) {
        nnhp = MPLS_LIST_NEXT(&fp->nh_root, nhp, _fec);
	ldp_fec_del_nexthop(g, fp, nhp);
        nhp = nnhp;
      }
      MPLS_REFCNT_RELEASE2(g, fp, ldp_fec_delete);

      fp = nfp;
    }

    ifp = MPLS_LIST_HEAD(&g->iff);
    while (ifp != NULL) {
      nifp = MPLS_LIST_NEXT(&g->iff, ifp, _global);

      ap = MPLS_LIST_HEAD(&ifp->addr_root);
      while (ap != NULL) {
        nap = MPLS_LIST_NEXT(&ifp->addr_root, ap, _if);
	ldp_if_del_addr(g, ifp, ap);
	ap = nap;
      }
      MPLS_REFCNT_RELEASE2(g, ifp, ldp_if_delete);

      ifp = nifp;
    }

    nhp = MPLS_LIST_HEAD(&g->nexthop);
    while (nhp != NULL) {
      LDP_PRINT(g->user_data,"Left over NH: %p type %d ref %d",
        nhp, nhp->info.type, nhp->_refcnt);
      switch(nhp->info.type) {
        case MPLS_NH_IP:
          LDP_PRINT(g->user_data,"    IP %08x addr %p",
	    nhp->info.ip.u.ipv4, nhp->addr);
          break;
        case MPLS_NH_IF:
          LDP_PRINT(g->user_data,"    IF %s handle %p",
	    nhp->info.if_handle->name, nhp->iff);
          break;
        case MPLS_NH_OUTSEGMENT:
          LDP_PRINT(g->user_data,"    OS %p", nhp->outlabel);
          break;
        default:
          LDP_PRINT(g->user_data,"    EMPTY");
          break;
      }
      nnhp = MPLS_LIST_NEXT(&g->nexthop, nhp, _global);
//      _ldp_global_del_nexthop(g, nhp);
      nhp = nnhp;
    }

    ap = MPLS_LIST_HEAD(&g->addr);
    while (ap != NULL) {
      LDP_PRINT(g->user_data, "Left over ADDR: %p address %08x",
	ap, ap->address.u.ipv4);
      nap = MPLS_LIST_NEXT(&g->addr, ap, _global);
//      _ldp_global_del_addr(g, ap);
      ap = nap;
    }

    atp = MPLS_LIST_HEAD(&g->attr);
    while (atp != NULL) {
      LDP_PRINT(g->user_data, "Left over ATTR: %p %d", atp, atp->_refcnt);
      natp = MPLS_LIST_NEXT(&g->attr, atp, _global);
//      _ldp_global_del_attr(g, atp);
      atp = natp;
    }

    inp = MPLS_LIST_HEAD(&g->inlabel);
    while (inp != NULL) {
      LDP_PRINT(g->user_data,"Left over INLABEL: %p %d", inp, inp->_refcnt);
      ninp = MPLS_LIST_NEXT(&g->inlabel, inp, _global);
      inp = ninp;
    }

    outp = MPLS_LIST_HEAD(&g->outlabel);
    while (outp != NULL) {
      LDP_PRINT(g->user_data, "Left over OUTLABEL: %p %d", outp, outp->_refcnt);
      noutp = MPLS_LIST_NEXT(&g->outlabel, outp, _global);
      outp = noutp;
    }

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

    mpls_lock_delete(g->global_lock);
    LDP_PRINT(g->user_data, "global delete");
    mpls_free(g);
  }
  return MPLS_SUCCESS;
}

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