lsr_cfg.c

Linux平台下

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

#include "lsr_struct.h"
#include "lsr_cfg.h"
#include "lsr_global.h"
#include "lsr_outsegment.h"
#include "lsr_insegment.h"
#include "lsr_xconnect.h"
#include "lsr_if.h"
#include "lsr_ftn.h"

#include "mpls_mm_impl.h"
#include "mpls_mpls_impl.h"
#include "mpls_ifmgr_impl.h"
#include "mpls_lock_impl.h"
#include "mpls_trace_impl.h"

mpls_cfg_handle lsr_cfg_open(mpls_instance_handle data)
{
  lsr_global *g = NULL;

  LDP_ENTER(data, "lsr_cfg_open");
  g = lsr_global_create(data);
  LDP_EXIT(data, "lsr_cfg_open");

  return (mpls_cfg_handle) g;
}

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

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

mpls_return_enum lsr_cfg_global_get(mpls_cfg_handle handle, lsr_global * g,
  uint32_t flag)
{
  lsr_global *global = (lsr_global *) handle;

  MPLS_ASSERT(global !=NULL);

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

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

  if (flag & LSR_GLOBAL_CFG_ADMIN_STATE) {
    g->admin_state = global->admin_state;
  }

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

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

  return MPLS_SUCCESS;
}

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

  MPLS_ASSERT(global !=NULL);

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

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

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

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

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

  return retval;
}

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

  MPLS_ASSERT(global !=NULL);

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

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

  if ((global->admin_state == MPLS_ADMIN_ENABLE) &&
      (flag & LSR_GLOBAL_CFG_WHEN_DOWN))
    goto lsr_cfg_global_set_end;

  if (flag & LSR_GLOBAL_CFG_ADMIN_STATE) {
    if ((global->admin_state == MPLS_ADMIN_ENABLE) &&
        (g->admin_state == MPLS_ADMIN_DISABLE)) {
      lsr_global_shutdown(global);
    } else if ((global->admin_state == MPLS_ADMIN_DISABLE) &&
               (g->admin_state == MPLS_ADMIN_ENABLE)) {
      lsr_global_startup(global);
    }
  }

  retval = MPLS_SUCCESS;

lsr_cfg_global_set_end:

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

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

  return retval;
}

/******************* OUTSEGMENT **********************/

mpls_return_enum lsr_cfg_outsegment_get(mpls_cfg_handle handle, lsr_outsegment * o, uint32_t flag)
{
  lsr_global *global = (lsr_global *) handle;
  lsr_outsegment *oseg = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (lsr_global_find_outsegment_index(global, o->index, &oseg) != MPLS_SUCCESS)
      goto lsr_cfg_outsegment_get_end;

  if (LSR_OUTSEGMENT_CFG_INDEX & flag) {
    o->index = oseg->index;
  }
  if (LSR_OUTSEGMENT_CFG_PUSH_LABEL & flag) {
    o->info.push_label = oseg->info.push_label;
  }
  if (LSR_OUTSEGMENT_CFG_OWNER & flag) {
    o->info.owner = oseg->info.owner;
  }
  if (LSR_OUTSEGMENT_CFG_INTERFACE & flag) {
    o->if_index = oseg->iff ? oseg->iff->index : 0;
  }
  if (LSR_OUTSEGMENT_CFG_LABEL & flag) {
    memcpy(&o->info.label, &oseg->info.label, sizeof(mpls_label_struct));
  }
  if (LSR_OUTSEGMENT_CFG_NEXTHOP & flag) {
    memcpy(&o->info.nexthop, &oseg->info.nexthop, sizeof(mpls_nexthop));
  }

  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum lsr_cfg_outsegment_getnext(mpls_cfg_handle handle, lsr_outsegment * i,
  uint32_t flag)
{
  lsr_global *g = (lsr_global *) handle;
  lsr_outsegment *oseg = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  int index;

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

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

  mpls_lock_get(g->global_lock); /* LOCK */
  while (done == MPLS_BOOL_FALSE) {
    switch ((r = lsr_global_find_outsegment_index(g, index, &oseg))) {
      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) {
    i->index = oseg->index;
    LDP_EXIT(g->user_data, "lsr_cfg_outsegment_getnext");
    return lsr_cfg_outsegment_get(g, i, flag);
  }
  LDP_EXIT(g->user_data, "lsr_cfg_outsegment_getnext");
  return r;
}

mpls_return_enum lsr_cfg_outsegment_test(mpls_cfg_handle handle, lsr_outsegment * i,
  uint32_t flag)
{
  lsr_global *global = (lsr_global *) handle;
  lsr_outsegment *oseg = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (!(flag & LSR_CFG_ADD)) {
    lsr_global_find_outsegment_index(global, i->index, &oseg);
  } else {
    retval = MPLS_SUCCESS;
    goto lsr_cfg_outsegment_test_end;
  }

  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum lsr_cfg_outsegment_set(mpls_cfg_handle handle, lsr_outsegment * o, uint32_t flag)
{
  lsr_global *global = (lsr_global*)handle;
  lsr_outsegment *oseg = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (flag & LSR_CFG_ADD) {
    if ((oseg = lsr_outsegment_create()) == NULL) {
      goto lsr_cfg_outsegment_set_end;
    }
    o->index = oseg->index;
  } else {
    lsr_global_find_outsegment_index(global, o->index, &oseg);
  }

  if (oseg == NULL)
    goto lsr_cfg_outsegment_set_end;

  if (flag & LSR_CFG_DEL) {
    _lsr_global_del_outsegment(global, oseg);
    mpls_mpls_outsegment_del(global->mpls_handle,&oseg->info);
    retval = MPLS_SUCCESS;
    goto lsr_cfg_outsegment_set_end;
  }

  if (LSR_OUTSEGMENT_CFG_PUSH_LABEL & flag) {
    oseg->info.push_label = o->info.push_label;
  }
  if (LSR_OUTSEGMENT_CFG_OWNER & flag) {
    oseg->info.owner = o->info.owner;
  }
  if (LSR_OUTSEGMENT_CFG_INTERFACE & flag) {
    lsr_if *iff = NULL;
    if (lsr_global_find_if_index(global, o->if_index, &iff) == MPLS_SUCCESS) {
      lsr_if_add_outsegment(iff,oseg);
    }
  }
  if (LSR_OUTSEGMENT_CFG_LABEL & flag) {
    memcpy(&oseg->info.label, &o->info.label, sizeof(mpls_label_struct));
  }
  if (LSR_OUTSEGMENT_CFG_NEXTHOP & flag) {
    memcpy(&oseg->info.nexthop, &o->info.nexthop, sizeof(mpls_nexthop));
  }

  retval = MPLS_SUCCESS;

  if (flag & LSR_CFG_ADD) {
    retval = mpls_mpls_outsegment_add(global->mpls_handle,&oseg->info);
    if (retval == MPLS_SUCCESS) {
      _lsr_global_add_outsegment(global, oseg);
    }
  }

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

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

  return retval;
}
/******************* INSEGMENT **********************/

mpls_return_enum lsr_cfg_insegment_get(mpls_cfg_handle handle, lsr_insegment * i, uint32_t flag)
{
  lsr_global *global = (lsr_global *) handle;
  lsr_insegment *iseg = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (lsr_global_find_insegment_index(global, i->index, &iseg) != MPLS_SUCCESS)
      goto lsr_cfg_insegment_get_end;

  if (LSR_INSEGMENT_CFG_INDEX & flag) {
    i->index = iseg->index;
  }
  if (LSR_INSEGMENT_CFG_NPOP & flag) {
    i->info.npop = iseg->info.npop;
  }
  if (LSR_INSEGMENT_CFG_FAMILY & flag) {
    i->info.family = iseg->info.family;
  }
  if (LSR_INSEGMENT_CFG_LABELSPACE & flag) {
    i->info.labelspace = iseg->info.labelspace;
  }
  if (LSR_INSEGMENT_CFG_LABEL & flag) {
    memcpy(&i->info.label, &iseg->info.label, sizeof(mpls_label_struct));
  }
  if (LSR_INSEGMENT_CFG_OWNER & flag) {
    i->info.owner = iseg->info.owner;
  }

  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum lsr_cfg_insegment_getnext(mpls_cfg_handle handle, lsr_insegment * i,
  uint32_t flag)
{
  lsr_global *g = (lsr_global *) handle;
  lsr_insegment *iseg = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  int index;

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

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

  mpls_lock_get(g->global_lock); /* LOCK */
  while (done == MPLS_BOOL_FALSE) {
    switch ((r = lsr_global_find_insegment_index(g, index, &iseg))) {
      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) {
    i->index = iseg->index;
    LDP_EXIT(g->user_data, "lsr_cfg_insegment_getnext");
    return lsr_cfg_insegment_get(g, i, flag);
  }
  LDP_EXIT(g->user_data, "lsr_cfg_insegment_getnext");
  return r;
}

mpls_return_enum lsr_cfg_insegment_test(mpls_cfg_handle handle, lsr_insegment * i,
  uint32_t flag)
{
  lsr_global *global = (lsr_global *) handle;
  lsr_insegment *iseg = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (!(flag & LSR_CFG_ADD)) {
    lsr_global_find_insegment_index(global, i->index, &iseg);
  } else {
    retval = MPLS_SUCCESS;
    goto lsr_cfg_insegment_test_end;
  }

  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum lsr_cfg_insegment_set(mpls_cfg_handle handle, lsr_insegment * i, uint32_t flag)
{
  lsr_global *global = (lsr_global*)handle;
  lsr_insegment *iseg = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (flag & LSR_CFG_ADD) {
    if ((iseg = lsr_insegment_create()) == NULL) {
      goto lsr_cfg_insegment_set_end;
    }
    i->index = iseg->index;
  } else {
    lsr_global_find_insegment_index(global, i->index, &iseg);
  }

  if (iseg == NULL)
    goto lsr_cfg_insegment_set_end;

  if (flag & LSR_CFG_DEL) {

    mpls_mpls_insegment_del(global->mpls_handle,&iseg->info);
    _lsr_global_del_insegment(global, iseg);

    retval = MPLS_SUCCESS;
    goto lsr_cfg_insegment_set_end;
  }

  if (LSR_INSEGMENT_CFG_NPOP & flag) {
    iseg->info.npop = i->info.npop;
  }
  if (LSR_INSEGMENT_CFG_FAMILY & flag) {
    iseg->info.family = i->info.family;
  }
  if (LSR_INSEGMENT_CFG_LABELSPACE & flag) {
    iseg->info.labelspace = i->info.labelspace;
  }
  if (LSR_INSEGMENT_CFG_LABEL & flag) {
    memcpy(&iseg->info.label, &i->info.label, sizeof(mpls_label_struct));
  }
  if (LSR_INSEGMENT_CFG_OWNER & flag) {
    iseg->info.owner = i->info.owner;
  }

  retval = MPLS_SUCCESS;

  if (flag & LSR_CFG_ADD) {
    retval = mpls_mpls_insegment_add(global->mpls_handle,&iseg->info);
    if (retval == MPLS_SUCCESS) {
      memcpy(&i->info.label, &iseg->info.label, sizeof(mpls_label_struct));
      _lsr_global_add_insegment(global, iseg);
    }
  }

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

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

  return retval;
}
/******************* XCONNECT **********************/

void do_lsr_cfg_xconnect_get(lsr_xconnect * x, lsr_xconnect * xcon,
  uint32_t flag)
{
  if (LSR_XCONNECT_CFG_INDEX & flag) {
    x->index = xcon->index;
  }
  if (LSR_XCONNECT_CFG_OUTSEGMENT & flag) {
    x->outsegment_index = xcon->outsegment ? xcon->outsegment->index : 0;
  }
  if (LSR_XCONNECT_CFG_INSEGMENT & flag) {
    x->insegment_index = xcon->insegment->index;
  }
  if (LSR_XCONNECT_CFG_LSPID & flag) {
    x->info.lspid = xcon->info.lspid;
  }
  if (LSR_XCONNECT_CFG_LABELSTACK & flag) {
    x->info.stack_size = xcon->info.stack_size;
    memcpy(x->info.stack,xcon->info.stack,
      sizeof(mpls_label_struct) * xcon->info.stack_size);
  }
  if (LSR_XCONNECT_CFG_OWNER & flag) {
    x->info.owner = xcon->info.owner;
  }
}

mpls_return_enum lsr_cfg_xconnect_get(mpls_cfg_handle handle, lsr_xconnect * x, uint32_t flag)
{
  lsr_global *global = (lsr_global *) handle;
  lsr_xconnect *xcon = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (lsr_global_find_xconnect_index(global, x->index, &xcon) != MPLS_SUCCESS)
      goto lsr_cfg_xconnect_get_end;

  do_lsr_cfg_xconnect_get(x, xcon, flag);

  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum lsr_cfg_xconnect_get2(mpls_cfg_handle handle, lsr_xconnect *x, uint32_t flag)
{
  lsr_global *global = (lsr_global *) handle;
  lsr_xconnect *xcon = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (lsr_global_find_xconnect_index2(global, x->insegment_index,
    x->outsegment_index, &xcon) != MPLS_SUCCESS)
      goto lsr_cfg_xconnect_get_end;

  do_lsr_cfg_xconnect_get(x, xcon, flag);

  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum lsr_cfg_xconnect_getnext(mpls_cfg_handle handle, lsr_xconnect * i, uint32_t flag)
{
  lsr_global *g = (lsr_global *) handle;
  lsr_xconnect *xcon = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  int index;

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

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

  mpls_lock_get(g->global_lock); /* LOCK */
  while (done == MPLS_BOOL_FALSE) {
    switch ((r = lsr_global_find_xconnect_index(g, index, &xcon))) {
      case MPLS_SUCCESS: