ldp_cfg.c

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

  }
  if (flag & LDP_ATTR_CFG_OUTLABEL_INDEX) {
    a->outlabel_index = (attr->outlabel) ? (attr->outlabel->index) : 0;
  }
  if (flag & LDP_ATTR_CFG_INGRESS) {
    a->ingress = attr->ingress;
  }
  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum ldp_cfg_attr_getnext(mpls_cfg_handle handle, ldp_attr * a,
  uint32_t flag)
{
  ldp_global *g = (ldp_global *) handle;
  ldp_attr *attr = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  int index;

  LDP_ENTER(g->user_data, "ldp_cfg_attr_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_attr_index(g, index, &attr))) {
      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 = attr->index;
    LDP_EXIT(g->user_data, "ldp_cfg_attr_getnext");
    return ldp_cfg_attr_get(g, a, flag);
  }
  LDP_EXIT(g->user_data, "ldp_cfg_attr_getnext");
  return r;
}

/******************* PEER **********************/

mpls_return_enum ldp_cfg_peer_get(mpls_cfg_handle handle, ldp_peer * p,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_peer *peer = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (ldp_global_find_peer_index(global, p->index, &peer) != MPLS_SUCCESS)
      goto ldp_cfg_peer_get_end;

  if (flag & LDP_PEER_CFG_LABEL_SPACE) {
    p->label_space = peer->label_space;
  }
  if (flag & LDP_PEER_CFG_TARGET_ROLE) {
    p->target_role = peer->target_role;
  }
  if (flag & LDP_PEER_CFG_DEST_ADDR) {
    memcpy(&p->dest.addr, &peer->dest.addr, sizeof(mpls_inet_addr));
  }
  if (flag & LDP_PEER_CFG_ENTITY_INDEX) {
    p->entity_index = peer->entity->index;
  }
  if (flag & LDP_PEER_CFG_OPER_STATE) {
    p->oper_state = peer->oper_state;
  }
  if (flag & LDP_PEER_CFG_PEER_NAME) {
    strncpy(p->peer_name, peer->peer_name, MPLS_MAX_IF_NAME);
  }
  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum ldp_cfg_peer_getnext(mpls_cfg_handle handle, ldp_peer * p,
  uint32_t flag)
{
  ldp_global *g = (ldp_global *) handle;
  ldp_peer *peer = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  int index;

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

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

  mpls_lock_get(g->global_lock); /* LOCK */
  while (done == MPLS_BOOL_FALSE) {
    switch ((r = ldp_global_find_peer_index(g, index, &peer))) {
      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) {
    p->index = peer->index;
    LDP_EXIT(g->user_data, "ldp_cfg_peer_getnext");
    return ldp_cfg_peer_get(g, p, flag);
  }
  LDP_EXIT(g->user_data, "ldp_cfg_peer_getnext");
  return r;
}

mpls_return_enum ldp_cfg_peer_test(mpls_cfg_handle handle, ldp_peer * p,
  uint32_t flag)
{
  // ldp_global* g = (ldp_global*)handle;
  return MPLS_SUCCESS;
}

mpls_return_enum ldp_cfg_peer_set(mpls_cfg_handle handle, ldp_peer * p,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_peer *peer = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (flag & LDP_CFG_ADD) {
    if ((peer = ldp_peer_create()) == NULL) {
      goto ldp_cfg_peer_set_end;
    }
    p->index = peer->index;
    _ldp_global_add_peer(global, peer);
  } else {
    ldp_global_find_peer_index(global, p->index, &peer);
  }

  if (peer == NULL) {
    LDP_PRINT(global->user_data, "ldp_cfg_peer_set: no such peer\n");

    goto ldp_cfg_peer_set_end;
  }
  if ((ldp_peer_is_active(peer) == MPLS_BOOL_TRUE) && (flag & LDP_PEER_CFG_WHEN_DOWN)) {
    LDP_PRINT(global->user_data, "ldp_cfg_peer_set: peer is activer\n");

    goto ldp_cfg_peer_set_end;
  }

  if (flag & LDP_CFG_DEL) {
    if (peer->entity != NULL) {
      LDP_PRINT(global->user_data,
        "ldp_cfg_peer_set: not cleanup correctly is activer\n");

      goto ldp_cfg_peer_set_end;
    }

    _ldp_global_del_peer(global, peer);

    retval = MPLS_SUCCESS;
    goto ldp_cfg_peer_set_end;
  }
  if (flag & LDP_PEER_CFG_LABEL_SPACE) {
    peer->label_space = p->label_space;
  }
  if (flag & LDP_PEER_CFG_TARGET_ROLE) {
    peer->target_role = p->target_role;
  }
  if (flag & LDP_PEER_CFG_DEST_ADDR) {
    memcpy(&peer->dest.addr, &p->dest.addr, sizeof(mpls_inet_addr));
  }
  if (flag & LDP_PEER_CFG_PEER_NAME) {
    LDP_PRINT(global->user_data, "ldp_cfg_peer_set: peer_name = %s\n",

      p->peer_name);
    strncpy(peer->peer_name, p->peer_name, MPLS_MAX_IF_NAME);
  }
  global->configuration_sequence_number++;

  retval = MPLS_SUCCESS;

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

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

  return retval;
}
/******************* FEC **********************/

mpls_return_enum ldp_cfg_fec_get(mpls_cfg_handle handle, mpls_fec * f,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_fec *fec = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (flag & LDP_FEC_CFG_BY_INDEX) {
    ldp_global_find_fec_index(global, f->index, &fec);
  } else {
    fec = ldp_fec_find(global, f);
  }
  if (!fec)
      goto ldp_cfg_fec_get_end;

  memcpy(f, &fec->info, sizeof(mpls_fec));
  f->index = fec->index;
  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum ldp_cfg_fec_getnext(mpls_cfg_handle handle, mpls_fec * f,
  uint32_t flag)
{
  ldp_global *g = (ldp_global *) handle;
  ldp_fec *fec = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  int index;

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

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

  mpls_lock_get(g->global_lock); /* LOCK */
  while (done == MPLS_BOOL_FALSE) {
    switch ((r = ldp_global_find_fec_index(g, index, &fec))) {
      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) {
    f->index = fec->index;
    LDP_EXIT(g->user_data, "ldp_cfg_fec_getnext");
    return ldp_cfg_fec_get(g, f, flag);
  }
  LDP_EXIT(g->user_data, "ldp_cfg_fec_getnext");
  return r;
}

mpls_return_enum ldp_cfg_fec_test(mpls_cfg_handle handle, mpls_fec * f,
  uint32_t flag)
{
  // ldp_global* g = (ldp_global*)handle;
  return MPLS_SUCCESS;
}

mpls_return_enum ldp_cfg_fec_set(mpls_cfg_handle handle, mpls_fec * f,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_fec *fec = NULL;
  ldp_nexthop *nh;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (flag & LDP_CFG_ADD) {
    if (ldp_fec_find(global, f) || (fec = ldp_fec_create(global, f)) == NULL) {
      goto ldp_cfg_fec_set_end;
    }
    MPLS_REFCNT_HOLD(fec);
    f->index = fec->index;
  } else {
    if (flag & LDP_FEC_CFG_BY_INDEX) {
      ldp_global_find_fec_index(global, f->index, &fec);
    } else {
      fec = ldp_fec_find(global, f);
    }
  }

  if (fec == NULL) {
    LDP_PRINT(global->user_data, "ldp_cfg_fec_set: no such fec\n");
    goto ldp_cfg_fec_set_end;
  }

  if (flag & LDP_CFG_DEL) {

    while ((nh = MPLS_LIST_HEAD(&fec->nh_root))) {
      ldp_fec_del_nexthop(global, fec, nh);
    }

    MPLS_REFCNT_RELEASE2(global, fec, ldp_fec_delete);
  }

  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum ldp_cfg_fec_nexthop_get(mpls_cfg_handle handle, mpls_fec * f,
  mpls_nexthop *n, uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_fec *fec = NULL;
  ldp_nexthop *nh = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (flag & LDP_FEC_CFG_BY_INDEX) {
    ldp_global_find_fec_index(global, f->index, &fec);
  } else {
    fec = ldp_fec_find(global, f);
  }
  if (!fec)
      goto ldp_cfg_fec_nexthop_get_end;

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

  memcpy(n, &nh->info, sizeof(mpls_nexthop));
  n->index = nh->index;
  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum ldp_cfg_fec_nexthop_getnext(mpls_cfg_handle handle,
  mpls_fec * f, mpls_nexthop *n, uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_fec *fec = NULL;
  ldp_nexthop *nh = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  int index;

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

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

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

  if (flag & LDP_FEC_CFG_BY_INDEX) {
    ldp_global_find_fec_index(global, f->index, &fec);
  } else {
    fec = ldp_fec_find(global, f);
  }
  if (!fec)
      goto ldp_cfg_fec_nexthop_getnext_end;

  while (done == MPLS_BOOL_FALSE) {
    switch ((r = ldp_fec_find_nexthop_index(fec, index, &nh))) {
      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) {
    n->index = nh->index;
    LDP_EXIT(global->user_data, "ldp_cfg_fec_nexthop_getnext");
    return ldp_cfg_fec_nexthop_get(global, f, n, flag);
  }

ldp_cfg_fec_nexthop_getnext_end:

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

mpls_return_enum ldp_cfg_fec_nexthop_test(mpls_cfg_handle handle, mpls_fec * f,
  mpls_nexthop *n, uint32_t flag)
{
  // ldp_global* g = (ldp_global*)handle;
  return MPLS_SUCCESS;
}

mpls_return_enum ldp_cfg_fec_nexthop_set(mpls_cfg_handle handle, mpls_fec * f,
  mpls_nexthop *n, uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_fec *fec = NULL;
  ldp_nexthop *nh = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

  MPLS_ASSERT(global !=NULL && f != NULL && n != NULL);

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

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

  if (flag & LDP_FEC_CFG_BY_INDEX) {
    ldp_global_find_fec_index(global, f->index, &fec);
  } else {
    fec = ldp_fec_find(global, f);
  }
  if (!fec)
      goto ldp_cfg_fec_nexthop_set_end;

  if (flag & LDP_CFG_ADD) {
    if (ldp_fec_nexthop_find(fec, n) ||
      (nh = ldp_nexthop_create(global, n)) == NULL) {