ldp_cfg.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_cfg.h"
#include "ldp_global.h"
#include "ldp_entity.h"
#include "ldp_attr.h"
#include "ldp_if.h"
#include "ldp_peer.h"
#include "ldp_fec.h"
#include "ldp_addr.h"
#include "ldp_nexthop.h"
#include "ldp_tunnel.h"
#include "ldp_resource.h"
#include "mpls_ifmgr_impl.h"
#include "ldp_label_mapping.h"
#include "ldp_hop.h"
#include "ldp_hop_list.h"
#include "mpls_lock_impl.h"
#include "mpls_trace_impl.h"
#include "mpls_tree_impl.h"

mpls_cfg_handle ldp_cfg_open(mpls_instance_handle data)
{
  ldp_global *g = ldp_global_create(data);

  LDP_ENTER(data, "ldp_cfg_open");
  LDP_EXIT(data, "ldp_cfg_open");

  return (mpls_cfg_handle) g;
}

void ldp_cfg_close(mpls_cfg_handle g)
{
  LDP_ENTER((mpls_instance_handle) g->user_data, "ldp_cfg_close");
  ldp_global_delete(g);
  LDP_EXIT((mpls_instance_handle) g->user_data, "ldp_cfg_close");
}

/******************* GLOBAL **********************/

void ldp_cfg_global_attr(mpls_cfg_handle handle) {
  ldp_global *global = (ldp_global *) handle;
  ldp_attr *attr = MPLS_LIST_HEAD(&global->attr);
  while (attr) {
    if (attr->state == LDP_LSP_STATE_MAP_SENT && attr->ds_attr) {
      fprintf(stderr, "%p(%s) xc to %p(%s)\n", attr,
        attr->session->session_name, attr->ds_attr,
        attr->ds_attr->session->session_name);
    }
    attr = MPLS_LIST_NEXT(&global->attr, attr, _global);
  }
}

mpls_return_enum ldp_cfg_global_get(mpls_cfg_handle handle, ldp_global * g,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;

  MPLS_ASSERT(global !=NULL);

  LDP_ENTER(global->user_data, "ldp_cfg_global_get");

  mpls_lock_get(global->global_lock); /* LOCK */

  if (flag & LDP_GLOBAL_CFG_LSR_IDENTIFIER) {
    memcpy(&(g->lsr_identifier), &(global->lsr_identifier),
      sizeof(mpls_inet_addr));
  }
  if (flag & LDP_GLOBAL_CFG_ADMIN_STATE) {
    g->admin_state = global->admin_state;
  }
  if (flag & LDP_GLOBAL_CFG_CONTROL_MODE) {
    g->lsp_control_mode = global->lsp_control_mode;
  }
  if (flag & LDP_GLOBAL_CFG_RETENTION_MODE) {
    g->label_retention_mode = global->label_retention_mode;
  }
  if (flag & LDP_GLOBAL_CFG_REPAIR_MODE) {
    g->lsp_repair_mode = global->lsp_repair_mode;
  }
  if (flag & LDP_GLOBAL_CFG_PROPOGATE_RELEASE) {
    g->propagate_release = global->propagate_release;
  }
  if (flag & LDP_GLOBAL_CFG_LABEL_MERGE) {
    g->label_merge = global->label_merge;
  }
  if (flag & LDP_GLOBAL_CFG_LOOP_DETECTION_MODE) {
    g->loop_detection_mode = global->loop_detection_mode;
  }
  if (flag & LDP_GLOBAL_CFG_TTLLESS_DOMAIN) {
    g->ttl_less_domain = global->ttl_less_domain;
  }
  if (flag & LDP_GLOBAL_CFG_LOCAL_TCP_PORT) {
    g->local_tcp_port = global->local_tcp_port;
  }
  if (flag & LDP_GLOBAL_CFG_LOCAL_UDP_PORT) {
    g->local_udp_port = global->local_udp_port;
  }
  if (flag & LDP_GLOBAL_CFG_TRANS_ADDR) {
    memcpy(&(g->transport_address), &(global->transport_address),
      sizeof(mpls_inet_addr));
  }
  if (flag & LDP_GLOBAL_CFG_KEEPALIVE_TIMER) {
    g->keepalive_timer = global->keepalive_timer;
  }
  if (flag & LDP_GLOBAL_CFG_KEEPALIVE_INTERVAL) {
    g->keepalive_interval = global->keepalive_interval;
  }
  if (flag & LDP_GLOBAL_CFG_HELLOTIME_TIMER) {
    g->hellotime_timer = global->hellotime_timer;
  }
  if (flag & LDP_GLOBAL_CFG_HELLOTIME_INTERVAL) {
    g->hellotime_interval = global->hellotime_interval;
  }
#if MPLS_USE_LSR
  if (flag & LDP_GLOBAL_CFG_LSR_HANDLE) {
    g->lsr_handle = global->lsr_handle;
  }
#endif

  mpls_lock_release(global->global_lock); /* UNLOCK */

  LDP_EXIT(global->user_data, "ldp_cfg_global_get");

  return MPLS_SUCCESS;
}

mpls_return_enum ldp_cfg_global_test(mpls_cfg_handle handle, ldp_global * g,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  mpls_return_enum retval = MPLS_SUCCESS;

  MPLS_ASSERT(global !=NULL);

  LDP_ENTER(global->user_data, "ldp_cfg_global_test");

  mpls_lock_get(global->global_lock); /* LOCK */

  if (global->admin_state == MPLS_ADMIN_ENABLE && (flag & LDP_GLOBAL_CFG_WHEN_DOWN))
    retval = MPLS_FAILURE;

  mpls_lock_release(global->global_lock); /* UNLOCK */

  LDP_EXIT(global->user_data, "ldp_cfg_global_test");

  return retval;
}

mpls_return_enum ldp_cfg_global_set(mpls_cfg_handle handle, ldp_global * g,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  mpls_return_enum retval = MPLS_FAILURE;

  MPLS_ASSERT(global !=NULL);

  LDP_ENTER(global->user_data, "ldp_cfg_global_set");

  mpls_lock_get(global->global_lock); /* LOCK */

  if ((global->admin_state == MPLS_ADMIN_ENABLE && (flag & LDP_GLOBAL_CFG_WHEN_DOWN)))
    goto ldp_cfg_global_set_end;

  if (flag & LDP_GLOBAL_CFG_CONTROL_MODE) {
    global->lsp_control_mode = g->lsp_control_mode;
  }
  if (flag & LDP_GLOBAL_CFG_RETENTION_MODE) {
    global->label_retention_mode = g->label_retention_mode;
  }
  if (flag & LDP_GLOBAL_CFG_REPAIR_MODE) {
    global->lsp_repair_mode = g->lsp_repair_mode;
  }
  if (flag & LDP_GLOBAL_CFG_PROPOGATE_RELEASE) {
    global->propagate_release = g->propagate_release;
  }
  if (flag & LDP_GLOBAL_CFG_LABEL_MERGE) {
    global->label_merge = g->label_merge;
  }
  if (flag & LDP_GLOBAL_CFG_LOOP_DETECTION_MODE) {
    global->loop_detection_mode = g->loop_detection_mode;
  }
  if (flag & LDP_GLOBAL_CFG_TTLLESS_DOMAIN) {
    global->ttl_less_domain = g->ttl_less_domain;
  }
  if (flag & LDP_GLOBAL_CFG_LOCAL_TCP_PORT) {
    global->local_tcp_port = g->local_tcp_port;
  }
  if (flag & LDP_GLOBAL_CFG_LOCAL_UDP_PORT) {
    global->local_udp_port = g->local_udp_port;
  }
  if (flag & LDP_GLOBAL_CFG_LSR_IDENTIFIER) {
    memcpy(&(global->lsr_identifier), &(g->lsr_identifier),
      sizeof(mpls_inet_addr));
  }
#if MPLS_USE_LSR
  if (flag & LDP_GLOBAL_CFG_LSR_HANDLE) {
    global->lsr_handle = g->lsr_handle;
  }
#endif
  if (flag & LDP_GLOBAL_CFG_ADMIN_STATE) {
    if (global->admin_state == MPLS_ADMIN_ENABLE && g->admin_state == MPLS_ADMIN_DISABLE) {
      ldp_global_shutdown(global);
    } else if (global->admin_state == MPLS_ADMIN_DISABLE && g->admin_state ==
      MPLS_ADMIN_ENABLE) {
      ldp_global_startup(global);
    }
  }
  if (flag & LDP_GLOBAL_CFG_TRANS_ADDR) {
    memcpy(&(global->transport_address), &(g->transport_address),
      sizeof(mpls_inet_addr));
  }
  if (flag & LDP_GLOBAL_CFG_KEEPALIVE_TIMER) {
    if (g->keepalive_timer == 0) {
      global->keepalive_timer = LDP_ENTITY_DEF_KEEPALIVE_TIMER;
    } else {
      global->keepalive_timer = g->keepalive_timer;
    }
  }
  if (flag & LDP_GLOBAL_CFG_KEEPALIVE_INTERVAL) {
    if (g->keepalive_interval == 0) {
      global->keepalive_interval = LDP_ENTITY_DEF_KEEPALIVE_INTERVAL;
    } else {
      global->keepalive_interval = g->keepalive_interval;
    }
  }
  if (flag & LDP_GLOBAL_CFG_HELLOTIME_TIMER) {
    if (g->hellotime_timer == 0) {
      global->hellotime_timer = LDP_ENTITY_DEF_HELLOTIME_TIMER;
    } else {
      global->hellotime_timer = g->hellotime_timer;
    }
  }
  if (flag & LDP_GLOBAL_CFG_HELLOTIME_INTERVAL) {
    if (g->hellotime_interval == 0) {
      global->hellotime_interval = LDP_ENTITY_DEF_HELLOTIME_INTERVAL;
    } else {
      global->hellotime_interval = g->hellotime_interval;
    }
  }
#if MPLS_USE_LSR
  if (flag & LDP_GLOBAL_CFG_LSR_HANDLE) {
    global->lsr_handle = g->lsr_handle ;
  }
#endif
  global->configuration_sequence_number++;

  retval = MPLS_SUCCESS;

ldp_cfg_global_set_end:

  mpls_lock_release(global->global_lock); /* UNLOCK */

  LDP_EXIT(global->user_data, "ldp_cfg_global_set");

  return retval;
}

/******************* ENTITY **********************/

/* must set ldp_entity->index */
mpls_return_enum ldp_cfg_entity_get(mpls_cfg_handle handle, ldp_entity * e,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_entity *entity = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

  MPLS_ASSERT(global !=NULL && e != NULL);

  LDP_ENTER(global->user_data, "ldp_cfg_entity_get");

  mpls_lock_get(global->global_lock); /* LOCK */

  if (ldp_global_find_entity_index(global, e->index, &entity) != MPLS_SUCCESS)
      goto ldp_cfg_entity_get_end;

  if (flag & LDP_ENTITY_CFG_ADMIN_STATE) {
    e->admin_state = entity->admin_state;
  }
  if (flag & LDP_ENTITY_CFG_TRANS_ADDR) {
    e->transport_address = entity->transport_address;
  }
  if (flag & LDP_ENTITY_CFG_PROTO_VER) {
    e->protocol_version = entity->protocol_version;
  }
  if (flag & LDP_ENTITY_CFG_REMOTE_TCP) {
    e->remote_tcp_port = entity->remote_tcp_port;
  }
  if (flag & LDP_ENTITY_CFG_REMOTE_UDP) {
    e->remote_udp_port = entity->remote_udp_port;
  }
  if (flag & LDP_ENTITY_CFG_MAX_PDU) {
    e->max_pdu = entity->max_pdu;
  }
  if (flag & LDP_ENTITY_CFG_KEEPALIVE_TIMER) {
    e->keepalive_timer = entity->keepalive_timer;
  }
  if (flag & LDP_ENTITY_CFG_KEEPALIVE_INTERVAL) {
    e->keepalive_interval = entity->keepalive_interval;
  }
  if (flag & LDP_ENTITY_CFG_HELLOTIME_TIMER) {
    e->hellotime_timer = entity->hellotime_timer;
  }
  if (flag & LDP_ENTITY_CFG_HELLOTIME_INTERVAL) {
    e->hellotime_interval = entity->hellotime_interval;
  }
  if (flag & LDP_ENTITY_CFG_SESSION_SETUP_COUNT) {
    e->session_setup_count = entity->session_setup_count;
  }
  if (flag & LDP_ENTITY_CFG_SESSION_BACKOFF_TIMER) {
    e->session_backoff_timer = entity->session_backoff_timer;
  }
  if (flag & LDP_ENTITY_CFG_DISTRIBUTION_MODE) {
    e->label_distribution_mode = entity->label_distribution_mode;
  }
  if (flag & LDP_ENTITY_CFG_PATHVECTOR_LIMIT) {
    e->path_vector_limit = entity->path_vector_limit;
  }
  if (flag & LDP_ENTITY_CFG_HOPCOUNT_LIMIT) {
    e->hop_count_limit = entity->hop_count_limit;
  }
  if (flag & LDP_ENTITY_CFG_REQUEST_COUNT) {
    e->label_request_count = entity->label_request_count;
  }
  if (flag & LDP_ENTITY_CFG_REQUEST_TIMER) {
    e->label_request_timer = entity->label_request_timer;
  }
  if (flag & LDP_ENTITY_CFG_TYPE) {
    e->entity_type = entity->entity_type;
  }
  if (flag & LDP_ENTITY_CFG_SUB_INDEX) {
    e->sub_index = entity->sub_index;
  }
  if (flag & LDP_ENTITY_CFG_MESG_TX) {
    e->mesg_tx = entity->mesg_tx;
  }
  if (flag & LDP_ENTITY_CFG_MESG_RX) {
    e->mesg_rx = entity->mesg_rx;
  }
  if (flag & LDP_ENTITY_CFG_ADJ_COUNT) {
    e->adj_count = entity->adj_root.count;
  }
  if (flag & LDP_ENTITY_CFG_ADJ_INDEX) {
    ldp_adj *a = MPLS_LIST_HEAD(&entity->adj_root);
    e->adj_index = a ? a->index : 0;
  }
  if (flag & LDP_ENTITY_CFG_INHERIT_FLAG) {
    e->inherit_flag = entity->inherit_flag;
  }
  retval = MPLS_SUCCESS;

ldp_cfg_entity_get_end:

  mpls_lock_release(global->global_lock); /* UNLOCK */

  LDP_EXIT(global->user_data, "ldp_cfg_entity_get");

  return retval;
}

mpls_return_enum ldp_cfg_entity_getnext(mpls_cfg_handle handle, ldp_entity * e,
  uint32_t flag)
{
  ldp_global *g = (ldp_global *) handle;
  ldp_entity *entity = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  int index;

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

  if (e->index == 0) {
    index = 1;
  } else {
    index = e->index + 1;
  }

  mpls_lock_get(g->global_lock); /* LOCK */
  while (done == MPLS_BOOL_FALSE) {
    switch ((r = ldp_global_find_entity_index(g, index, &entity))) {
      case MPLS_SUCCESS:
      case MPLS_END_OF_LIST:
        done = MPLS_BOOL_TRUE;
        break;
      case MPLS_FAILURE:
        break;
      default:
        MPLS_ASSERT(0);
    }
    index++;
  }
  mpls_lock_release(g->global_lock); /* UNLOCK */

  if (r == MPLS_SUCCESS) {
    e->index = entity->index;
    LDP_EXIT(g->user_data, "ldp_cfg_entity_getnext");
    return ldp_cfg_entity_get(g, e, flag);
  }
  LDP_EXIT(g->user_data, "ldp_cfg_entity_getnext");
  return r;
}

mpls_return_enum ldp_cfg_entity_test(mpls_cfg_handle handle, ldp_entity * e,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_entity *entity = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

  MPLS_ASSERT(global !=NULL);

  LDP_ENTER(global->user_data, "ldp_cfg_entity_test");

  mpls_lock_get(global->global_lock); /* LOCK */

  if (!(flag & LDP_CFG_ADD)) {
    if (e == NULL)
      goto ldp_cfg_entity_test_end;

    ldp_global_find_entity_index(global, e->index, &entity);
  } else {
    retval = MPLS_SUCCESS;
    goto ldp_cfg_entity_test_end;
  }

  if (entity == NULL) {
     goto ldp_cfg_entity_test_end;
  }

  if ((ldp_entity_is_active(entity) == MPLS_BOOL_TRUE) &&
      (flag & LDP_ENTITY_CFG_WHEN_DOWN)) {
     goto ldp_cfg_entity_test_end;
  }

  retval = MPLS_SUCCESS;

ldp_cfg_entity_test_end:
  mpls_lock_release(global->global_lock); /* UNLOCK */

  LDP_EXIT(global->user_data, "ldp_cfg_entity_test");

  return retval;
}

/* must set ldp_entity->index if not an add */
mpls_return_enum ldp_cfg_entity_set(mpls_cfg_handle handle, ldp_entity * e,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_entity *entity = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

  MPLS_ASSERT(global !=NULL && e != NULL);

  LDP_ENTER(global->user_data, "ldp_cfg_entity_set");

  mpls_lock_get(global->global_lock); /* LOCK */

  if (flag & LDP_CFG_ADD) {
    entity = ldp_entity_create();
    _ldp_global_add_entity(global, entity);

    e->index = entity->index;
  } else {
    ldp_global_find_entity_index(global, e->index, &entity);
  }

  if (entity == NULL) {
    LDP_PRINT(global->user_data, "ldp_cfg_entity_set: can't find entity\n");
    goto ldp_cfg_entity_set_end;
  }

  if ((ldp_entity_is_active(entity) == MPLS_BOOL_TRUE) &&
      (flag & LDP_ENTITY_CFG_WHEN_DOWN)) {
    LDP_PRINT(global->user_data, "ldp_cfg_entity_set: entity is active\n");
    goto ldp_cfg_entity_set_end;
  }

  if (flag & LDP_CFG_DEL) {
    switch (entity->entity_type) {
      case LDP_DIRECT:
        ldp_entity_del_if(global, entity);
        break;