/*
 *  Copyright (C) James R. Leu 2000
 *  jleu@mindspring.com
 *
 *  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_range.h"
#include "ldp_attr.h"
#include "ldp_if.h"
#include "ldp_peer.h"
#include "ldp_ifmgr_impl.h"
#include "ldp_lock_impl.h"
#include "ldp_trace_impl.h"

ldp_cfg_handle ldp_cfg_open(ldp_instance_handle data) {
  ldp_global* g = ldp_global_create(data);

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

  return (ldp_cfg_handle)g;
}

void ldp_cfg_close(ldp_cfg_handle g) {
  ldp_instance_handle data = g->user_data;

  LDP_ENTER(data,"ldp_cfg_close");
  ldp_global_delete(g);
  LDP_EXIT(data,"ldp_cfg_close");
}

ldp_return_enum ldp_cfg_global_get(ldp_cfg_handle handle,ldp_global* g,uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;

  LDP_ASSERT(global != NULL);

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

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

  if(flag & LDP_GLOBAL_CFG_LSR_IDENTIFIER) {
    memcpy(&(g->lsr_identifier),&(global->lsr_identifier),
      sizeof(ldp_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(ldp_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;
  }

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

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

  return LDP_SUCCESS;
}

ldp_return_enum ldp_cfg_global_test(ldp_cfg_handle handle,ldp_global* g,uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_return_enum retval = LDP_SUCCESS;

  LDP_ASSERT(global != NULL);

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

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

  if(global->admin_state == LDP_ENABLE &&
    (flag & LDP_GLOBAL_CFG_WHEN_DOWN))
    retval = LDP_FAILURE;

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

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

  return retval;
}

ldp_return_enum ldp_cfg_global_set(ldp_cfg_handle handle,ldp_global* g,uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_return_enum retval = LDP_FAILURE;

  LDP_ASSERT(global != NULL);

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

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

  if((global->admin_state == LDP_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(ldp_inet_addr));
  }
  if(flag & LDP_GLOBAL_CFG_ADMIN_STATE) {
    if(global->admin_state == LDP_ENABLE && g->admin_state == LDP_DISABLE) {
      ldp_global_shutdown(global);
    } else if(global->admin_state == LDP_DISABLE && g->admin_state ==
      LDP_ENABLE) {
      ldp_global_startup(global);
    }
  }
  if(flag & LDP_GLOBAL_CFG_TRANS_ADDR) {
    memcpy(&(global->transport_address),&(g->transport_address),
      sizeof(ldp_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;
    }
  }
  global->configuration_sequence_number++;
  retval = LDP_SUCCESS;

ldp_cfg_global_set_end:

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

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

  return retval;
}

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

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

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

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

  if(ldp_global_find_entity_index(global,e->index,&entity) != LDP_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_ADJ_COUNT) {
    ldp_adj* adj = LDP_LIST_HEAD(&entity->adj_root);
    int count = 0;
    while(adj != NULL) {
      count++;
      adj = LDP_LIST_NEXT(&entity->adj_root,adj,_entity);
    }
    e->adj_count = count;
  }
  if(flag & LDP_ENTITY_CFG_INHERIT_FLAG) {
    e->inherit_flag = entity->inherit_flag;
  }
  retval = LDP_SUCCESS;

ldp_cfg_entity_get_end:

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

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

  return retval;
}

ldp_return_enum ldp_cfg_entity_getnext(ldp_cfg_handle handle,ldp_entity* e,
  uint32_t flag) {
  ldp_global* g = (ldp_global*)handle;
  ldp_entity* entity = NULL;
  ldp_return_enum r = LDP_FAILURE;
  ldp_bool done = LDP_FALSE;
  int index;

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

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

  ldp_lock_get(g->global_lock);				/* LOCK */
  while(done == LDP_FALSE) {
    switch((r = ldp_global_find_entity_index(g,index,&entity))) {
      case LDP_SUCCESS:
      case LDP_END_OF_LIST:
        done = LDP_TRUE;
        break;
      case LDP_FAILURE:
        break;
      default:
        LDP_ASSERT(0);
    }
    index++;
  }
  ldp_lock_release(g->global_lock);			/* UNLOCK */

  if(r == LDP_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;
}

ldp_return_enum ldp_cfg_entity_test(ldp_cfg_handle handle,ldp_entity* e,uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_entity* entity = NULL;
  ldp_return_enum retval = LDP_FAILURE;

  LDP_ASSERT(global != NULL);

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

  ldp_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 = LDP_SUCCESS;
    goto ldp_cfg_entity_test_end;
  }

  if((entity == NULL) || 
    ((ldp_entity_is_active(entity) == LDP_TRUE) &&
    (flag & LDP_ENTITY_CFG_WHEN_DOWN)))
    goto ldp_cfg_entity_test_end;

  retval = LDP_SUCCESS;

ldp_cfg_entity_test_end:
  ldp_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 */
ldp_return_enum ldp_cfg_entity_set(ldp_cfg_handle handle,ldp_entity* e,uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_entity* entity = NULL;
  ldp_return_enum retval = LDP_FAILURE;

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

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

  ldp_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_entity_is_active(entity) == LDP_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(entity);
        break;
      case LDP_INDIRECT:
        ldp_entity_del_peer(entity);
        break;
      default:
        LDP_ASSERT(0);
    }
    _ldp_global_del_entity(global,entity);
    retval = LDP_SUCCESS;
    goto ldp_cfg_entity_set_end;
  }

  if(flag & LDP_ENTITY_CFG_SUB_INDEX) {
    if(entity->sub_index != 0) {
      /* unlink the old sub object */
      switch(entity->entity_type) {
        case LDP_DIRECT:
          ldp_entity_del_if(entity);
          break;
        case LDP_INDIRECT:
          ldp_entity_del_peer(entity);
          break;
        default:
          LDP_ASSERT(0);
      }
    }

    /* link the new sub object */
    switch(e->entity_type) {
      case LDP_DIRECT:
      {
        ldp_if* iff = NULL;
        if(ldp_global_find_if_index(global,e->sub_index,&iff) != LDP_SUCCESS) {
          LDP_PRINT(global->user_data,
            "ldp_cfg_entity_set: no such interface\n");
          if(flag & LDP_CFG_ADD) {
            _ldp_global_del_entity(global,entity);
          }
          goto ldp_cfg_entity_set_end;
        }

        if(ldp_entity_add_if(entity,iff) == LDP_FAILURE) {
          if(flag & LDP_CFG_ADD) {
            _ldp_global_del_entity(global,entity);
          }
        }
        break;
      }
      case LDP_INDIRECT:
      {
        ldp_peer* peer = NULL;

        if(ldp_global_find_peer_index(global,e->sub_index,&peer) != 
          LDP_SUCCESS) {
          LDP_PRINT(global->user_data,"ldp_cfg_entity_set: no such peer\n");
          if(flag & LDP_CFG_ADD) {
            _ldp_global_del_entity(global,entity);
          }
          goto ldp_cfg_entity_set_end;
        }

        if(ldp_entity_add_peer(entity,peer) == LDP_FAILURE) {
          if(flag & LDP_CFG_ADD) {
            _ldp_global_del_entity(global,entity);
          }
          goto ldp_cfg_entity_set_end;
        }
        break;
      }
      default:
        LDP_ASSERT(0);
    }
  }

  if(flag & LDP_ENTITY_CFG_TRANS_ADDR) {
    if(e->transport_address.protocol == 0) {
      entity->inherit_flag |= LDP_ENTITY_CFG_TRANS_ADDR;
    } else {
      entity->inherit_flag &= ~LDP_ENTITY_CFG_TRANS_ADDR;
    }
    memcpy(&entity->transport_address,&e->transport_address,
      sizeof(ldp_inet_addr));;
  }
  if(flag & LDP_ENTITY_CFG_PROTO_VER) {
    entity->protocol_version = e->protocol_version;
  }
  if(flag & LDP_ENTITY_CFG_REMOTE_TCP) {
    entity->remote_tcp_port = e->remote_tcp_port;
  }
  if(flag & LDP_ENTITY_CFG_REMOTE_UDP) {
    entity->remote_udp_port = e->remote_udp_port;
  }
  if(flag & LDP_ENTITY_CFG_MAX_PDU) {
    entity->max_pdu = e->max_pdu;
  }
  if(flag & LDP_ENTITY_CFG_KEEPALIVE_TIMER) {
    if(e->transport_address.protocol == 0) {
      entity->inherit_flag |= LDP_ENTITY_CFG_KEEPALIVE_TIMER;
    } else {
      entity->inherit_flag &= ~LDP_ENTITY_CFG_KEEPALIVE_TIMER;
    }
    entity->keepalive_timer = e->keepalive_timer;
  }
  if(flag & LDP_ENTITY_CFG_KEEPALIVE_INTERVAL) {
    if(e->transport_address.protocol == 0) {
      entity->inherit_flag |= LDP_ENTITY_CFG_KEEPALIVE_INTERVAL;
    } else {
      entity->inherit_flag &= ~LDP_ENTITY_CFG_KEEPALIVE_INTERVAL;
    }
    entity->keepalive_interval = e->keepalive_interval;
  }
  if(flag & LDP_ENTITY_CFG_HELLOTIME_TIMER) {
    if(e->transport_address.protocol == 0) {
      entity->inherit_flag |= LDP_ENTITY_CFG_HELLOTIME_TIMER;
    } else {
      entity->inherit_flag &= ~LDP_ENTITY_CFG_HELLOTIME_TIMER;
    }
    entity->hellotime_timer = e->hellotime_timer;
  }
  if(flag & LDP_ENTITY_CFG_HELLOTIME_INTERVAL) {
    if(e->transport_address.protocol == 0) {
      entity->inherit_flag |= LDP_ENTITY_CFG_HELLOTIME_INTERVAL;
    } else {
      entity->inherit_flag &= ~LDP_ENTITY_CFG_HELLOTIME_INTERVAL;
    }
    entity->hellotime_interval = e->hellotime_interval;
  }
  if(flag & LDP_ENTITY_CFG_SESSION_SETUP_COUNT) {
    entity->session_setup_count = e->session_setup_count;
  }
  if(flag & LDP_ENTITY_CFG_SESSION_BACKOFF_TIMER) {
    entity->session_backoff_timer = e->session_backoff_timer;
  }
  if(flag & LDP_ENTITY_CFG_DISTRIBUTION_MODE) {
    entity->label_distribution_mode = e->label_distribution_mode;
  }
  if(flag & LDP_ENTITY_CFG_PATHVECTOR_LIMIT) {
    entity->path_vector_limit = e->path_vector_limit;
  }
  if(flag & LDP_ENTITY_CFG_HOPCOUNT_LIMIT) {
    entity->hop_count_limit = e->hop_count_limit;
  }
  if(flag & LDP_ENTITY_CFG_REQUEST_COUNT) {
    entity->label_request_count = e->label_request_count;
  }
  if(flag & LDP_ENTITY_CFG_REQUEST_TIMER) {
    entity->label_request_timer = e->label_request_timer;
  }
  if(flag & LDP_ENTITY_CFG_TYPE) {
    entity->entity_type = e->entity_type;
  }
  if(flag & LDP_ENTITY_CFG_ADMIN_STATE) {
    if(ldp_entity_is_active(entity) == LDP_TRUE && 
      e->admin_state == LDP_DISABLE) {
      if(ldp_entity_shutdown(global,entity,0) == LDP_FAILURE) {
        goto ldp_cfg_entity_set_end;
      }
    } else if(ldp_entity_is_active(entity) == LDP_FALSE &&
      e->admin_state == LDP_ENABLE && ldp_entity_is_ready(entity) == LDP_TRUE) {
      if(ldp_entity_startup(global,entity) == LDP_FAILURE) {
        goto ldp_cfg_entity_set_end;
      }
    } else {
      LDP_PRINT(global->user_data,"ldp_cfg_entity_set: entity not ready\n");
      goto ldp_cfg_entity_set_end;
    }
  }
  if(flag & LDP_ENTITY_CFG_INHERIT_FLAG) {
    entity->inherit_flag = e->inherit_flag;
  }
  global->configuration_sequence_number++;
  retval = LDP_SUCCESS;

ldp_cfg_entity_set_end:
  ldp_lock_release(global->global_lock);			/* UNLOCK */

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

  return retval;
}

ldp_return_enum ldp_cfg_if_get(ldp_cfg_handle handle,ldp_if* i,uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_if* iff = NULL;
  ldp_return_enum retval = LDP_FAILURE;

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

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

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

  if(ldp_global_find_if_index(global,i->index,&iff) != LDP_SUCCESS)
    goto ldp_cfg_if_get_end;

  if(flag & LDP_IF_CFG_NAME) {
    strncpy(i->name,iff->name,LDP_MAX_IF_NAME);
  }
  if(flag & LDP_IF_CFG_LABEL_SPACE) {
    i->label_space = iff->label_space;
  }
  if(flag & LDP_IF_CFG_ENTITY_INDEX) {
    i->entity_index = iff->entity->index;
  }
  if(flag & LDP_IF_CFG_OPER_STATE) {
    i->oper_state = iff->oper_state;
  }
  if(flag & LDP_IF_CFG_LOCAL_SOURCE_ADDR) {
    memcpy(&i->local_source_address,&iff->local_source_address,
      sizeof(ldp_inet_addr));
  }
  retval = LDP_SUCCESS;

ldp_cfg_if_get_end:
  ldp_lock_release(global->global_lock);			/* UNLOCK */

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

  return retval;
}

ldp_return_enum ldp_cfg_if_getnext(ldp_cfg_handle handle,ldp_if* i,
  uint32_t flag) {
  ldp_global* g = (ldp_global*)handle;
  ldp_if* iff = NULL;
  ldp_return_enum r = LDP_FAILURE;
  ldp_bool done = LDP_FALSE;
  int index;

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

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

  ldp_lock_get(g->global_lock);				/* LOCK */
  while(done == LDP_FALSE) {
    switch((r = ldp_global_find_if_index(g,index,&iff))) {
      case LDP_SUCCESS:
      case LDP_END_OF_LIST:
        done = LDP_TRUE;
        break;
      case LDP_FAILURE:
        break;
      default:
        LDP_ASSERT(0);
    }
    index++;
  }
  ldp_lock_release(g->global_lock);			/* UNLOCK */
 
  if(r == LDP_SUCCESS) {
    i->index = iff->index;
    LDP_EXIT(g->user_data,"ldp_cfg_if_getnext");
    return ldp_cfg_if_get(g,i,flag);
  }
  LDP_EXIT(g->user_data,"ldp_cfg_if_getnext");
  return r;
}

ldp_return_enum ldp_cfg_if_test(ldp_cfg_handle handle,ldp_if* i,uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_if* iff = NULL;
  ldp_return_enum retval = LDP_FAILURE;

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

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

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

  if(!(flag & LDP_CFG_ADD)) {
    ldp_global_find_if_index(global,i->index,&iff);
  } else {
    retval = LDP_SUCCESS;
    goto ldp_cfg_if_test_end;
  }

  if((iff == NULL) ||
    ((ldp_if_is_active(iff) == LDP_TRUE) &&
    (flag & LDP_IF_CFG_WHEN_DOWN)))
    goto ldp_cfg_if_test_end;

  if(flag & LDP_CFG_DEL) {
    if(iff->entity != NULL)
      goto ldp_cfg_if_test_end;
  }
  retval = LDP_SUCCESS;

ldp_cfg_if_test_end:
  ldp_lock_release(global->global_lock);			/* UNLOCK */

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

  return retval;
}

ldp_return_enum ldp_cfg_if_set(ldp_cfg_handle handle,ldp_if* i,uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_if* iff = NULL;
  ldp_return_enum retval = LDP_FAILURE;

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

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

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

  if(flag & LDP_CFG_ADD) {
    if((iff = ldp_if_create()) == NULL) {
      goto ldp_cfg_if_set_end;
    }
    if(ldp_if_handle_verify(global->ifmgr_handle,i->handle) == LDP_FALSE) {
      i->handle = ldp_ifmgr_open_if(global->ifmgr_handle,i->name);
    }
    iff->handle = i->handle;
    i->index = iff->index;
    strncpy(iff->name,i->name,LDP_MAX_IF_NAME);
    _ldp_global_add_if(global,iff);
  } else {
    ldp_global_find_if_index(global,i->index,&iff);
  }

  if((iff == NULL) ||
    ((ldp_if_is_active(iff) == LDP_TRUE) &&
    (flag & LDP_IF_CFG_WHEN_DOWN)))
    goto ldp_cfg_if_set_end;

  if(flag & LDP_CFG_DEL) {
    if(iff->entity != NULL) {
      goto ldp_cfg_if_set_end;
    }

    if(iff->range != NULL)
      ldp_if_del_range(iff);

    _ldp_global_del_if(global,iff);
    retval = LDP_SUCCESS;
    goto ldp_cfg_if_set_end;
  }
  if(flag & LDP_IF_CFG_INDEX) {
    iff->index = i->index;
  }
  if(flag & LDP_IF_CFG_LABEL_SPACE) {
    ldp_range* range = NULL;

    range = ldp_global_find_range_label_space(global,i->label_space);
    if(range == NULL)
      ldp_if_del_range(iff);
    else
      ldp_if_add_range(iff,range);
  }
  global->configuration_sequence_number++;
  retval = LDP_SUCCESS;

ldp_cfg_if_set_end:
  ldp_lock_release(global->global_lock);			/* UNLOCK */

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

  return retval;
}

ldp_return_enum ldp_cfg_attr_get(ldp_cfg_handle handle,ldp_attr* a,
  uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_attr* attr = NULL;
  ldp_return_enum retval = LDP_FAILURE;

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

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

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

  if(ldp_global_find_attr_index(global,a->index,&attr) != LDP_SUCCESS)
    goto ldp_cfg_attr_get_end;

  if(flag & LDP_ATTR_CFG_STATE) {
    a->state = attr->state;
  }
  if(flag & LDP_ATTR_CFG_FEC) {
    ldp_attr2ldp_attr(attr,a,LDP_ATTR_FEC);
  }
  if(flag & LDP_ATTR_CFG_LABEL) {
    ldp_attr2ldp_attr(attr,a,LDP_ATTR_LABEL);
  }
  if(flag & LDP_ATTR_CFG_HOP_COUNT) {
    ldp_attr2ldp_attr(attr,a,LDP_ATTR_HOPCOUNT);
  }
  if(flag & LDP_ATTR_CFG_PATH) {
    ldp_attr2ldp_attr(attr,a,LDP_ATTR_PATH);
  }
  if(flag & LDP_ATTR_CFG_SESSION_INDEX) {
    a->session_index = (attr->session)?(attr->session->index):0;
  }
  if(flag & LDP_ATTR_CFG_INLABEL_INDEX) {
    a->inlabel_index = (attr->inlabel)?(attr->inlabel->index):0;
  }
  if(flag & LDP_ATTR_CFG_OUTLABEL_INDEX) {
    a->outlabel_index = (attr->outlabel)?(attr->outlabel->index):0;
  }
  retval = LDP_SUCCESS;

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

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

  return retval;
}

ldp_return_enum ldp_cfg_attr_getnext(ldp_cfg_handle handle,ldp_attr* a,
  uint32_t flag) {
  ldp_global* g = (ldp_global*)handle;
  ldp_attr* attr = NULL;
  ldp_return_enum r = LDP_FAILURE;
  ldp_bool done = LDP_FALSE;
  int index;

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

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

  ldp_lock_get(g->global_lock);				/* LOCK */
  while(done == LDP_FALSE) {
    switch((r = ldp_global_find_attr_index(g,index,&attr))) {
      case LDP_SUCCESS:
      case LDP_END_OF_LIST:
        done = LDP_TRUE;
        break;
      case LDP_FAILURE:
        break;
      default:
        LDP_ASSERT(0);
    }
    index++;
  }
  ldp_lock_release(g->global_lock);			/* UNLOCK */
 
  if(r == LDP_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;
}

ldp_return_enum ldp_cfg_peer_get(ldp_cfg_handle handle,ldp_peer* p,
  uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_peer* peer = NULL;
  ldp_return_enum retval = LDP_FAILURE;

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

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

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

  if(ldp_global_find_peer_index(global,p->index,&peer) != LDP_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(ldp_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,LDP_MAX_IF_NAME);
  }
  if(flag & LDP_PEER_CFG_LOCAL_SOURCE_ADDR) {
    memcpy(&p->local_source_address,&peer->local_source_address,
      sizeof(ldp_inet_addr));
  }
  retval = LDP_SUCCESS;

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

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

  return retval;
}

ldp_return_enum ldp_cfg_peer_getnext(ldp_cfg_handle handle,ldp_peer* p,
  uint32_t flag) {
  ldp_global* g = (ldp_global*)handle;
  ldp_peer* peer = NULL;
  ldp_return_enum r = LDP_FAILURE;
  ldp_bool done = LDP_FALSE;
  int index;

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

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

  ldp_lock_get(g->global_lock);				/* LOCK */
  while(done == LDP_FALSE) {
    switch((r = ldp_global_find_peer_index(g,index,&peer))) {
      case LDP_SUCCESS:
      case LDP_END_OF_LIST:
        done = LDP_TRUE;
        break;
      case LDP_FAILURE:
        break;
      default:
        LDP_ASSERT(0);
    }
    index++;
  }
  ldp_lock_release(g->global_lock);			/* UNLOCK */
 
  if(r == LDP_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;
}

ldp_return_enum ldp_cfg_peer_test(ldp_cfg_handle handle,ldp_peer* p,uint32_t flag) {
  // ldp_global* g = (ldp_global*)handle;
  return LDP_SUCCESS;
}

ldp_return_enum ldp_cfg_peer_set(ldp_cfg_handle handle,ldp_peer* p,
  uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_peer* peer = NULL;
  ldp_return_enum retval = LDP_FAILURE;

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

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

  ldp_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) == LDP_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;
    }

    if(peer->range != NULL)
      ldp_peer_del_range(peer);

    _ldp_global_del_peer(global,peer);
    retval = LDP_SUCCESS;
    goto ldp_cfg_peer_set_end;
  }
  if(flag & LDP_PEER_CFG_LABEL_SPACE) {
    ldp_range* range = NULL;

    range = ldp_global_find_range_label_space(global,p->label_space);
    if(range == NULL)
      ldp_peer_del_range(peer);
    else
      ldp_peer_add_range(peer,range);
  }
  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(ldp_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,LDP_MAX_IF_NAME);
  }
  global->configuration_sequence_number++;
  retval = LDP_SUCCESS;

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

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

  return retval;
}

ldp_return_enum ldp_cfg_range_get(ldp_cfg_handle handle,ldp_range* r,uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_range* range = NULL;
  ldp_return_enum retval = LDP_FAILURE;

  LDP_ASSERT(global != NULL && r != NULL);

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

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

  range = ldp_global_find_range_label_space(global,r->label_space);
  if(range == NULL)
    goto ldp_cfg_range_get_end;

  if(flag & LDP_RANGE_CFG_LABEL_SPACE) {
    r->label_space = range->label_space;
  }
  if(flag & LDP_RANGE_CFG_TYPE) {
    r->type = range->type;
  }
  if(flag & LDP_RANGE_CFG_GEN_MIN) {
    if(range->type != LDP_GENERIC)
      goto ldp_cfg_range_get_end;

    r->min.gen = range->min.gen;
  }
  if(flag & LDP_RANGE_CFG_GEN_MAX) {
    if(range->type != LDP_GENERIC)
      goto ldp_cfg_range_get_end;

    r->max.gen = range->max.gen;
  }
  if(flag & LDP_RANGE_CFG_ATM_VPI_MIN) {
    if(range->type != LDP_ATM_VP && range->type != LDP_ATM_VP_VC)
      goto ldp_cfg_range_get_end;

    r->min.atm.vpi = range->min.atm.vpi;
  }
  if(flag & LDP_RANGE_CFG_ATM_VPI_MAX) {
    if(range->type != LDP_ATM_VP && range->type != LDP_ATM_VP_VC)
      goto ldp_cfg_range_get_end;

    r->max.atm.vpi = range->max.atm.vpi;
  }
  if(flag & LDP_RANGE_CFG_ATM_VCI_MIN) {
    if(range->type != LDP_ATM_VC && range->type != LDP_ATM_VP_VC)
      goto ldp_cfg_range_get_end;

    r->min.atm.vci = range->min.atm.vci;
  }
  if(flag & LDP_RANGE_CFG_ATM_VCI_MAX) {
    if(range->type != LDP_ATM_VC && range->type != LDP_ATM_VP_VC)
      goto ldp_cfg_range_get_end;

    r->max.atm.vci = range->max.atm.vci;
  }
  if(flag & LDP_RANGE_CFG_FR_MIN) {
    if(range->type != LDP_FR_10 && range->type != LDP_FR_24)
      goto ldp_cfg_range_get_end;

    r->min.fr = range->min.fr;
  }
  if(flag & LDP_RANGE_CFG_FR_MAX) {
    if(range->type != LDP_FR_10 && range->type != LDP_FR_24)
      goto ldp_cfg_range_get_end;

    r->max.fr = range->max.fr;
  }
  retval = LDP_SUCCESS;

ldp_cfg_range_get_end:
  ldp_lock_release(global->global_lock);			/* UNLOCK */

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

  return retval;
}

ldp_return_enum ldp_cfg_range_test(ldp_cfg_handle handle,ldp_range* r,uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_range* range = NULL;
  ldp_return_enum retval = LDP_FAILURE;

  LDP_ASSERT(global != NULL && r != NULL);

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

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

  if(!(flag & LDP_CFG_ADD)) {
    range = ldp_global_find_range_label_space(global,r->label_space);
  } else {
    retval = LDP_SUCCESS;
    goto ldp_cfg_range_test_end;
  }

  if((range == NULL) ||
    ((ldp_range_is_active(range) == LDP_TRUE) &&
    (flag & LDP_RANGE_CFG_WHEN_DOWN)))
    goto ldp_cfg_range_test_end;

  retval = LDP_SUCCESS;

ldp_cfg_range_test_end:
  ldp_lock_release(global->global_lock);			/* UNLOCK */

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

  return retval;
}

ldp_return_enum ldp_cfg_range_set(ldp_cfg_handle handle,ldp_range* r,uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_range* range = NULL;
  ldp_return_enum retval = LDP_FAILURE;

  LDP_ASSERT(global != NULL && r != NULL);

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

  ldp_lock_get(global->global_lock);

  if(flag & LDP_CFG_ADD) {
    if((range = ldp_range_create(r->label_space,r->type)) == NULL) {
      goto ldp_cfg_range_set_end;
    }
    _ldp_global_add_range(global,range);
  } else {
    range = ldp_global_find_range_label_space(global,r->label_space);
  }

  if((range == NULL) ||
    ((ldp_range_is_active(range) == LDP_TRUE) &&
    (flag & LDP_RANGE_CFG_WHEN_DOWN)))
    goto ldp_cfg_range_set_end;

  if(flag & LDP_CFG_DEL) {
    /* JLEU : for each if and peer unlink */
    _ldp_global_del_range(global,range);
    retval = LDP_SUCCESS;
    goto ldp_cfg_range_set_end;
  }

  if(flag & LDP_RANGE_CFG_LABEL_SPACE) {
    range->label_space = r->label_space;
  }
  if(flag & LDP_RANGE_CFG_TYPE) {
    range->type = r->type;
  }
  if(flag & LDP_RANGE_CFG_GEN_MIN) {
    if(r->type != LDP_GENERIC)
      goto ldp_cfg_range_set_end;

    range->min.gen = r->min.gen;
  }
  if(flag & LDP_RANGE_CFG_GEN_MAX) {
    if(r->type != LDP_GENERIC)
      goto ldp_cfg_range_set_end;

    range->max.gen = r->max.gen;
  }
  if(flag & LDP_RANGE_CFG_ATM_VPI_MIN) {
    if(r->type != LDP_ATM_VP && r->type != LDP_ATM_VP_VC)
      goto ldp_cfg_range_set_end;

    range->min.atm.vpi = r->min.atm.vpi;
  }
  if(flag & LDP_RANGE_CFG_ATM_VPI_MAX) {
    if(r->type != LDP_ATM_VP && r->type != LDP_ATM_VP_VC)
      goto ldp_cfg_range_set_end;

    range->max.atm.vpi = r->max.atm.vpi;
  }
  if(flag & LDP_RANGE_CFG_ATM_VCI_MIN) {
    if(r->type != LDP_ATM_VC && r->type != LDP_ATM_VP_VC)
      goto ldp_cfg_range_set_end;

    range->min.atm.vci = r->min.atm.vci;
  }
  if(flag & LDP_RANGE_CFG_ATM_VCI_MAX) {
    if(r->type != LDP_ATM_VC && r->type != LDP_ATM_VP_VC)
      goto ldp_cfg_range_set_end;

    range->max.atm.vci = r->max.atm.vci;
  }
  if(flag & LDP_RANGE_CFG_FR_MIN) {
    if(r->type != LDP_FR_10 && r->type != LDP_FR_24)
      goto ldp_cfg_range_set_end;

    range->min.fr = r->min.fr;
  }
  if(flag & LDP_RANGE_CFG_FR_MAX) {
    if(r->type != LDP_FR_10 && r->type != LDP_FR_24)
      goto ldp_cfg_range_set_end;

    range->max.fr = r->max.fr;
  }
  global->configuration_sequence_number++;
  retval = LDP_SUCCESS;

ldp_cfg_range_set_end:
  ldp_lock_release(global->global_lock);			/* UNLOCK */

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

  return retval;
}

ldp_return_enum ldp_cfg_adj_get(ldp_cfg_handle handle,ldp_adj* a,
  uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_adj* adj = NULL;
  ldp_return_enum retval = LDP_FAILURE;

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

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

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

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

  if(flag & LDP_ADJ_CFG_REMOTE_TRADDR) {
    memcpy(&a->remote_transport_address,&adj->remote_transport_address,
      sizeof(ldp_inet_addr));
  }
  if(flag & LDP_ADJ_CFG_REMOTE_SRCADDR) {
    memcpy(&a->remote_source_address,&adj->remote_source_address,
      sizeof(ldp_inet_addr));
  }
  if(flag & LDP_ADJ_CFG_REMOTE_LSRADDR) {
    memcpy(&a->remote_lsr_address,&adj->remote_lsr_address,
      sizeof(ldp_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_REMOTE_ENTITY_INDEX) {
    a->entity_index = adj->entity->index;
  }
  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;
  }
  if(flag & LDP_ADJ_CFG_BACKOFF) {
    a->backoff = adj->backoff;
  }
  retval = LDP_SUCCESS;

ldp_cfg_adj_get_end:

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

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

  return retval;
}

ldp_return_enum ldp_cfg_adj_getnext(ldp_cfg_handle handle,ldp_adj* a,
  uint32_t flag) {
  ldp_global* g = (ldp_global*)handle;
  ldp_adj* adj = NULL;
  ldp_return_enum r = LDP_FAILURE;
  ldp_bool done = LDP_FALSE;
  int index;

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

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

  ldp_lock_get(g->global_lock);                         /* LOCK */
  while(done == LDP_FALSE) {
    switch((r = ldp_global_find_adj_index(g,index,&adj))) {
      case LDP_SUCCESS:
      case LDP_END_OF_LIST:
        done = LDP_TRUE;
        break;
      case LDP_FAILURE:
        break;
      default:
        LDP_ASSERT(0);
    }
    index++;
  }
  ldp_lock_release(g->global_lock);                     /* UNLOCK */

  if(r == LDP_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;
}

ldp_return_enum ldp_cfg_session_get(ldp_cfg_handle handle,ldp_session* s,
  uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_session* session = NULL;
  ldp_return_enum retval = LDP_FAILURE;

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

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

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

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

  if(flag & LDP_SESSION_CFG_STATE) {
    s->state = session->state;
  }
  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.protocol = session->remote_dest.addr.protocol;
    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_ENTITY_INDEX) {
    s->entity_index = (session->entity)?(session->entity->index):0;
  }
  if(flag & LDP_SESSION_CFG_ADJ_INDEX) {
    s->adj_index = (session->adj)?(session->adj->index):0;
  }
  retval = LDP_SUCCESS;

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

  LDP_EXIT(global->user_data,"ldp_cfg_session_get");
  return retval;
}

ldp_return_enum ldp_cfg_session_getnext(ldp_cfg_handle handle,ldp_session* s,
  uint32_t flag) {
  ldp_global* g = (ldp_global*)handle;
  ldp_session* ses = NULL;
  ldp_return_enum r = LDP_FAILURE;
  ldp_bool done = LDP_FALSE;
  int index;

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

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

  ldp_lock_get(g->global_lock);				/* LOCK */
  while(done == LDP_FALSE) {
    switch((r = ldp_global_find_session_index(g,index,&ses))) {
      case LDP_SUCCESS:
      case LDP_END_OF_LIST:
        done = LDP_TRUE;
        break;
      case LDP_FAILURE:
        break;
      default:
        LDP_ASSERT(0);
    }
    index++;
  }
  ldp_lock_release(g->global_lock);			/* UNLOCK */
 
  if(r == LDP_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;
}

ldp_return_enum ldp_cfg_inlabel_get(ldp_cfg_handle handle,ldp_inlabel* i,
  uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_inlabel* inlabel = NULL;
  ldp_return_enum retval = LDP_FAILURE;

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

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

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

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

  if(flag & LDP_INLABEL_CFG_LABELSPACE) {
    i->label_space = inlabel->label_space;
  }
  if(flag & LDP_INLABEL_CFG_LABEL) {
    memcpy(&i->l,&inlabel->l,sizeof(ldp_label));
  }
  if(flag & LDP_INLABEL_CFG_OUTLABEL_INDEX) {
    i->outlabel_index = (inlabel->outlabel)?(inlabel->outlabel->index):0;
  }

  retval = LDP_SUCCESS;

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

  LDP_EXIT(global->user_data,"ldp_cfg_inlabel_get");
  return retval;
}

ldp_return_enum ldp_cfg_inlabel_getnext(ldp_cfg_handle handle,ldp_inlabel* i,
  uint32_t flag) {
  ldp_global* g = (ldp_global*)handle;
  ldp_inlabel* inlabel = NULL;
  ldp_return_enum r = LDP_FAILURE;
  ldp_bool done = LDP_FALSE;
  int index;

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

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

  ldp_lock_get(g->global_lock);				/* LOCK */
  while(done == LDP_FALSE) {
    switch((r = ldp_global_find_inlabel_index(g,index,&inlabel))) {
      case LDP_SUCCESS:
      case LDP_END_OF_LIST:
        done = LDP_TRUE;
        break;
      case LDP_FAILURE:
        break;
      default:
        LDP_ASSERT(0);
    }
    index++;
  }
  ldp_lock_release(g->global_lock);			/* UNLOCK */
 
  if(r == LDP_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;
}

ldp_return_enum ldp_cfg_outlabel_get(ldp_cfg_handle handle,ldp_outlabel* o,
  uint32_t flag) {
  ldp_global* global = (ldp_global*)handle;
  ldp_outlabel* outlabel = NULL;
  ldp_return_enum retval = LDP_FAILURE;

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

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

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

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

  if(flag & LDP_OUTLABEL_CFG_ADDR_INDEX) {
    o->addr_index = (outlabel->next_hop)?(outlabel->next_hop->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->l,&outlabel->l,sizeof(ldp_label));
  }
  if(flag & LDP_OUTLABEL_CFG_MERGE_COUNT) {
    o->merge_count = outlabel->merge_count;
  }

  retval = LDP_SUCCESS;

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

  LDP_EXIT(global->user_data,"ldp_cfg_outlabel_get");
  return retval;
}

ldp_return_enum ldp_cfg_outlabel_getnext(ldp_cfg_handle handle,ldp_outlabel* o,
  uint32_t flag) {
  ldp_global* g = (ldp_global*)handle;
  ldp_outlabel* outlabel = NULL;
  ldp_return_enum r = LDP_FAILURE;
  ldp_bool done = LDP_FALSE;
  int index;

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

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

  ldp_lock_get(g->global_lock);				/* LOCK */
  while(done == LDP_FALSE) {
    switch((r = ldp_global_find_outlabel_index(g,index,&outlabel))) {
      case LDP_SUCCESS:
      case LDP_END_OF_LIST:
        done = LDP_TRUE;
        break;
      case LDP_FAILURE:
        break;
      default:
        LDP_ASSERT(0);
    }
    index++;
  }
  ldp_lock_release(g->global_lock);			/* UNLOCK */
 
  if(r == LDP_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;
}