ldp_cfg.c

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

      goto ldp_cfg_fec_nexthop_set_end;
    }
    n->index = nh->index;
    ldp_fec_add_nexthop(global, fec, nh);
    ldp_fec_process_add(global, fec, nh, NULL);
  } else {
    if (flag & LDP_FEC_NEXTHOP_CFG_BY_INDEX) {
      ldp_fec_find_nexthop_index(fec, n->index, &nh);
    } else {
      nh = ldp_fec_nexthop_find(fec, n);
    }
  }

  if (nh == NULL) {
    LDP_PRINT(global->user_data, "ldp_cfg_fec_nexthop_set: no such nh\n");
    goto ldp_cfg_fec_nexthop_set_end;
  }

  if (flag & LDP_CFG_DEL) {
    ldp_fec_del_nexthop(global, fec, nh);
    if (ldp_fec_process_change(global, fec, MPLS_LIST_HEAD(&fec->nh_root),
      nh, NULL) != MPLS_SUCCESS) {
      MPLS_ASSERT(0);
    }
    _ldp_global_del_nexthop(global, nh);
  }

  retval = MPLS_SUCCESS;

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

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

  return retval;
}

/******************* ADDR **********************/

mpls_return_enum ldp_cfg_addr_get(mpls_cfg_handle handle, ldp_addr * a,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_session *session = NULL;
  ldp_nexthop *nexthop = NULL;
  ldp_addr *addr = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  ldp_global_find_addr_index(global, a->index, &addr);

  if (!addr)
    goto ldp_cfg_addr_get_end;

  memcpy(&a->address, &addr->address, sizeof(mpls_inet_addr));
  a->index = addr->index;

  if ((session = mpls_link_list_head_data(&addr->session_root))) {
    a->session_index = session->index;
  }

  if ((nexthop = MPLS_LIST_HEAD(&addr->nh_root))) {
    a->nexthop_index = nexthop->index;
  }

  if (addr->iff) {
    a->if_index = addr->iff->index;
  }

  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum ldp_cfg_addr_getnext(mpls_cfg_handle handle, ldp_addr *a,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_addr *addr = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  int index;

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

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

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

  while (done == MPLS_BOOL_FALSE) {
    switch ((r = ldp_global_find_addr_index(global, index, &addr))) {
      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(global->global_lock); /* UNLOCK */

  if (r == MPLS_SUCCESS) {
    a->index = addr->index;
    LDP_EXIT(global->user_data, "ldp_cfg_addr_getnext");
    return ldp_cfg_addr_get(global, a, flag);
  }

  LDP_EXIT(global->user_data, "ldp_cfg_addr_getnext");
  return r;
}

/******************* IF ADDR **********************/

mpls_return_enum ldp_cfg_if_addr_get(mpls_cfg_handle handle, ldp_if * i,
  ldp_addr * a, uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_addr *addr = NULL;
  ldp_if *iff = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (flag & LDP_IF_CFG_BY_INDEX) {
    ldp_global_find_if_index(global, i->index, &iff);
  } else {
    iff = ldp_global_find_if_handle(global, i->handle);
  }
  if (!iff)
      goto ldp_cfg_if_addr_get_end;

  if (flag & LDP_IF_ADDR_CFG_BY_INDEX) {
    ldp_if_find_addr_index(iff, a->index, &addr);
  } else {
    addr = ldp_if_addr_find(iff, &a->address);
  }
  if (!addr)
    goto ldp_cfg_if_addr_get_end;

  memcpy(&a->address, &addr->address, sizeof(mpls_inet_addr));
  a->index = addr->index;

  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum ldp_cfg_if_addr_getnext(mpls_cfg_handle handle,
  ldp_if * i, ldp_addr *a, uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_if *iff = NULL;
  ldp_addr *addr = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  int index;

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

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

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

  if (flag & LDP_IF_CFG_BY_INDEX) {
    ldp_global_find_if_index(global, i->index, &iff);
  } else {
    iff = ldp_global_find_if_handle(global, i->handle);
  }
  if (!iff)
      goto ldp_cfg_if_addr_getnext_end;

  while (done == MPLS_BOOL_FALSE) {
    switch ((r = ldp_if_find_addr_index(iff, index, &addr))) {
      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(global->global_lock); /* UNLOCK */

  if (r == MPLS_SUCCESS) {
    a->index = addr->index;
    LDP_EXIT(global->user_data, "ldp_cfg_if_addr_getnext");
    return ldp_cfg_if_addr_get(global, i, a, flag);
  }

ldp_cfg_if_addr_getnext_end:

  LDP_EXIT(global->user_data, "ldp_cfg_if_addr_getnext");
  return r;
}

mpls_return_enum ldp_cfg_if_addr_set(mpls_cfg_handle handle, ldp_if * i,
  ldp_addr *a, uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_if *iff = NULL;
  ldp_addr *addr = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (flag & LDP_FEC_CFG_BY_INDEX) {
    ldp_global_find_if_index(global, i->index, &iff);
  } else {
    iff = ldp_global_find_if_handle(global, i->handle);
  }
  if (!iff)
      goto ldp_cfg_if_addr_set_end;

  if (flag & LDP_CFG_ADD) {
    if (ldp_if_addr_find(iff, &a->address) || (addr = ldp_addr_create(global,
      &a->address)) == NULL) {
      goto ldp_cfg_if_addr_set_end;
    }
    a->index = addr->index;
    ldp_if_add_addr(iff, addr);
  } else {
    if (flag & LDP_FEC_NEXTHOP_CFG_BY_INDEX) {
      ldp_if_find_addr_index(iff, a->index, &addr);
    } else {
      addr = ldp_if_addr_find(iff, &a->address);
    }
  }

  if (addr == NULL) {
    LDP_PRINT(global->user_data, "ldp_cfg_if_addr_set: no such addr\n");
    goto ldp_cfg_if_addr_set_end;
  }

  if (flag & LDP_CFG_DEL) {
    ldp_if_del_addr(global, iff ,addr);
  }

  retval = MPLS_SUCCESS;

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

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

  return retval;
}

/******************* ADJACENCY **********************/

mpls_return_enum ldp_cfg_adj_get(mpls_cfg_handle handle, ldp_adj * a,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_adj *adj = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (ldp_global_find_adj_index(global, a->index, &adj) != MPLS_SUCCESS)
      goto ldp_cfg_adj_get_end;

  if (flag & LDP_ADJ_CFG_REMOTE_TRADDR) {
    memcpy(&a->remote_transport_address, &adj->remote_transport_address,
      sizeof(mpls_inet_addr));
  }
  if (flag & LDP_ADJ_CFG_REMOTE_SRCADDR) {
    memcpy(&a->remote_source_address, &adj->remote_source_address,
      sizeof(mpls_inet_addr));
  }
  if (flag & LDP_ADJ_CFG_REMOTE_LSRADDR) {
    memcpy(&a->remote_lsr_address, &adj->remote_lsr_address,
      sizeof(mpls_inet_addr));
  }
  if (flag & LDP_ADJ_CFG_REMOTE_CSN) {
    a->remote_csn = adj->remote_csn;
  }
  if (flag & LDP_ADJ_CFG_REMOTE_LABELSPACE) {
    a->remote_label_space = adj->remote_label_space;
  }
  if (flag & LDP_ADJ_CFG_REMOTE_HELLOTIME) {
    a->remote_hellotime = adj->remote_hellotime;
  }
  if (flag & LDP_ADJ_CFG_ENTITY_INDEX) {
    a->entity_index = adj->entity ? adj->entity->index : 0;
  }
  if (flag & LDP_ADJ_CFG_REMOTE_SESSION_INDEX) {
    a->session_index = (adj->session) ? (adj->session->index) : 0;
  }
  if (flag & LDP_ADJ_CFG_ROLE) {
    a->role = adj->role;
  }
  retval = MPLS_SUCCESS;

ldp_cfg_adj_get_end:

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

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

  return retval;
}

mpls_return_enum ldp_cfg_adj_getnext(mpls_cfg_handle handle, ldp_adj * a,
  uint32_t flag)
{
  ldp_global *g = (ldp_global *) handle;
  ldp_adj *adj = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  int index;

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

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

  mpls_lock_get(g->global_lock); /* LOCK */
  while (done == MPLS_BOOL_FALSE) {
    switch ((r = ldp_global_find_adj_index(g, index, &adj))) {
      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) {
    a->index = adj->index;
    LDP_EXIT(g->user_data, "ldp_cfg_adj_getnext");
    return ldp_cfg_adj_get(g, a, flag);
  }
  LDP_EXIT(g->user_data, "ldp_cfg_adj_getnext");
  return r;
}

/******************* SESSION **********************/

mpls_return_enum ldp_cfg_session_get(mpls_cfg_handle handle, ldp_session * s,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_session *session = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (ldp_global_find_session_index(global, s->index, &session) != MPLS_SUCCESS)
      goto ldp_cfg_session_get_end;

  if (flag & LDP_SESSION_CFG_STATE) {
    s->state = session->state;
  }
  if (flag & LDP_SESSION_CFG_OPER_UP) {
    s->oper_up = session->oper_up;
  }
  if (flag & LDP_SESSION_CFG_MAX_PDU) {
    s->oper_max_pdu = session->oper_max_pdu;
  }
  if (flag & LDP_SESSION_CFG_KEEPALIVE) {
    s->oper_keepalive = session->oper_keepalive;
  }
  if (flag & LDP_SESSION_CFG_PATH_LIMIT) {
    s->oper_path_vector_limit = session->oper_path_vector_limit;
  }
  if (flag & LDP_SESSION_CFG_DIST_MODE) {
    s->oper_distribution_mode = session->oper_distribution_mode;
  }
  if (flag & LDP_SESSION_CFG_LOOP_DETECTION) {
    s->oper_loop_detection = session->oper_loop_detection;
  }
  if (flag & LDP_SESSION_CFG_REMOTE_MAX_PDU) {
    s->remote_max_pdu = session->remote_max_pdu;
  }
  if (flag & LDP_SESSION_CFG_REMOTE_KEEPALIVE) {
    s->remote_keepalive = session->remote_keepalive;
  }
  if (flag & LDP_SESSION_CFG_REMOTE_PATH_LIMIT) {
    s->remote_path_vector_limit = session->remote_path_vector_limit;
  }
  if (flag & LDP_SESSION_CFG_REMOTE_DIST_MODE) {
    s->remote_distribution_mode = session->remote_distribution_mode;
  }
  if (flag & LDP_SESSION_CFG_REMOTE_LOOP_DETECTION) {
    s->remote_loop_detection = session->remote_loop_detection;
  }
  if (flag & LDP_SESSION_CFG_REMOTE_ADDR) {
    s->remote_dest.addr.type = session->remote_dest.addr.type;
    s->remote_dest.addr.u.ipv4 = session->remote_dest.addr.u.ipv4;
  }
  if (flag & LDP_SESSION_CFG_REMOTE_PORT) {
    s->remote_dest.port = session->remote_dest.port;
  }
  if (flag & LDP_SESSION_CFG_LABEL_RESOURCE_STATE_LOCAL) {
    s->no_label_resource_sent = session->no_label_resource_sent;
  }
  if (flag & LDP_SESSION_CFG_LABEL_RESOURCE_STATE_REMOTE) {
    s->no_label_resource_recv = session->no_label_resource_recv;
  }
  if (flag & LDP_SESSION_CFG_ADJ_INDEX) {
    ldp_adj *a = MPLS_LIST_HEAD(&session->adj_root);
    s->adj_index = a ? a->index : 0;
  }
  if (flag & LDP_SESSION_CFG_MESG_TX) {
    s->mesg_tx = session->mesg_tx;
  }
  if (flag & LDP_SESSION_CFG_MESG_RX) {
    s->mesg_rx = session->mesg_rx;
  }
  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum ldp_cfg_session_getnext(mpls_cfg_handle handle, ldp_session * s,
  uint32_t flag)
{
  ldp_global *g = (ldp_global *) handle;
  ldp_session *ses = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  int index;

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

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

  mpls_lock_get(g->global_lock); /* LOCK */
  while (done == MPLS_BOOL_FALSE) {
    switch ((r = ldp_global_find_session_index(g, index, &ses))) {