ldp_cfg.c

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

      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) {
    s->index = ses->index;

    LDP_EXIT(g->user_data, "ldp_cfg_session_getnext");
    return ldp_cfg_session_get(g, s, flag);
  }

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

  return r;
}

mpls_return_enum ldp_cfg_session_adj_getnext(mpls_cfg_handle handle,
  ldp_session * s)
{
  ldp_global *g = (ldp_global *) handle;
  mpls_bool this_one = MPLS_BOOL_FALSE;
  mpls_return_enum r = MPLS_FAILURE;
  ldp_adj *adj_next = NULL;
  ldp_adj *adj = NULL;
  ldp_session *session = NULL;

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

  /* if an adj_index of zero is sent, get the index of
   * the first adj in the list
   */
  if (!s->adj_index) {
    this_one = MPLS_BOOL_TRUE;
  }

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

  if (ldp_global_find_session_index(g, s->index, &session) == MPLS_SUCCESS) {
    adj = MPLS_LIST_HEAD(&session->adj_root);
    while (adj) {
      if (this_one == MPLS_BOOL_TRUE) {
        adj_next = adj;
        break;
      }

      /* since the entities are sort in the list ... */
      if (adj->index > s->adj_index) {
        break;
      } else if (adj->index == s->adj_index) {
        this_one = MPLS_BOOL_TRUE;
      }
      adj = MPLS_LIST_NEXT(&session->adj_root, adj, _session);
    }
  }
  mpls_lock_release(g->global_lock); /* UNLOCK */

  if (adj_next) {
    s->adj_index = adj_next->index;
    r = MPLS_SUCCESS;
  }

  LDP_EXIT(g->user_data, "ldp_cfg_session_adj_getnext");
  return r;
}

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

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

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

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

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

  if (ldp_session_find_raddr_index(session, a->index, &addr) != MPLS_SUCCESS)
      goto ldp_cfg_session_raddr_get_end;

  if (flag & LDP_SESSION_RADDR_CFG_ADDR) {
    memcpy(&a->address,&addr->address,sizeof(struct mpls_inet_addr));
  }
  if (flag & LDP_SESSION_RADDR_CFG_INDEX) {
    a->index = addr->index;
  }
  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum ldp_cfg_session_raddr_getnext(mpls_cfg_handle handle,
  ldp_session * s, ldp_addr * a, uint32_t flag)
{
  ldp_global *g = (ldp_global *) handle;
  ldp_addr *addr = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  ldp_session *sp = NULL;
  int index;

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

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

  r = ldp_global_find_session_index(g, s->index, &sp);
  if (r != MPLS_SUCCESS) {
    return r;
  }

  mpls_lock_get(g->global_lock); /* LOCK */
  while (done == MPLS_BOOL_FALSE) {
    switch ((r = ldp_session_find_raddr_index(sp, 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(g->global_lock); /* UNLOCK */

  if (r == MPLS_SUCCESS) {
    a->index = addr->index;
    r = ldp_cfg_session_raddr_get(handle, sp, a, flag);
  }

  LDP_EXIT(g->user_data, "ldp_cfg_session_getnext");
  return r;
}

/******************* IN LABEL **********************/

mpls_return_enum ldp_cfg_inlabel_get(mpls_cfg_handle handle, ldp_inlabel * i,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_inlabel *inlabel = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (ldp_global_find_inlabel_index(global, i->index, &inlabel) != MPLS_SUCCESS)
      goto ldp_cfg_inlabel_get_end;

  if (flag & LDP_INLABEL_CFG_LABELSPACE) {
    i->info.labelspace = inlabel->info.labelspace;
  }
  if (flag & LDP_INLABEL_CFG_LABEL) {
    memcpy(&i->info.label, &inlabel->info.label, sizeof(mpls_label_struct));
  }
  if (flag & LDP_INLABEL_CFG_OUTLABEL_INDEX) {
    i->outlabel_index = (inlabel->outlabel) ? (inlabel->outlabel->index) : 0;
  }

  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum ldp_cfg_inlabel_getnext(mpls_cfg_handle handle, ldp_inlabel * i,
  uint32_t flag)
{
  ldp_global *g = (ldp_global *) handle;
  ldp_inlabel *inlabel = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  int index;

  LDP_ENTER(g->user_data, "ldp_cfg_inlabel_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 = ldp_global_find_inlabel_index(g, index, &inlabel))) {
      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 = inlabel->index;

    LDP_EXIT(g->user_data, "ldp_cfg_inlabel_getnext");
    return ldp_cfg_inlabel_get(g, i, flag);
  }

  LDP_EXIT(g->user_data, "ldp_cfg_inlabel_getnext");

  return r;
}

/******************* OUT LABEL **********************/

mpls_return_enum ldp_cfg_outlabel_get(mpls_cfg_handle handle, ldp_outlabel * o,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  ldp_outlabel *outlabel = NULL;
  mpls_return_enum retval = MPLS_FAILURE;

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

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

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

  if (ldp_global_find_outlabel_index(global, o->index,
      &outlabel) != MPLS_SUCCESS) goto ldp_cfg_outlabel_get_end;

  if (flag & LDP_OUTLABEL_CFG_NH_INDEX) {
    if (outlabel->nh) {
      o->nh_index = outlabel->nh->index;
    } else {
      o->nh_index = 0;
    }
  }
  if (flag & LDP_OUTLABEL_CFG_SESSION_INDEX) {
    o->session_index = (outlabel->session) ? (outlabel->session->index) : 0;
  }
  if (flag & LDP_OUTLABEL_CFG_LABEL) {
    memcpy(&o->info.label, &outlabel->info.label, sizeof(mpls_label_struct));
  }
  if (flag & LDP_OUTLABEL_CFG_MERGE_COUNT) {
    o->merge_count = outlabel->merge_count;
  }

  retval = MPLS_SUCCESS;

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

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

  return retval;
}

mpls_return_enum ldp_cfg_outlabel_getnext(mpls_cfg_handle handle,
  ldp_outlabel * o, uint32_t flag)
{
  ldp_global *g = (ldp_global *) handle;
  ldp_outlabel *outlabel = NULL;
  mpls_return_enum r = MPLS_FAILURE;
  mpls_bool done = MPLS_BOOL_FALSE;
  int index;

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

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

  mpls_lock_get(g->global_lock); /* LOCK */
  while (done == MPLS_BOOL_FALSE) {
    switch ((r = ldp_global_find_outlabel_index(g, index, &outlabel))) {
      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) {
    o->index = outlabel->index;

    LDP_EXIT(g->user_data, "ldp_cfg_outlabel_getnext");
    return ldp_cfg_outlabel_get(g, o, flag);
  }

  LDP_EXIT(g->user_data, "ldp_cfg_outlabel_getnext");

  return r;
}

/******************* TUNNEL **********************/

mpls_return_enum ldp_cfg_tunnel_set(mpls_cfg_handle handle, ldp_tunnel * t,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  mpls_return_enum retval = MPLS_FAILURE;
  ldp_tunnel *tunnel = NULL;

  MPLS_ASSERT(global !=NULL);

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

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

  if (flag & LDP_CFG_ADD) {
    if (!(tunnel = ldp_tunnel_create())) {
      goto ldp_cfg_tunnel_set_end;
    }
    _ldp_global_add_tunnel(global, tunnel);

    t->index = tunnel->index;
  } else {
    ldp_global_find_tunnel_index(global, t->index, &tunnel);
  }

  if (!tunnel) {
    LDP_PRINT(global->user_data,

      "ldp_cfg_tunnel_set:could not create tunnel\n");
    goto ldp_cfg_tunnel_set_end;
  }

  if ((ldp_tunnel_is_active(tunnel) == MPLS_BOOL_TRUE) &&
    (flag & LDP_TUNNEL_CFG_WHEN_DOWN)) {
    LDP_PRINT(global->user_data, "ldp_cfg_tunnel_set: tunnel is active\n");

    goto ldp_cfg_tunnel_set_end;
  }

  if (flag & LDP_CFG_DEL) {
    if (tunnel->outlabel)
      ldp_tunnel_del_outlabel(tunnel);
    if (tunnel->resource)
      ldp_tunnel_del_resource(tunnel);
    if (tunnel->hop_list)
      ldp_tunnel_del_hop_list(tunnel);
    _ldp_global_del_tunnel(global, tunnel);

    retval = MPLS_SUCCESS;
    goto ldp_cfg_tunnel_set_end;
  }

  if (flag & LDP_TUNNEL_CFG_INGRESS) {
    memcpy(&tunnel->ingress_lsrid, &t->ingress_lsrid, sizeof(ldp_addr));
  }
  if (flag & LDP_TUNNEL_CFG_EGRESS) {
    memcpy(&tunnel->egress_lsrid, &t->egress_lsrid, sizeof(ldp_addr));
  }
  if (flag & LDP_TUNNEL_CFG_NAME) {
    memcpy(&tunnel->name, &t->name, MPLS_MAX_IF_NAME);
  }
  if (flag & LDP_TUNNEL_CFG_IS_IF) {
    tunnel->is_interface = t->is_interface;
  }
  if (flag & LDP_TUNNEL_CFG_OUTLABEL) {
    ldp_outlabel *outlabel = NULL;

    if (t->outlabel_index) {
      ldp_global_find_outlabel_index(global, t->outlabel_index, &outlabel);

      if (!outlabel) {
        goto ldp_cfg_tunnel_set_end;
      }
      ldp_tunnel_add_outlabel(tunnel, outlabel);
    } else {
      ldp_tunnel_del_outlabel(tunnel);
    }
  }
  if (flag & LDP_TUNNEL_CFG_SETUP_PRIO) {
    tunnel->setup_prio = t->setup_prio;
  }
  if (flag & LDP_TUNNEL_CFG_HOLD_PRIO) {
    tunnel->hold_prio = t->hold_prio;
  }
  if (flag & LDP_TUNNEL_CFG_INSTANCE_PRIO) {
    tunnel->instance_prio = t->instance_prio;
  }
  if (flag & LDP_TUNNEL_CFG_LOCAL_PROTECT) {
    tunnel->local_protect = t->local_protect;
  }
  if (flag & LDP_TUNNEL_CFG_RESOURCE_INDEX) {
    ldp_resource *resource = NULL;

    if (t->resource_index) {
      ldp_global_find_resource_index(global, t->resource_index, &resource);

      if (!resource) {
        goto ldp_cfg_tunnel_set_end;
      }
      ldp_tunnel_add_resource(tunnel, resource);
    } else {
      ldp_tunnel_del_resource(tunnel);
    }
  }
  if (flag & LDP_TUNNEL_CFG_HOP_LIST_INDEX) {
    ldp_hop_list *hop_list = NULL;

    if (t->hop_list_index) {
      ldp_global_find_hop_list_index(global, t->hop_list_index, &hop_list);

      if (!hop_list) {
        goto ldp_cfg_tunnel_set_end;
      }
      ldp_tunnel_add_hop_list(tunnel, hop_list);
    } else {
      ldp_tunnel_del_hop_list(tunnel);
    }
  }
  if (flag & LDP_TUNNEL_CFG_FEC) {
    memcpy(&tunnel->fec, &t->fec, sizeof(ldp_fec));
  }
  if (flag & LDP_TUNNEL_CFG_ADMIN_STATE) {
    if (ldp_tunnel_is_active(tunnel) == MPLS_BOOL_TRUE) {
      if (t->admin_state == MPLS_ADMIN_DISABLE) {
        if (ldp_tunnel_shutdown(global, tunnel, 0) == MPLS_FAILURE) {
          goto ldp_cfg_tunnel_set_end;
        }
      }
    } else {
      if (t->admin_state == MPLS_ADMIN_ENABLE) {
        if (ldp_tunnel_is_ready(tunnel) == MPLS_BOOL_TRUE) {
          if (ldp_tunnel_startup(global, tunnel) == MPLS_FAILURE) {
            goto ldp_cfg_tunnel_set_end;
          }
        } else {
          LDP_PRINT(global->user_data,

            "ldp_cfg_tunnel_set: tunnel not ready\n");
          goto ldp_cfg_tunnel_set_end;
        }
      }
    }
  }
  retval = MPLS_SUCCESS;

ldp_cfg_tunnel_set_end:

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

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

  return retval;
}

mpls_return_enum ldp_cfg_tunnel_test(mpls_cfg_handle handle, ldp_tunnel * t,
  uint32_t flag)
{
  ldp_global *global = (ldp_global *) handle;
  mpls_return_enum retval = MPLS_FAILURE;
  ldp_tunnel *