ldp/ldp_cfg.c

   1
   2 /*
   3  *  Copyright (C) James R. Leu 2000
   4  *  jleu@mindspring.com
   5  *
   6  *  This software is covered under the LGPL, for more
   7  *  info check out http://www.gnu.org/copyleft/lgpl.html
   8  */
   9
  10 #include "ldp_struct.h"
  11 #include "ldp_cfg.h"
  12 #include "ldp_global.h"
  13 #include "ldp_entity.h"
  14 #include "ldp_attr.h"
  15 #include "ldp_if.h"
  16 #include "ldp_peer.h"
  17 #include "ldp_fec.h"
  18 #include "ldp_addr.h"
  19 #include "ldp_nexthop.h"
  20 #include "ldp_tunnel.h"
  21 #include "ldp_resource.h"
  22 #include "mpls_ifmgr_impl.h"
  23 #include "ldp_label_mapping.h"
  24 #include "ldp_hop.h"
  25 #include "ldp_hop_list.h"
  26 #include "mpls_lock_impl.h"
  27 #include "mpls_socket_impl.h"
  28 #include "mpls_trace_impl.h"
  29 #include "mpls_tree_impl.h"
  30
  31 mpls_cfg_handle ldp_cfg_open(mpls_instance_handle data)
  32 {
  33   ldp_global *g = ldp_global_create(data);
  34
  35   LDP_ENTER(data, "ldp_cfg_open");
  36   LDP_EXIT(data, "ldp_cfg_open");
  37
  38   return (mpls_cfg_handle) g;
  39 }
  40
  41 void ldp_cfg_close(mpls_cfg_handle g)
  42 {
  43   LDP_ENTER((mpls_instance_handle) g->user_data, "ldp_cfg_close");
  44   ldp_global_delete(g);
  45   LDP_EXIT((mpls_instance_handle) g->user_data, "ldp_cfg_close");
  46 }
  47
  48 /******************* GLOBAL **********************/
  49
  50 void ldp_cfg_global_attr(mpls_cfg_handle handle) {
  51   ldp_global *global = (ldp_global *) handle;
  52   ldp_attr *attr = MPLS_LIST_HEAD(&global->attr);
  53   while (attr) {
  54     if (attr->state == LDP_LSP_STATE_MAP_SENT && attr->ds_attr) {
  55       LDP_PRINT(global->user_data, "%p(%s) xc to %p(%s)", attr,
  56         attr->session->session_name, attr->ds_attr,
  57         attr->ds_attr->session->session_name);
  58     }
  59     attr = MPLS_LIST_NEXT(&global->attr, attr, _global);
  60   }
  61 }
  62
  63 mpls_return_enum ldp_cfg_global_get(mpls_cfg_handle handle, ldp_global * g,
  64   uint32_t flag)
  65 {
  66   ldp_global *global = (ldp_global *) handle;
  67
  68   MPLS_ASSERT(global !=NULL);
  69
  70   LDP_ENTER(global->user_data, "ldp_cfg_global_get");
  71
  72   mpls_lock_get(global->global_lock); /* LOCK */
  73
  74   if (flag & LDP_GLOBAL_CFG_LSR_IDENTIFIER) {
  75     memcpy(&(g->lsr_identifier), &(global->lsr_identifier),
  76       sizeof(mpls_inet_addr));
  77   }
  78   if (flag & LDP_GLOBAL_CFG_ADMIN_STATE) {
  79     g->admin_state = global->admin_state;
  80   }
  81   if (flag & LDP_GLOBAL_CFG_CONTROL_MODE) {
  82     g->lsp_control_mode = global->lsp_control_mode;
  83   }
  84   if (flag & LDP_GLOBAL_CFG_RETENTION_MODE) {
  85     g->label_retention_mode = global->label_retention_mode;
  86   }
  87   if (flag & LDP_GLOBAL_CFG_REPAIR_MODE) {
  88     g->lsp_repair_mode = global->lsp_repair_mode;
  89   }
  90   if (flag & LDP_GLOBAL_CFG_PROPOGATE_RELEASE) {
  91     g->propagate_release = global->propagate_release;
  92   }
  93   if (flag & LDP_GLOBAL_CFG_LABEL_MERGE) {
  94     g->label_merge = global->label_merge;
  95   }
  96   if (flag & LDP_GLOBAL_CFG_LOOP_DETECTION_MODE) {
  97     g->loop_detection_mode = global->loop_detection_mode;
  98   }
  99   if (flag & LDP_GLOBAL_CFG_TTLLESS_DOMAIN) {
 100     g->ttl_less_domain = global->ttl_less_domain;
 101   }
 102   if (flag & LDP_GLOBAL_CFG_LOCAL_TCP_PORT) {
 103     g->local_tcp_port = global->local_tcp_port;
 104   }
 105   if (flag & LDP_GLOBAL_CFG_LOCAL_UDP_PORT) {
 106     g->local_udp_port = global->local_udp_port;
 107   }
 108   if (flag & LDP_GLOBAL_CFG_TRANS_ADDR) {
 109     memcpy(&(g->transport_address), &(global->transport_address),
 110       sizeof(mpls_inet_addr));
 111   }
 112   if (flag & LDP_GLOBAL_CFG_KEEPALIVE_TIMER) {
 113     g->keepalive_timer = global->keepalive_timer;
 114   }
 115   if (flag & LDP_GLOBAL_CFG_KEEPALIVE_INTERVAL) {
 116     g->keepalive_interval = global->keepalive_interval;
 117   }
 118   if (flag & LDP_GLOBAL_CFG_HELLOTIME_TIMER) {
 119     g->hellotime_timer = global->hellotime_timer;
 120   }
 121   if (flag & LDP_GLOBAL_CFG_HELLOTIME_INTERVAL) {
 122     g->hellotime_interval = global->hellotime_interval;
 123   }
 124 #if MPLS_USE_LSR
 125   if (flag & LDP_GLOBAL_CFG_LSR_HANDLE) {
 126     g->lsr_handle = global->lsr_handle;
 127   }
 128 #endif
 129
 130   mpls_lock_release(global->global_lock); /* UNLOCK */
 131
 132   LDP_EXIT(global->user_data, "ldp_cfg_global_get");
 133
 134   return MPLS_SUCCESS;
 135 }
 136
 137 mpls_return_enum ldp_cfg_global_test(mpls_cfg_handle handle, ldp_global * g,
 138   uint32_t flag)
 139 {
 140   ldp_global *global = (ldp_global *) handle;
 141   mpls_return_enum retval = MPLS_SUCCESS;
 142
 143   MPLS_ASSERT(global !=NULL);
 144
 145   LDP_ENTER(global->user_data, "ldp_cfg_global_test");
 146
 147   mpls_lock_get(global->global_lock); /* LOCK */
 148
 149   if (global->admin_state == MPLS_ADMIN_ENABLE && (flag & LDP_GLOBAL_CFG_WHEN_DOWN))
 150     retval = MPLS_FAILURE;
 151
 152   mpls_lock_release(global->global_lock); /* UNLOCK */
 153
 154   LDP_EXIT(global->user_data, "ldp_cfg_global_test");
 155
 156   return retval;
 157 }
 158
 159 mpls_return_enum ldp_cfg_global_set(mpls_cfg_handle handle, ldp_global * g,
 160   uint32_t flag)
 161 {
 162   ldp_global *global = (ldp_global *) handle;
 163   mpls_return_enum retval = MPLS_FAILURE;
 164
 165   MPLS_ASSERT(global !=NULL);
 166
 167   LDP_ENTER(global->user_data, "ldp_cfg_global_set");
 168
 169   mpls_lock_get(global->global_lock); /* LOCK */
 170
 171   if ((global->admin_state == MPLS_ADMIN_ENABLE && (flag & LDP_GLOBAL_CFG_WHEN_DOWN)))
 172     goto ldp_cfg_global_set_end;
 173
 174   if (flag & LDP_GLOBAL_CFG_CONTROL_MODE) {
 175     global->lsp_control_mode = g->lsp_control_mode;
 176   }
 177   if (flag & LDP_GLOBAL_CFG_RETENTION_MODE) {
 178     global->label_retention_mode = g->label_retention_mode;
 179   }
 180   if (flag & LDP_GLOBAL_CFG_REPAIR_MODE) {
 181     global->lsp_repair_mode = g->lsp_repair_mode;
 182   }
 183   if (flag & LDP_GLOBAL_CFG_PROPOGATE_RELEASE) {
 184     global->propagate_release = g->propagate_release;
 185   }
 186   if (flag & LDP_GLOBAL_CFG_LABEL_MERGE) {
 187     global->label_merge = g->label_merge;
 188   }
 189   if (flag & LDP_GLOBAL_CFG_LOOP_DETECTION_MODE) {
 190     global->loop_detection_mode = g->loop_detection_mode;
 191   }
 192   if (flag & LDP_GLOBAL_CFG_TTLLESS_DOMAIN) {
 193     global->ttl_less_domain = g->ttl_less_domain;
 194   }
 195   if (flag & LDP_GLOBAL_CFG_LOCAL_TCP_PORT) {
 196     global->local_tcp_port = g->local_tcp_port;
 197   }
 198   if (flag & LDP_GLOBAL_CFG_LOCAL_UDP_PORT) {
 199     global->local_udp_port = g->local_udp_port;
 200   }
 201   if (flag & LDP_GLOBAL_CFG_LSR_IDENTIFIER) {
 202     memcpy(&(global->lsr_identifier), &(g->lsr_identifier),
 203       sizeof(mpls_inet_addr));
 204   }
 205 #if MPLS_USE_LSR
 206   if (flag & LDP_GLOBAL_CFG_LSR_HANDLE) {
 207     global->lsr_handle = g->lsr_handle;
 208   }
 209 #endif
 210   if (flag & LDP_GLOBAL_CFG_ADMIN_STATE) {
 211     if (global->admin_state == MPLS_ADMIN_ENABLE && g->admin_state == MPLS_ADMIN_DISABLE) {
 212       ldp_global_shutdown(global);
 213     } else if (global->admin_state == MPLS_ADMIN_DISABLE && g->admin_state ==
 214       MPLS_ADMIN_ENABLE) {
 215       ldp_global_startup(global);
 216     }
 217   }
 218   if (flag & LDP_GLOBAL_CFG_TRANS_ADDR) {
 219     memcpy(&(global->transport_address), &(g->transport_address),
 220       sizeof(mpls_inet_addr));
 221   }
 222   if (flag & LDP_GLOBAL_CFG_KEEPALIVE_TIMER) {
 223     if (g->keepalive_timer == 0) {
 224       global->keepalive_timer = LDP_ENTITY_DEF_KEEPALIVE_TIMER;
 225     } else {
 226       global->keepalive_timer = g->keepalive_timer;
 227     }
 228   }
 229   if (flag & LDP_GLOBAL_CFG_KEEPALIVE_INTERVAL) {
 230     if (g->keepalive_interval == 0) {
 231       global->keepalive_interval = LDP_ENTITY_DEF_KEEPALIVE_INTERVAL;
 232     } else {
 233       global->keepalive_interval = g->keepalive_interval;
 234     }
 235   }
 236   if (flag & LDP_GLOBAL_CFG_HELLOTIME_TIMER) {
 237     if (g->hellotime_timer == 0) {
 238       global->hellotime_timer = LDP_ENTITY_DEF_HELLOTIME_TIMER;
 239     } else {
 240       global->hellotime_timer = g->hellotime_timer;
 241     }
 242   }
 243   if (flag & LDP_GLOBAL_CFG_HELLOTIME_INTERVAL) {
 244     if (g->hellotime_interval == 0) {
 245       global->hellotime_interval = LDP_ENTITY_DEF_HELLOTIME_INTERVAL;
 246     } else {
 247       global->hellotime_interval = g->hellotime_interval;
 248     }
 249   }
 250 #if MPLS_USE_LSR
 251   if (flag & LDP_GLOBAL_CFG_LSR_HANDLE) {
 252     global->lsr_handle = g->lsr_handle ;
 253   }
 254 #endif
 255   global->configuration_sequence_number++;
 256
 257   retval = MPLS_SUCCESS;
 258
 259 ldp_cfg_global_set_end:
 260
 261   mpls_lock_release(global->global_lock); /* UNLOCK */
 262
 263   LDP_EXIT(global->user_data, "ldp_cfg_global_set");
 264
 265   return retval;
 266 }
 267
 268 /******************* ENTITY **********************/
 269
 270 /* must set ldp_entity->index */
 271 mpls_return_enum ldp_cfg_entity_get(mpls_cfg_handle handle, ldp_entity * e,
 272   uint32_t flag)
 273 {
 274   ldp_global *global = (ldp_global *) handle;
 275   ldp_entity *entity = NULL;
 276   mpls_return_enum retval = MPLS_FAILURE;
 277
 278   MPLS_ASSERT(global !=NULL && e != NULL);
 279
 280   LDP_ENTER(global->user_data, "ldp_cfg_entity_get");
 281
 282   mpls_lock_get(global->global_lock); /* LOCK */
 283
 284   if (ldp_global_find_entity_index(global, e->index, &entity) != MPLS_SUCCESS)
 285       goto ldp_cfg_entity_get_end;
 286
 287   if (flag & LDP_ENTITY_CFG_ADMIN_STATE) {
 288     e->admin_state = entity->admin_state;
 289   }
 290   if (flag & LDP_ENTITY_CFG_TRANS_ADDR) {
 291     e->transport_address = entity->transport_address;
 292   }
 293   if (flag & LDP_ENTITY_CFG_PROTO_VER) {
 294     e->protocol_version = entity->protocol_version;
 295   }
 296   if (flag & LDP_ENTITY_CFG_REMOTE_TCP) {
 297     e->remote_tcp_port = entity->remote_tcp_port;
 298   }
 299   if (flag & LDP_ENTITY_CFG_REMOTE_UDP) {
 300     e->remote_udp_port = entity->remote_udp_port;
 301   }
 302   if (flag & LDP_ENTITY_CFG_MAX_PDU) {
 303     e->max_pdu = entity->max_pdu;
 304   }
 305   if (flag & LDP_ENTITY_CFG_KEEPALIVE_TIMER) {
 306     e->keepalive_timer = entity->keepalive_timer;
 307   }
 308   if (flag & LDP_ENTITY_CFG_KEEPALIVE_INTERVAL) {
 309     e->keepalive_interval = entity->keepalive_interval;
 310   }
 311   if (flag & LDP_ENTITY_CFG_HELLOTIME_TIMER) {
 312     e->hellotime_timer = entity->hellotime_timer;
 313   }
 314   if (flag & LDP_ENTITY_CFG_HELLOTIME_INTERVAL) {
 315     e->hellotime_interval = entity->hellotime_interval;
 316   }
 317   if (flag & LDP_ENTITY_CFG_SESSION_SETUP_COUNT) {
 318     e->session_setup_count = entity->session_setup_count;
 319   }
 320   if (flag & LDP_ENTITY_CFG_SESSION_BACKOFF_TIMER) {
 321     e->session_backoff_timer = entity->session_backoff_timer;
 322   }
 323   if (flag & LDP_ENTITY_CFG_DISTRIBUTION_MODE) {
 324     e->label_distribution_mode = entity->label_distribution_mode;
 325   }
 326   if (flag & LDP_ENTITY_CFG_PATHVECTOR_LIMIT) {
 327     e->path_vector_limit = entity->path_vector_limit;
 328   }
 329   if (flag & LDP_ENTITY_CFG_HOPCOUNT_LIMIT) {
 330     e->hop_count_limit = entity->hop_count_limit;
 331   }
 332   if (flag & LDP_ENTITY_CFG_REQUEST_COUNT) {
 333     e->label_request_count = entity->label_request_count;
 334   }
 335   if (flag & LDP_ENTITY_CFG_REQUEST_TIMER) {
 336     e->label_request_timer = entity->label_request_timer;
 337   }
 338   if (flag & LDP_ENTITY_CFG_TYPE) {
 339     e->entity_type = entity->entity_type;
 340   }
 341   if (flag & LDP_ENTITY_CFG_SUB_INDEX) {
 342     e->sub_index = entity->sub_index;
 343   }
 344   if (flag & LDP_ENTITY_CFG_MESG_TX) {
 345     e->mesg_tx = entity->mesg_tx;
 346   }
 347   if (flag & LDP_ENTITY_CFG_MESG_RX) {
 348     e->mesg_rx = entity->mesg_rx;
 349   }
 350   if (flag & LDP_ENTITY_CFG_ADJ_COUNT) {
 351     e->adj_count = entity->adj_root.count;
 352   }
 353   if (flag & LDP_ENTITY_CFG_ADJ_INDEX) {
 354     ldp_adj *a = MPLS_LIST_HEAD(&entity->adj_root);
 355     e->adj_index = a ? a->index : 0;
 356   }
 357   if (flag & LDP_ENTITY_CFG_INHERIT_FLAG) {
 358     e->inherit_flag = entity->inherit_flag;
 359   }
 360   retval = MPLS_SUCCESS;
 361
 362 ldp_cfg_entity_get_end:
 363
 364   mpls_lock_release(global->global_lock); /* UNLOCK */
 365
 366   LDP_EXIT(global->user_data, "ldp_cfg_entity_get");
 367
 368   return retval;
 369 }
 370
 371 mpls_return_enum ldp_cfg_entity_getnext(mpls_cfg_handle handle, ldp_entity * e,
 372   uint32_t flag)
 373 {
 374   ldp_global *g = (ldp_global *) handle;
 375   ldp_entity *entity = NULL;
 376   mpls_return_enum r = MPLS_FAILURE;
 377   mpls_bool done = MPLS_BOOL_FALSE;
 378   int index;
 379
 380   LDP_ENTER(g->user_data, "ldp_cfg_entity_getnext");
 381
 382   if (e->index == 0) {
 383     index = 1;
 384   } else {
 385     index = e->index + 1;
 386   }
 387
 388   mpls_lock_get(g->global_lock); /* LOCK */
 389   while (done == MPLS_BOOL_FALSE) {
 390     switch ((r = ldp_global_find_entity_index(g, index, &entity))) {
 391       case MPLS_SUCCESS:
 392       case MPLS_END_OF_LIST:
 393         done = MPLS_BOOL_TRUE;
 394         break;
 395       case MPLS_FAILURE:
 396         break;
 397       default:
 398         MPLS_ASSERT(0);
 399     }
 400     index++;
 401   }
 402   mpls_lock_release(g->global_lock); /* UNLOCK */
 403
 404   if (r == MPLS_SUCCESS) {
 405     e->index = entity->index;
 406     LDP_EXIT(g->user_data, "ldp_cfg_entity_getnext");
 407     return ldp_cfg_entity_get(g, e, flag);
 408   }
 409   LDP_EXIT(g->user_data, "ldp_cfg_entity_getnext");
 410   return r;
 411 }
 412
 413 mpls_return_enum ldp_cfg_entity_test(mpls_cfg_handle handle, ldp_entity * e,
 414   uint32_t flag)
 415 {
 416   ldp_global *global = (ldp_global *) handle;
 417   ldp_entity *entity = NULL;
 418   mpls_return_enum retval = MPLS_FAILURE;
 419
 420   MPLS_ASSERT(global !=NULL);
 421
 422   LDP_ENTER(global->user_data, "ldp_cfg_entity_test");
 423
 424   mpls_lock_get(global->global_lock); /* LOCK */
 425
 426   if (!(flag & LDP_CFG_ADD)) {
 427     if (e == NULL)
 428       goto ldp_cfg_entity_test_end;
 429
 430     ldp_global_find_entity_index(global, e->index, &entity);
 431   } else {
 432     retval = MPLS_SUCCESS;
 433     goto ldp_cfg_entity_test_end;
 434   }
 435
 436   if (entity == NULL) {
 437      goto ldp_cfg_entity_test_end;
 438   }
 439
 440   if ((ldp_entity_is_active(entity) == MPLS_BOOL_TRUE) &&
 441       (flag & LDP_ENTITY_CFG_WHEN_DOWN)) {
 442      goto ldp_cfg_entity_test_end;
 443   }
 444
 445   retval = MPLS_SUCCESS;
 446
 447 ldp_cfg_entity_test_end:
 448   mpls_lock_release(global->global_lock); /* UNLOCK */
 449
 450   LDP_EXIT(global->user_data, "ldp_cfg_entity_test");
 451
 452   return retval;
 453 }
 454
 455 /* must set ldp_entity->index if not an add */
 456 mpls_return_enum ldp_cfg_entity_set(mpls_cfg_handle handle, ldp_entity * e,
 457   uint32_t flag)
 458 {
 459   ldp_global *global = (ldp_global *) handle;
 460   ldp_entity *entity = NULL;
 461   mpls_return_enum retval = MPLS_FAILURE;
 462
 463   MPLS_ASSERT(global !=NULL && e != NULL);
 464
 465   LDP_ENTER(global->user_data, "ldp_cfg_entity_set");
 466
 467   mpls_lock_get(global->global_lock); /* LOCK */
 468
 469   if (flag & LDP_CFG_ADD) {
 470     entity = ldp_entity_create();
 471     _ldp_global_add_entity(global, entity);
 472
 473     e->index = entity->index;
 474   } else {
 475     ldp_global_find_entity_index(global, e->index, &entity);
 476   }
 477
 478   if (entity == NULL) {
 479     LDP_PRINT(global->user_data, "ldp_cfg_entity_set: can't find entity\n");
 480     goto ldp_cfg_entity_set_end;
 481   }
 482
 483   if ((ldp_entity_is_active(entity) == MPLS_BOOL_TRUE) &&
 484       (flag & LDP_ENTITY_CFG_WHEN_DOWN)) {
 485     LDP_PRINT(global->user_data, "ldp_cfg_entity_set: entity is active\n");
 486     goto ldp_cfg_entity_set_end;
 487   }
 488
 489   if (flag & LDP_CFG_DEL) {
 490     switch (entity->entity_type) {
 491       case LDP_DIRECT:
 492         ldp_entity_del_if(global, entity);
 493         break;
 494       case LDP_INDIRECT:
 495         ldp_entity_del_peer(entity);
 496         break;
 497       default:
 498         MPLS_ASSERT(0);
 499     }
 500     _ldp_global_del_entity(global, entity);
 501
 502     retval = MPLS_SUCCESS;
 503     goto ldp_cfg_entity_set_end;
 504   }
 505
 506   if (flag & LDP_ENTITY_CFG_SUB_INDEX) {
 507     if (entity->sub_index != 0) {
 508       /* unlink the old sub object */
 509       switch (entity->entity_type) {
 510         case LDP_DIRECT:
 511           ldp_entity_del_if(global, entity);
 512           break;
 513         case LDP_INDIRECT:
 514           ldp_entity_del_peer(entity);
 515           break;
 516         default:
 517           MPLS_ASSERT(0);
 518       }
 519     }
 520
 521     /* link the new sub object */
 522     switch (e->entity_type) {
 523       case LDP_DIRECT:
 524         {
 525           ldp_if *iff = NULL;
 526           if (ldp_global_find_if_index(global, e->sub_index,
 527               &iff) != MPLS_SUCCESS) {
 528             LDP_PRINT(global->user_data,
 529               "ldp_cfg_entity_set: no such interface\n");
 530
 531             if (flag & LDP_CFG_ADD) {
 532               _ldp_global_del_entity(global, entity);
 533             }
 534             goto ldp_cfg_entity_set_end;
 535           }
 536           ldp_entity_add_if(entity, iff);
 537           break;
 538         }
 539       case LDP_INDIRECT:
 540         {
 541           ldp_peer *peer = NULL;
 542
 543           if (ldp_global_find_peer_index(global, e->sub_index, &peer) !=
 544             MPLS_SUCCESS) {
 545             LDP_PRINT(global->user_data, "ldp_cfg_entity_set: no such peer\n");
 546
 547             if (flag & LDP_CFG_ADD) {
 548               _ldp_global_del_entity(global, entity);
 549             }
 550             goto ldp_cfg_entity_set_end;
 551           }
 552           ldp_entity_add_peer(entity, peer);
 553           break;
 554         }
 555       default:
 556         MPLS_ASSERT(0);
 557     }
 558   }
 559
 560   if (flag & LDP_ENTITY_CFG_TRANS_ADDR) {
 561     if (e->transport_address.type == MPLS_FAMILY_NONE) {
 562       entity->inherit_flag |= LDP_ENTITY_CFG_TRANS_ADDR;
 563     } else {
 564       entity->inherit_flag &= ~LDP_ENTITY_CFG_TRANS_ADDR;
 565     }
 566     memcpy(&entity->transport_address, &e->transport_address,
 567       sizeof(mpls_inet_addr));;
 568   }
 569   if (flag & LDP_ENTITY_CFG_PROTO_VER) {
 570     entity->protocol_version = e->protocol_version;
 571   }
 572   if (flag & LDP_ENTITY_CFG_REMOTE_TCP) {
 573     entity->remote_tcp_port = e->remote_tcp_port;
 574   }
 575   if (flag & LDP_ENTITY_CFG_REMOTE_UDP) {
 576     entity->remote_udp_port = e->remote_udp_port;
 577   }
 578   if (flag & LDP_ENTITY_CFG_MAX_PDU) {
 579     entity->max_pdu = e->max_pdu;
 580   }
 581   if (flag & LDP_ENTITY_CFG_KEEPALIVE_TIMER) {
 582     if (e->transport_address.type == MPLS_FAMILY_NONE) {
 583       entity->inherit_flag |= LDP_ENTITY_CFG_KEEPALIVE_TIMER;
 584     } else {
 585       entity->inherit_flag &= ~LDP_ENTITY_CFG_KEEPALIVE_TIMER;
 586     }
 587     entity->keepalive_timer = e->keepalive_timer;
 588   }
 589   if (flag & LDP_ENTITY_CFG_KEEPALIVE_INTERVAL) {
 590     if (e->transport_address.type == MPLS_FAMILY_NONE) {
 591       entity->inherit_flag |= LDP_ENTITY_CFG_KEEPALIVE_INTERVAL;
 592     } else {
 593       entity->inherit_flag &= ~LDP_ENTITY_CFG_KEEPALIVE_INTERVAL;
 594     }
 595     entity->keepalive_interval = e->keepalive_interval;
 596   }
 597   if (flag & LDP_ENTITY_CFG_HELLOTIME_TIMER) {
 598     if (e->transport_address.type == MPLS_FAMILY_NONE) {
 599       entity->inherit_flag |= LDP_ENTITY_CFG_HELLOTIME_TIMER;
 600     } else {
 601       entity->inherit_flag &= ~LDP_ENTITY_CFG_HELLOTIME_TIMER;
 602     }
 603     entity->hellotime_timer = e->hellotime_timer;
 604   }
 605   if (flag & LDP_ENTITY_CFG_HELLOTIME_INTERVAL) {
 606     if (e->transport_address.type == MPLS_FAMILY_NONE) {
 607       entity->inherit_flag |= LDP_ENTITY_CFG_HELLOTIME_INTERVAL;
 608     } else {
 609       entity->inherit_flag &= ~LDP_ENTITY_CFG_HELLOTIME_INTERVAL;
 610     }
 611     entity->hellotime_interval = e->hellotime_interval;
 612   }
 613   if (flag & LDP_ENTITY_CFG_SESSION_SETUP_COUNT) {
 614     entity->session_setup_count = e->session_setup_count;
 615   }
 616   if (flag & LDP_ENTITY_CFG_SESSION_BACKOFF_TIMER) {
 617     entity->session_backoff_timer = e->session_backoff_timer;
 618   }
 619   if (flag & LDP_ENTITY_CFG_DISTRIBUTION_MODE) {
 620     entity->label_distribution_mode = e->label_distribution_mode;
 621   }
 622   if (flag & LDP_ENTITY_CFG_PATHVECTOR_LIMIT) {
 623     entity->path_vector_limit = e->path_vector_limit;
 624   }
 625   if (flag & LDP_ENTITY_CFG_HOPCOUNT_LIMIT) {
 626     entity->hop_count_limit = e->hop_count_limit;
 627   }
 628   if (flag & LDP_ENTITY_CFG_REQUEST_COUNT) {
 629     entity->label_request_count = e->label_request_count;
 630   }
 631   if (flag & LDP_ENTITY_CFG_REQUEST_TIMER) {
 632     entity->label_request_timer = e->label_request_timer;
 633   }
 634   if (flag & LDP_ENTITY_CFG_TYPE) {
 635     entity->entity_type = e->entity_type;
 636   }
 637   if (flag & LDP_ENTITY_CFG_ADMIN_STATE) {
 638     if (ldp_entity_is_active(entity) == MPLS_BOOL_TRUE &&
 639       e->admin_state == MPLS_ADMIN_DISABLE) {
 640       if (ldp_entity_shutdown(global, entity, 0) == MPLS_FAILURE) {
 641         goto ldp_cfg_entity_set_end;
 642       }
 643     } else if (ldp_entity_is_active(entity) == MPLS_BOOL_FALSE &&
 644       e->admin_state == MPLS_ADMIN_ENABLE && ldp_entity_is_ready(entity) == MPLS_BOOL_TRUE) {
 645       if (ldp_entity_startup(global, entity) == MPLS_FAILURE) {
 646         goto ldp_cfg_entity_set_end;
 647       }
 648     } else {
 649       LDP_PRINT(global->user_data, "ldp_cfg_entity_set: entity not ready\n");
 650
 651       goto ldp_cfg_entity_set_end;
 652     }
 653   }
 654   if (flag & LDP_ENTITY_CFG_INHERIT_FLAG) {
 655     entity->inherit_flag = e->inherit_flag;
 656   }
 657   global->configuration_sequence_number++;
 658
 659   retval = MPLS_SUCCESS;
 660
 661 ldp_cfg_entity_set_end:
 662   mpls_lock_release(global->global_lock); /* UNLOCK */
 663
 664   LDP_EXIT(global->user_data, "ldp_cfg_entity_set");
 665
 666   return retval;
 667 }
 668
 669 mpls_return_enum ldp_cfg_entity_adj_getnext(mpls_cfg_handle handle,
 670   ldp_entity * e)
 671 {
 672   ldp_global *g = (ldp_global *) handle;
 673   mpls_bool this_one = MPLS_BOOL_FALSE;
 674   mpls_return_enum r = MPLS_FAILURE;
 675   ldp_adj *adj_next = NULL;
 676   ldp_adj *adj = NULL;
 677   ldp_entity *entity = NULL;
 678
 679   LDP_ENTER(g->user_data, "ldp_cfg_entity_adj_getnext");
 680
 681   /* if an adj_index of zero is sent, get the index of
 682    * the first adj in the list
 683    */
 684   if (!e->adj_index) {
 685     this_one = MPLS_BOOL_TRUE;
 686   }
 687
 688   mpls_lock_get(g->global_lock); /* LOCK */
 689
 690   if (ldp_global_find_entity_index(g, e->index, &entity) == MPLS_SUCCESS) {
 691     adj = MPLS_LIST_HEAD(&entity->adj_root);
 692     while (adj) {
 693       if (this_one == MPLS_BOOL_TRUE) {
 694         adj_next = adj;
 695         break;
 696       }
 697
 698       /* since the entities are sort in the list ... */
 699       if (adj->index > e->adj_index) {
 700         break;
 701       } else if (adj->index == e->adj_index) {
 702         this_one = MPLS_BOOL_TRUE;
 703       }
 704       adj = MPLS_LIST_NEXT(&entity->adj_root, adj, _entity);
 705     }
 706   }
 707   mpls_lock_release(g->global_lock); /* UNLOCK */
 708
 709   if (adj_next) {
 710     e->adj_index = adj_next->index;
 711     r = MPLS_SUCCESS;
 712   }
 713
 714   LDP_EXIT(g->user_data, "ldp_cfg_entity_adj_getnext");
 715   return r;
 716 }
 717
 718 /******************* INTERFACE **********************/
 719
 720 mpls_return_enum ldp_cfg_if_get(mpls_cfg_handle handle, ldp_if * i, uint32_t flag)
 721 {
 722   ldp_global *global = (ldp_global *) handle;
 723   ldp_if *iff = NULL;
 724   mpls_return_enum retval = MPLS_FAILURE;
 725
 726   MPLS_ASSERT(global !=NULL && i != NULL);
 727
 728   LDP_ENTER(global->user_data, "ldp_cfg_if_get");
 729
 730   mpls_lock_get(global->global_lock); /* LOCK */
 731
 732   if (flag & LDP_IF_CFG_BY_INDEX) {
 733     ldp_global_find_if_index(global, i->index, &iff);
 734   } else {
 735     iff = ldp_global_find_if_handle(global, i->handle);
 736   }
 737   if (!iff)
 738       goto ldp_cfg_if_get_end;
 739
 740   if (flag & LDP_IF_CFG_LABEL_SPACE) {
 741     i->label_space = iff->label_space;
 742   }
 743   if (flag & LDP_IF_CFG_ENTITY_INDEX) {
 744     i->entity_index = iff->entity ? iff->entity->index : 0;
 745   }
 746   if (flag & LDP_IF_CFG_OPER_STATE) {
 747     i->oper_state = iff->oper_state;
 748   }
 749   if (flag & LDP_IF_CFG_HANDLE) {
 750     memcpy(&i->handle, &iff->handle, sizeof(mpls_if_handle));
 751   }
 752   retval = MPLS_SUCCESS;
 753
 754 ldp_cfg_if_get_end:
 755   mpls_lock_release(global->global_lock); /* UNLOCK */
 756
 757   LDP_EXIT(global->user_data, "ldp_cfg_if_get");
 758
 759   return retval;
 760 }
 761
 762 mpls_return_enum ldp_cfg_if_getnext(mpls_cfg_handle handle, ldp_if * i,
 763   uint32_t flag)
 764 {
 765   ldp_global *g = (ldp_global *) handle;
 766   ldp_if *iff = NULL;
 767   mpls_return_enum r = MPLS_FAILURE;
 768   mpls_bool done = MPLS_BOOL_FALSE;
 769   int index;
 770
 771   LDP_ENTER(g->user_data, "ldp_cfg_if_getnext");
 772
 773   if (i->index == 0) {
 774     index = 1;
 775   } else {
 776     index = i->index + 1;
 777   }
 778
 779   mpls_lock_get(g->global_lock); /* LOCK */
 780   while (done == MPLS_BOOL_FALSE) {
 781     switch ((r = ldp_global_find_if_index(g, index, &iff))) {
 782       case MPLS_SUCCESS:
 783       case MPLS_END_OF_LIST:
 784         done = MPLS_BOOL_TRUE;
 785         break;
 786       case MPLS_FAILURE:
 787         break;
 788       default:
 789         MPLS_ASSERT(0);
 790     }
 791     index++;
 792   }
 793   mpls_lock_release(g->global_lock); /* UNLOCK */
 794
 795   if (r == MPLS_SUCCESS) {
 796     i->index = iff->index;
 797     LDP_EXIT(g->user_data, "ldp_cfg_if_getnext");
 798     return ldp_cfg_if_get(g, i, flag);
 799   }
 800   LDP_EXIT(g->user_data, "ldp_cfg_if_getnext");
 801   return r;
 802 }
 803
 804 mpls_return_enum ldp_cfg_if_test(mpls_cfg_handle handle, ldp_if * i,
 805   uint32_t flag)
 806 {
 807   ldp_global *global = (ldp_global *) handle;
 808   ldp_if *iff = NULL;
 809   mpls_return_enum retval = MPLS_FAILURE;
 810
 811   MPLS_ASSERT(global !=NULL && i != NULL);
 812
 813   LDP_ENTER(global->user_data, "ldp_cfg_if_test");
 814
 815   mpls_lock_get(global->global_lock); /* LOCK */
 816
 817   if (!(flag & LDP_CFG_ADD)) {
 818     ldp_global_find_if_index(global, i->index, &iff);
 819   } else {
 820     retval = MPLS_SUCCESS;
 821     goto ldp_cfg_if_test_end;
 822   }
 823
 824   if ((!iff) || ((ldp_if_is_active(iff) == MPLS_BOOL_TRUE) &&
 825     (flag & LDP_IF_CFG_WHEN_DOWN))) {
 826     goto ldp_cfg_if_test_end;
 827   }
 828
 829   if (flag & LDP_CFG_DEL) {
 830     if (iff->entity != NULL) {
 831       goto ldp_cfg_if_test_end;
 832     }
 833   }
 834   retval = MPLS_SUCCESS;
 835
 836 ldp_cfg_if_test_end:
 837   mpls_lock_release(global->global_lock); /* UNLOCK */
 838
 839   LDP_EXIT(global->user_data, "ldp_cfg_if_test");
 840
 841   return retval;
 842 }
 843
 844 mpls_return_enum ldp_cfg_if_set(mpls_cfg_handle handle, ldp_if * i, uint32_t flag)
 845 {
 846   ldp_global *global = (ldp_global*)handle;
 847   ldp_if *iff = NULL;
 848   ldp_addr *ap;
 849   ldp_nexthop *np;
 850   mpls_return_enum retval = MPLS_FAILURE;
 851
 852   MPLS_ASSERT(global !=NULL && i != NULL);
 853
 854   LDP_ENTER(global->user_data, "ldp_cfg_if_set");
 855
 856   mpls_lock_get(global->global_lock); /* LOCK */
 857
 858   if (flag & LDP_CFG_ADD) {
 859     /* duplicate interface handles are not allowed */
 860     /* ADDs require a valid interface handle */
 861     if ((iff = ldp_global_find_if_handle(global, i->handle)) != NULL) {
 862       LDP_PRINT(global->user_data, "Duplicate interface exists");
 863       goto ldp_cfg_if_set_end;
 864     }
 865     if (mpls_if_handle_verify(global->ifmgr_handle, i->handle) ==
 866       MPLS_BOOL_FALSE) {
 867       LDP_PRINT(global->user_data, "Invalid interface handle");
 868       goto ldp_cfg_if_set_end;
 869     }
 870     if ((iff = ldp_if_create(global)) == NULL) {
 871       LDP_PRINT(global->user_data, "Failure creating interface");
 872       goto ldp_cfg_if_set_end;
 873     }
 874
 875     /* copy the handle from the user */
 876     iff->handle = i->handle;
 877
 878     /* search for addrs and nexthops that are waiting for this interface */
 879     ap = MPLS_LIST_HEAD(&global->addr);
 880     while (ap) {
 881       if (ap->if_handle == iff->handle && (!MPLS_LIST_IN_LIST(ap, _if))) {
 882         ldp_if_add_addr(iff, ap);
 883       }
 884       ap = MPLS_LIST_NEXT(&global->addr, ap, _global);
 885     }
 886
 887     np = MPLS_LIST_HEAD(&global->nexthop);
 888     while (np) {
 889       if ((np->info.type & MPLS_NH_IF) &&
 890         (np->info.if_handle == iff->handle) && (!MPLS_LIST_IN_LIST(np, _if))) {
 891         ldp_if_add_nexthop(iff, np);
 892       }
 893       np = MPLS_LIST_NEXT(&global->nexthop, np, _global);
 894     }
 895
 896     /* send the newly created index back to the user */
 897     i->index = iff->index;
 898     MPLS_REFCNT_HOLD(iff);
 899
 900   } else {
 901     if (flag & LDP_IF_CFG_BY_INDEX) {
 902       ldp_global_find_if_index(global, i->index, &iff);
 903     } else {
 904       iff = ldp_global_find_if_handle(global, i->handle);
 905     }
 906   }
 907
 908   /*
 909    * if we can't find this interface or if the interface is active and
 910    * we are trying to change propertises that can not be changed on a
 911    * active interface
 912    */
 913   if ((!iff) || ((ldp_if_is_active(iff) == MPLS_BOOL_TRUE) &&
 914     (flag & LDP_IF_CFG_WHEN_DOWN))) {
 915     goto ldp_cfg_if_set_end;
 916   }
 917
 918   if (flag & LDP_IF_CFG_LABEL_SPACE) {
 919     iff->label_space = i->label_space;
 920   }
 921
 922   if (flag & LDP_CFG_DEL) {
 923     /*
 924      * if this interface is still attached to a entity that it is not ready
 925      * to be removed
 926      */
 927     if (iff->entity != NULL) {
 928       goto ldp_cfg_if_set_end;
 929     }
 930
 931     np = MPLS_LIST_HEAD(&iff->nh_root);
 932     while ((np = MPLS_LIST_HEAD(&iff->nh_root))) {
 933       ldp_if_del_nexthop(global, iff, np);
 934     }
 935
 936     ap = MPLS_LIST_HEAD(&iff->addr_root);
 937     while ((ap = MPLS_LIST_HEAD(&iff->addr_root))) {
 938       ldp_if_del_addr(global, iff, ap);
 939     }
 940
 941     MPLS_REFCNT_RELEASE2(global, iff, ldp_if_delete);
 942   }
 943
 944   global->configuration_sequence_number++;
 945
 946   retval = MPLS_SUCCESS;
 947
 948 ldp_cfg_if_set_end:
 949   mpls_lock_release(global->global_lock); /* UNLOCK */
 950
 951   LDP_EXIT(global->user_data, "ldp_cfg_if_set");
 952
 953   return retval;
 954 }
 955
 956 /******************* ATTR **********************/
 957
 958 mpls_return_enum ldp_cfg_attr_get(mpls_cfg_handle handle, ldp_attr * a,
 959   uint32_t flag)
 960 {
 961   ldp_global *global = (ldp_global *) handle;
 962   ldp_attr *attr = NULL;
 963   mpls_return_enum retval = MPLS_FAILURE;
 964
 965   MPLS_ASSERT(global !=NULL && a != NULL);
 966
 967   LDP_ENTER(global->user_data, "ldp_cfg_attr_get");
 968
 969   mpls_lock_get(global->global_lock); /* LOCK */
 970
 971   if (ldp_global_find_attr_index(global, a->index, &attr) != MPLS_SUCCESS)
 972       goto ldp_cfg_attr_get_end;
 973
 974   if (flag & LDP_ATTR_CFG_STATE) {
 975     a->state = attr->state;
 976   }
 977   if (flag & LDP_ATTR_CFG_FEC) {
 978     ldp_attr2ldp_attr(attr, a, LDP_ATTR_FEC);
 979   }
 980   if (flag & LDP_ATTR_CFG_LABEL) {
 981     ldp_attr2ldp_attr(attr, a, LDP_ATTR_LABEL);
 982   }
 983   if (flag & LDP_ATTR_CFG_HOP_COUNT) {
 984     ldp_attr2ldp_attr(attr, a, LDP_ATTR_HOPCOUNT);
 985   }
 986   if (flag & LDP_ATTR_CFG_PATH) {
 987     ldp_attr2ldp_attr(attr, a, LDP_ATTR_PATH);
 988   }
 989   if (flag & LDP_ATTR_CFG_SESSION_INDEX) {
 990     a->session_index = (attr->session) ? (attr->session->index) : 0;
 991   }
 992   if (flag & LDP_ATTR_CFG_INLABEL_INDEX) {
 993     a->inlabel_index = (attr->inlabel) ? (attr->inlabel->index) : 0;
 994   }
 995   if (flag & LDP_ATTR_CFG_OUTLABEL_INDEX) {
 996     a->outlabel_index = (attr->outlabel) ? (attr->outlabel->index) : 0;
 997   }
 998   if (flag & LDP_ATTR_CFG_INGRESS) {
 999     a->ingress = attr->ingress;
1000   }
1001   retval = MPLS_SUCCESS;
1002
1003 ldp_cfg_attr_get_end:
1004   mpls_lock_release(global->global_lock); /* UNLOCK */
1005
1006   LDP_EXIT(global->user_data, "ldp_cfg_attr_get");
1007
1008   return retval;
1009 }
1010
1011 mpls_return_enum ldp_cfg_attr_getnext(mpls_cfg_handle handle, ldp_attr * a,
1012   uint32_t flag)
1013 {
1014   ldp_global *g = (ldp_global *) handle;
1015   ldp_attr *attr = NULL;
1016   mpls_return_enum r = MPLS_FAILURE;
1017   mpls_bool done = MPLS_BOOL_FALSE;
1018   int index;
1019
1020   LDP_ENTER(g->user_data, "ldp_cfg_attr_getnext");
1021
1022   if (a->index == 0) {
1023     index = 1;
1024   } else {
1025     index = a->index + 1;
1026   }
1027
1028   mpls_lock_get(g->global_lock); /* LOCK */
1029   while (done == MPLS_BOOL_FALSE) {
1030     switch ((r = ldp_global_find_attr_index(g, index, &attr))) {
1031       case MPLS_SUCCESS:
1032       case MPLS_END_OF_LIST:
1033         done = MPLS_BOOL_TRUE;
1034         break;
1035       case MPLS_FAILURE:
1036         break;
1037       default:
1038         MPLS_ASSERT(0);
1039     }
1040     index++;
1041   }
1042   mpls_lock_release(g->global_lock); /* UNLOCK */
1043
1044   if (r == MPLS_SUCCESS) {
1045     a->index = attr->index;
1046     LDP_EXIT(g->user_data, "ldp_cfg_attr_getnext");
1047     return ldp_cfg_attr_get(g, a, flag);
1048   }
1049   LDP_EXIT(g->user_data, "ldp_cfg_attr_getnext");
1050   return r;
1051 }
1052
1053 /******************* PEER **********************/
1054
1055 mpls_return_enum ldp_cfg_peer_get(mpls_cfg_handle handle, ldp_peer * p,
1056   uint32_t flag)
1057 {
1058   ldp_global *global = (ldp_global *) handle;
1059   ldp_peer *peer = NULL;
1060   mpls_return_enum retval = MPLS_FAILURE;
1061
1062   MPLS_ASSERT(global !=NULL && p != NULL);
1063
1064   LDP_ENTER(global->user_data, "ldp_cfg_peer_get");
1065
1066   mpls_lock_get(global->global_lock); /* LOCK */
1067
1068   if (ldp_global_find_peer_index(global, p->index, &peer) != MPLS_SUCCESS)
1069       goto ldp_cfg_peer_get_end;
1070
1071   if (flag & LDP_PEER_CFG_LABEL_SPACE) {
1072     p->label_space = peer->label_space;
1073   }
1074   if (flag & LDP_PEER_CFG_TARGET_ROLE) {
1075     p->target_role = peer->target_role;
1076   }
1077   if (flag & LDP_PEER_CFG_DEST_ADDR) {
1078     memcpy(&p->dest.addr, &peer->dest.addr, sizeof(mpls_inet_addr));
1079   }
1080   if (flag & LDP_PEER_CFG_ENTITY_INDEX) {
1081     p->entity_index = peer->entity->index;
1082   }
1083   if (flag & LDP_PEER_CFG_OPER_STATE) {
1084     p->oper_state = peer->oper_state;
1085   }
1086   if (flag & LDP_PEER_CFG_PEER_NAME) {
1087     strncpy(p->peer_name, peer->peer_name, MPLS_MAX_IF_NAME);
1088   }
1089   retval = MPLS_SUCCESS;
1090
1091 ldp_cfg_peer_get_end:
1092   mpls_lock_release(global->global_lock); /* UNLOCK */
1093
1094   LDP_EXIT(global->user_data, "ldp_cfg_peer_get");
1095
1096   return retval;
1097 }
1098
1099 mpls_return_enum ldp_cfg_peer_getnext(mpls_cfg_handle handle, ldp_peer * p,
1100   uint32_t flag)
1101 {
1102   ldp_global *g = (ldp_global *) handle;
1103   ldp_peer *peer = NULL;
1104   mpls_return_enum r = MPLS_FAILURE;
1105   mpls_bool done = MPLS_BOOL_FALSE;
1106   int index;
1107
1108   LDP_ENTER(g->user_data, "ldp_cfg_peer_getnext");
1109
1110   if (p->index == 0) {
1111     index = 1;
1112   } else {
1113     index = p->index + 1;
1114   }
1115
1116   mpls_lock_get(g->global_lock); /* LOCK */
1117   while (done == MPLS_BOOL_FALSE) {
1118     switch ((r = ldp_global_find_peer_index(g, index, &peer))) {
1119       case MPLS_SUCCESS:
1120       case MPLS_END_OF_LIST:
1121         done = MPLS_BOOL_TRUE;
1122         break;
1123       case MPLS_FAILURE:
1124         break;
1125       default:
1126         MPLS_ASSERT(0);
1127     }
1128     index++;
1129   }
1130   mpls_lock_release(g->global_lock); /* UNLOCK */
1131
1132   if (r == MPLS_SUCCESS) {
1133     p->index = peer->index;
1134     LDP_EXIT(g->user_data, "ldp_cfg_peer_getnext");
1135     return ldp_cfg_peer_get(g, p, flag);
1136   }
1137   LDP_EXIT(g->user_data, "ldp_cfg_peer_getnext");
1138   return r;
1139 }
1140
1141 mpls_return_enum ldp_cfg_peer_test(mpls_cfg_handle handle, ldp_peer * p,
1142   uint32_t flag)
1143 {
1144   // ldp_global* g = (ldp_global*)handle;
1145   return MPLS_SUCCESS;
1146 }
1147
1148 mpls_return_enum ldp_cfg_peer_set(mpls_cfg_handle handle, ldp_peer * p,
1149   uint32_t flag)
1150 {
1151   ldp_global *global = (ldp_global *) handle;
1152   ldp_peer *peer = NULL;
1153   mpls_return_enum retval = MPLS_FAILURE;
1154
1155   MPLS_ASSERT(global !=NULL && p != NULL);
1156
1157   LDP_ENTER(global->user_data, "ldp_cfg_peer_set");
1158
1159   mpls_lock_get(global->global_lock); /* LOCK */
1160
1161   if (flag & LDP_CFG_ADD) {
1162     if ((peer = ldp_peer_create()) == NULL) {
1163       goto ldp_cfg_peer_set_end;
1164     }
1165     p->index = peer->index;
1166     _ldp_global_add_peer(global, peer);
1167   } else {
1168     ldp_global_find_peer_index(global, p->index, &peer);
1169   }
1170
1171   if (peer == NULL) {
1172     LDP_PRINT(global->user_data, "ldp_cfg_peer_set: no such peer\n");
1173
1174     goto ldp_cfg_peer_set_end;
1175   }
1176   if ((ldp_peer_is_active(peer) == MPLS_BOOL_TRUE) && (flag & LDP_PEER_CFG_WHEN_DOWN)) {
1177     LDP_PRINT(global->user_data, "ldp_cfg_peer_set: peer is activer\n");
1178
1179     goto ldp_cfg_peer_set_end;
1180   }
1181
1182   if (flag & LDP_CFG_DEL) {
1183     if (peer->entity != NULL) {
1184       LDP_PRINT(global->user_data,
1185         "ldp_cfg_peer_set: not cleanup correctly is activer\n");
1186
1187       goto ldp_cfg_peer_set_end;
1188     }
1189
1190     _ldp_global_del_peer(global, peer);
1191
1192     retval = MPLS_SUCCESS;
1193     goto ldp_cfg_peer_set_end;
1194   }
1195   if (flag & LDP_PEER_CFG_LABEL_SPACE) {
1196     peer->label_space = p->label_space;
1197   }
1198   if (flag & LDP_PEER_CFG_TARGET_ROLE) {
1199     peer->target_role = p->target_role;
1200   }
1201   if (flag & LDP_PEER_CFG_DEST_ADDR) {
1202     memcpy(&peer->dest.addr, &p->dest.addr, sizeof(mpls_inet_addr));
1203   }
1204   if (flag & LDP_PEER_CFG_PEER_NAME) {
1205     LDP_PRINT(global->user_data, "ldp_cfg_peer_set: peer_name = %s\n",
1206
1207       p->peer_name);
1208     strncpy(peer->peer_name, p->peer_name, MPLS_MAX_IF_NAME);
1209   }
1210   global->configuration_sequence_number++;
1211
1212   retval = MPLS_SUCCESS;
1213
1214 ldp_cfg_peer_set_end:
1215   mpls_lock_release(global->global_lock); /* UNLOCK */
1216
1217   LDP_EXIT(global->user_data, "ldp_cfg_peer_set");
1218
1219   return retval;
1220 }
1221 /******************* FEC **********************/
1222
1223 mpls_return_enum ldp_cfg_fec_get(mpls_cfg_handle handle, mpls_fec * f,
1224   uint32_t flag)
1225 {
1226   ldp_global *global = (ldp_global *) handle;
1227   ldp_fec *fec = NULL;
1228   mpls_return_enum retval = MPLS_FAILURE;
1229
1230   MPLS_ASSERT(global !=NULL && f != NULL);
1231
1232   LDP_ENTER(global->user_data, "ldp_cfg_fec_get");
1233
1234   mpls_lock_get(global->global_lock); /* LOCK */
1235
1236   if (flag & LDP_FEC_CFG_BY_INDEX) {
1237     ldp_global_find_fec_index(global, f->index, &fec);
1238   } else {
1239     fec = ldp_fec_find(global, f);
1240   }
1241   if (!fec)
1242       goto ldp_cfg_fec_get_end;
1243
1244   memcpy(f, &fec->info, sizeof(mpls_fec));
1245   f->index = fec->index;
1246   f->is_route = fec->is_route;
1247   retval = MPLS_SUCCESS;
1248
1249 ldp_cfg_fec_get_end:
1250   mpls_lock_release(global->global_lock); /* UNLOCK */
1251
1252   LDP_EXIT(global->user_data, "ldp_cfg_fec_get");
1253
1254   return retval;
1255 }
1256
1257 mpls_return_enum ldp_cfg_fec_getnext(mpls_cfg_handle handle, mpls_fec * f,
1258   uint32_t flag)
1259 {
1260   ldp_global *g = (ldp_global *) handle;
1261   ldp_fec *fec = NULL;
1262   mpls_return_enum r = MPLS_FAILURE;
1263   mpls_bool done = MPLS_BOOL_FALSE;
1264   int index;
1265
1266   LDP_ENTER(g->user_data, "ldp_cfg_fec_getnext");
1267
1268   if (f->index == 0) {
1269     index = 1;
1270   } else {
1271     index = f->index + 1;
1272   }
1273
1274   mpls_lock_get(g->global_lock); /* LOCK */
1275   while (done == MPLS_BOOL_FALSE) {
1276     switch ((r = ldp_global_find_fec_index(g, index, &fec))) {
1277       case MPLS_SUCCESS:
1278       case MPLS_END_OF_LIST:
1279         done = MPLS_BOOL_TRUE;
1280         break;
1281       case MPLS_FAILURE:
1282         break;
1283       default:
1284         MPLS_ASSERT(0);
1285     }
1286     index++;
1287   }
1288   mpls_lock_release(g->global_lock); /* UNLOCK */
1289
1290   if (r == MPLS_SUCCESS) {
1291     f->index = fec->index;
1292     LDP_EXIT(g->user_data, "ldp_cfg_fec_getnext");
1293     return ldp_cfg_fec_get(g, f, flag);
1294   }
1295   LDP_EXIT(g->user_data, "ldp_cfg_fec_getnext");
1296   return r;
1297 }
1298
1299 mpls_return_enum ldp_cfg_fec_test(mpls_cfg_handle handle, mpls_fec * f,
1300   uint32_t flag)
1301 {
1302   // ldp_global* g = (ldp_global*)handle;
1303   return MPLS_SUCCESS;
1304 }
1305
1306 mpls_return_enum ldp_cfg_fec_set(mpls_cfg_handle handle, mpls_fec * f,
1307   uint32_t flag)
1308 {
1309   ldp_global *global = (ldp_global *) handle;
1310   ldp_fec *fec = NULL;
1311   mpls_return_enum retval = MPLS_FAILURE;
1312
1313   MPLS_ASSERT(global != NULL && f != NULL);
1314
1315   LDP_ENTER(global->user_data, "ldp_cfg_fec_set");
1316
1317   mpls_lock_get(global->global_lock); /* LOCK */
1318
1319   if (flag & LDP_CFG_ADD) {
1320     if ((fec = ldp_fec_find(global, f))) {
1321       if (fec->is_route == MPLS_BOOL_TRUE) {
1322         goto ldp_cfg_fec_set_end;
1323       }
1324     } else {
1325       if ((fec = ldp_fec_create(global, f)) == NULL) {
1326         goto ldp_cfg_fec_set_end;
1327       }
1328     }
1329     fec->is_route = MPLS_BOOL_TRUE;
1330     MPLS_REFCNT_HOLD(fec);
1331     f->index = fec->index;
1332   } else {
1333     if (flag & LDP_FEC_CFG_BY_INDEX) {
1334       ldp_global_find_fec_index(global, f->index, &fec);
1335     } else {
1336       fec = ldp_fec_find(global, f);
1337     }
1338   }
1339
1340   if (fec == NULL) {
1341     LDP_PRINT(global->user_data, "ldp_cfg_fec_set: no such fec\n");
1342     goto ldp_cfg_fec_set_end;
1343   }
1344
1345   if (flag & LDP_CFG_DEL) {
1346     /*
1347      * we can only delete the fec if all of the nexthops have been removed
1348      */
1349     if (!MPLS_LIST_EMPTY(&fec->nh_root)) {
1350       goto ldp_cfg_fec_set_end;
1351     }
1352
1353     fec->is_route = MPLS_BOOL_FALSE;
1354
1355     /*
1356      * we hold the last refcnt, this should result in a call to
1357      * ldp_fec_delete
1358      */
1359     MPLS_REFCNT_RELEASE2(global, fec, ldp_fec_delete);
1360   }
1361
1362   retval = MPLS_SUCCESS;
1363
1364 ldp_cfg_fec_set_end:
1365   mpls_lock_release(global->global_lock); /* UNLOCK */
1366
1367   LDP_EXIT(global->user_data, "ldp_cfg_fec_set");
1368   return retval;
1369 }
1370
1371 mpls_return_enum ldp_cfg_fec_nexthop_get(mpls_cfg_handle handle, mpls_fec * f,
1372   mpls_nexthop *n, uint32_t flag)
1373 {
1374   ldp_global *global = (ldp_global *) handle;
1375   ldp_fec *fec = NULL;
1376   ldp_nexthop *nh = NULL;
1377   mpls_return_enum retval = MPLS_FAILURE;
1378
1379   MPLS_ASSERT(global !=NULL && f != NULL);
1380
1381   LDP_ENTER(global->user_data, "ldp_cfg_fec_nexthop_get");
1382
1383   mpls_lock_get(global->global_lock); /* LOCK */
1384
1385   if (flag & LDP_FEC_CFG_BY_INDEX) {
1386     ldp_global_find_fec_index(global, f->index, &fec);
1387   } else {
1388     fec = ldp_fec_find(global, f);
1389   }
1390   if (!fec)
1391       goto ldp_cfg_fec_nexthop_get_end;
1392
1393   if (flag & LDP_FEC_NEXTHOP_CFG_BY_INDEX) {
1394     ldp_fec_find_nexthop_index(fec, n->index, &nh);
1395   } else {
1396     nh = ldp_fec_nexthop_find(fec, n);
1397   }
1398   if (!nh)
1399     goto ldp_cfg_fec_nexthop_get_end;
1400
1401   memcpy(n, &nh->info, sizeof(mpls_nexthop));
1402   n->index = nh->index;
1403   retval = MPLS_SUCCESS;
1404
1405 ldp_cfg_fec_nexthop_get_end:
1406   mpls_lock_release(global->global_lock); /* UNLOCK */
1407
1408   LDP_EXIT(global->user_data, "ldp_cfg_fec_nexthop_get");
1409
1410   return retval;
1411 }
1412
1413 mpls_return_enum ldp_cfg_fec_nexthop_getnext(mpls_cfg_handle handle,
1414   mpls_fec * f, mpls_nexthop *n, uint32_t flag)
1415 {
1416   ldp_global *global = (ldp_global *) handle;
1417   ldp_fec *fec = NULL;
1418   ldp_nexthop *nh = NULL;
1419   mpls_return_enum r = MPLS_FAILURE;
1420   mpls_bool done = MPLS_BOOL_FALSE;
1421   int index;
1422
1423   LDP_ENTER(global->user_data, "ldp_cfg_fec_nexthop_getnext");
1424
1425   if (n->index == 0) {
1426     index = 1;
1427   } else {
1428     index = n->index + 1;
1429   }
1430
1431   mpls_lock_get(global->global_lock); /* LOCK */
1432
1433   if (flag & LDP_FEC_CFG_BY_INDEX) {
1434     ldp_global_find_fec_index(global, f->index, &fec);
1435   } else {
1436     fec = ldp_fec_find(global, f);
1437   }
1438   if (!fec)
1439       goto ldp_cfg_fec_nexthop_getnext_end;
1440
1441   while (done == MPLS_BOOL_FALSE) {
1442     switch ((r = ldp_fec_find_nexthop_index(fec, index, &nh))) {
1443       case MPLS_SUCCESS:
1444       case MPLS_END_OF_LIST:
1445         done = MPLS_BOOL_TRUE;
1446         break;
1447       case MPLS_FAILURE:
1448         break;
1449       default:
1450         MPLS_ASSERT(0);
1451     }
1452     index++;
1453   }
1454   mpls_lock_release(global->global_lock); /* UNLOCK */
1455
1456   if (r == MPLS_SUCCESS) {
1457     n->index = nh->index;
1458     LDP_EXIT(global->user_data, "ldp_cfg_fec_nexthop_getnext");
1459     return ldp_cfg_fec_nexthop_get(global, f, n, flag);
1460   }
1461
1462 ldp_cfg_fec_nexthop_getnext_end:
1463
1464   LDP_EXIT(global->user_data, "ldp_cfg_fec_nexthop_getnext");
1465   return r;
1466 }
1467
1468 mpls_return_enum ldp_cfg_fec_nexthop_test(mpls_cfg_handle handle, mpls_fec * f,
1469   mpls_nexthop *n, uint32_t flag)
1470 {
1471   // ldp_global* g = (ldp_global*)handle;
1472   return MPLS_SUCCESS;
1473 }
1474
1475 mpls_return_enum ldp_cfg_fec_nexthop_set(mpls_cfg_handle handle, mpls_fec * f,
1476   mpls_nexthop *n, uint32_t flag)
1477 {
1478   ldp_global *global = (ldp_global *) handle;
1479   ldp_fec *fec = NULL;
1480   ldp_nexthop *nh = NULL;
1481   mpls_return_enum retval = MPLS_FAILURE;
1482
1483   MPLS_ASSERT(global != NULL && f != NULL && n != NULL);
1484
1485   LDP_ENTER(global->user_data, "ldp_cfg_fec_nexthop_set");
1486
1487   mpls_lock_get(global->global_lock); /* LOCK */
1488
1489   if (flag & LDP_FEC_CFG_BY_INDEX) {
1490     ldp_global_find_fec_index(global, f->index, &fec);
1491   } else {
1492     fec = ldp_fec_find(global, f);
1493   }
1494   if (!fec)
1495       goto ldp_cfg_fec_nexthop_set_end;
1496
1497   if (flag & LDP_CFG_ADD) {
1498     if (ldp_fec_nexthop_find(fec, n) ||
1499       (nh = ldp_nexthop_create(global, n)) == NULL) {
1500       goto ldp_cfg_fec_nexthop_set_end;
1501     }
1502     n->index = nh->index;
1503     ldp_fec_add_nexthop(global, fec, nh);
1504     ldp_fec_process_add(global, fec, nh, NULL);
1505   } else {
1506     if (flag & LDP_FEC_NEXTHOP_CFG_BY_INDEX) {
1507       ldp_fec_find_nexthop_index(fec, n->index, &nh);
1508     } else {
1509       nh = ldp_fec_nexthop_find(fec, n);
1510     }
1511   }
1512
1513   if (nh == NULL) {
1514     LDP_PRINT(global->user_data, "ldp_cfg_fec_nexthop_set: no such nh\n");
1515     goto ldp_cfg_fec_nexthop_set_end;
1516   }
1517
1518   if (flag & LDP_CFG_DEL) {
1519     MPLS_REFCNT_HOLD(nh);
1520     ldp_fec_del_nexthop(global, fec, nh);
1521     if (ldp_fec_process_change(global, fec, MPLS_LIST_HEAD(&fec->nh_root),
1522       nh, NULL) != MPLS_SUCCESS) {
1523       MPLS_ASSERT(0);
1524     }
1525     MPLS_REFCNT_RELEASE2(global, nh, ldp_nexthop_delete);
1526   }
1527
1528   retval = MPLS_SUCCESS;
1529
1530 ldp_cfg_fec_nexthop_set_end:
1531   mpls_lock_release(global->global_lock); /* UNLOCK */
1532
1533   LDP_EXIT(global->user_data, "ldp_cfg_fec_nexthop_set");
1534
1535   return retval;
1536 }
1537
1538 /******************* ADDR **********************/
1539
1540 mpls_return_enum ldp_cfg_addr_get(mpls_cfg_handle handle, ldp_addr * a,
1541   uint32_t flag)
1542 {
1543   ldp_global *global = (ldp_global *) handle;
1544   ldp_session *session = NULL;
1545   ldp_nexthop *nexthop = NULL;
1546   ldp_addr *addr = NULL;
1547   mpls_return_enum retval = MPLS_FAILURE;
1548
1549   MPLS_ASSERT(global !=NULL && a != NULL);
1550
1551   LDP_ENTER(global->user_data, "ldp_cfg_addr_get");
1552
1553   mpls_lock_get(global->global_lock); /* LOCK */
1554
1555   ldp_global_find_addr_index(global, a->index, &addr);
1556
1557   if (!addr)
1558     goto ldp_cfg_addr_get_end;
1559
1560   memcpy(&a->address, &addr->address, sizeof(mpls_inet_addr));
1561   a->index = addr->index;
1562
1563   if (addr->session) {
1564     a->session_index = addr->session->index;
1565   }
1566
1567   if ((nexthop = MPLS_LIST_HEAD(&addr->nh_root))) {
1568     a->nexthop_index = nexthop->index;
1569   }
1570
1571   if (addr->iff) {
1572     a->if_index = addr->iff->index;
1573   }
1574
1575   retval = MPLS_SUCCESS;
1576
1577 ldp_cfg_addr_get_end:
1578   mpls_lock_release(global->global_lock); /* UNLOCK */
1579
1580   LDP_EXIT(global->user_data, "ldp_cfg_addr_get");
1581
1582   return retval;
1583 }
1584
1585 mpls_return_enum ldp_cfg_addr_getnext(mpls_cfg_handle handle, ldp_addr *a,
1586   uint32_t flag)
1587 {
1588   ldp_global *global = (ldp_global *) handle;
1589   ldp_addr *addr = NULL;
1590   mpls_return_enum r = MPLS_FAILURE;
1591   mpls_bool done = MPLS_BOOL_FALSE;
1592   int index;
1593
1594   LDP_ENTER(global->user_data, "ldp_cfg_addr_getnext");
1595
1596   if (a->index == 0) {
1597     index = 1;
1598   } else {
1599     index = a->index + 1;
1600   }
1601
1602   mpls_lock_get(global->global_lock); /* LOCK */
1603
1604   while (done == MPLS_BOOL_FALSE) {
1605     switch ((r = ldp_global_find_addr_index(global, index, &addr))) {
1606       case MPLS_SUCCESS:
1607       case MPLS_END_OF_LIST:
1608         done = MPLS_BOOL_TRUE;
1609         break;
1610       case MPLS_FAILURE:
1611         break;
1612       default:
1613         MPLS_ASSERT(0);
1614     }
1615     index++;
1616   }
1617   mpls_lock_release(global->global_lock); /* UNLOCK */
1618
1619   if (r == MPLS_SUCCESS) {
1620     a->index = addr->index;
1621     LDP_EXIT(global->user_data, "ldp_cfg_addr_getnext");
1622     return ldp_cfg_addr_get(global, a, flag);
1623   }
1624
1625   LDP_EXIT(global->user_data, "ldp_cfg_addr_getnext");
1626   return r;
1627 }
1628
1629 /******************* IF ADDR **********************/
1630
1631 mpls_return_enum ldp_cfg_if_addr_get(mpls_cfg_handle handle, ldp_if * i,
1632   ldp_addr * a, uint32_t flag)
1633 {
1634   ldp_global *global = (ldp_global *) handle;
1635   ldp_addr *addr = NULL;
1636   ldp_if *iff = NULL;
1637   mpls_return_enum retval = MPLS_FAILURE;
1638
1639   MPLS_ASSERT(global !=NULL && i != NULL && a != NULL);
1640
1641   LDP_ENTER(global->user_data, "ldp_cfg_if_addr_get");
1642
1643   mpls_lock_get(global->global_lock); /* LOCK */
1644
1645   if (flag & LDP_IF_CFG_BY_INDEX) {
1646     ldp_global_find_if_index(global, i->index, &iff);
1647   } else {
1648     iff = ldp_global_find_if_handle(global, i->handle);
1649   }
1650   if (!iff)
1651       goto ldp_cfg_if_addr_get_end;
1652
1653   if (flag & LDP_IF_ADDR_CFG_BY_INDEX) {
1654     ldp_if_find_addr_index(iff, a->index, &addr);
1655   } else {
1656     addr = ldp_if_addr_find(iff, &a->address);
1657   }
1658   if (!addr)
1659     goto ldp_cfg_if_addr_get_end;
1660
1661   memcpy(&a->address, &addr->address, sizeof(mpls_inet_addr));
1662   a->index = addr->index;
1663
1664   retval = MPLS_SUCCESS;
1665
1666 ldp_cfg_if_addr_get_end:
1667   mpls_lock_release(global->global_lock); /* UNLOCK */
1668
1669   LDP_EXIT(global->user_data, "ldp_cfg_if_addr_get");
1670
1671   return retval;
1672 }
1673
1674 mpls_return_enum ldp_cfg_if_addr_getnext(mpls_cfg_handle handle,
1675   ldp_if * i, ldp_addr *a, uint32_t flag)
1676 {
1677   ldp_global *global = (ldp_global *) handle;
1678   ldp_if *iff = NULL;
1679   ldp_addr *addr = NULL;
1680   mpls_return_enum r = MPLS_FAILURE;
1681   mpls_bool done = MPLS_BOOL_FALSE;
1682   int index;
1683
1684   LDP_ENTER(global->user_data, "ldp_cfg_if_addr_getnext");
1685
1686   if (a->index == 0) {
1687     index = 1;
1688   } else {
1689     index = a->index + 1;
1690   }
1691
1692   mpls_lock_get(global->global_lock); /* LOCK */
1693
1694   if (flag & LDP_IF_CFG_BY_INDEX) {
1695     ldp_global_find_if_index(global, i->index, &iff);
1696   } else {
1697     iff = ldp_global_find_if_handle(global, i->handle);
1698   }
1699   if (!iff)
1700       goto ldp_cfg_if_addr_getnext_end;
1701
1702   while (done == MPLS_BOOL_FALSE) {
1703     switch ((r = ldp_if_find_addr_index(iff, index, &addr))) {
1704       case MPLS_SUCCESS:
1705       case MPLS_END_OF_LIST:
1706         done = MPLS_BOOL_TRUE;
1707         break;
1708       case MPLS_FAILURE:
1709         break;
1710       default:
1711         MPLS_ASSERT(0);
1712     }
1713     index++;
1714   }
1715   mpls_lock_release(global->global_lock); /* UNLOCK */
1716
1717   if (r == MPLS_SUCCESS) {
1718     a->index = addr->index;
1719     LDP_EXIT(global->user_data, "ldp_cfg_if_addr_getnext");
1720     return ldp_cfg_if_addr_get(global, i, a, flag);
1721   }
1722
1723 ldp_cfg_if_addr_getnext_end:
1724
1725   LDP_EXIT(global->user_data, "ldp_cfg_if_addr_getnext");
1726   return r;
1727 }
1728
1729 mpls_return_enum ldp_cfg_if_addr_set(mpls_cfg_handle handle, ldp_if * i,
1730   ldp_addr *a, uint32_t flag)
1731 {
1732   ldp_global *global = (ldp_global *) handle;
1733   ldp_if *iff = NULL;
1734   ldp_addr *addr = NULL;
1735   mpls_return_enum retval = MPLS_FAILURE;
1736
1737   MPLS_ASSERT(global != NULL && i != NULL && a != NULL);
1738
1739   LDP_ENTER(global->user_data, "ldp_cfg_if_addr_set");
1740
1741   mpls_lock_get(global->global_lock); /* LOCK */
1742
1743   if (flag & LDP_IF_CFG_BY_INDEX) {
1744     ldp_global_find_if_index(global, i->index, &iff);
1745   } else {
1746     iff = ldp_global_find_if_handle(global, i->handle);
1747   }
1748   if (!iff) {
1749       LDP_PRINT(global->user_data, "ldp_cfg_if_addr_set: no such iff\n");
1750       goto ldp_cfg_if_addr_set_end;
1751   }
1752
1753   if (flag & LDP_CFG_ADD) {
1754     if (ldp_if_addr_find(iff, &a->address) || ((addr = ldp_addr_create(global,
1755       &a->address)) == NULL)) {
1756       goto ldp_cfg_if_addr_set_end;
1757     }
1758     a->index = addr->index;
1759     ldp_if_add_addr(iff, addr);
1760     ldp_addr_process_add(global, addr);
1761   } else {
1762     if (flag & LDP_IF_ADDR_CFG_BY_INDEX) {
1763       ldp_if_find_addr_index(iff, a->index, &addr);
1764     } else {
1765       addr = ldp_if_addr_find(iff, &a->address);
1766     }
1767   }
1768
1769   if (addr == NULL) {
1770     LDP_PRINT(global->user_data, "ldp_cfg_if_addr_set: no such addr\n");
1771     goto ldp_cfg_if_addr_set_end;
1772   }
1773
1774   if (flag & LDP_CFG_DEL) {
1775     ldp_addr_process_remove(global, addr);
1776     ldp_if_del_addr(global, iff, addr);
1777   }
1778
1779   retval = MPLS_SUCCESS;
1780
1781 ldp_cfg_if_addr_set_end:
1782   mpls_lock_release(global->global_lock); /* UNLOCK */
1783
1784   LDP_EXIT(global->user_data, "ldp_cfg_if_addr_set");
1785
1786   return retval;
1787 }
1788
1789 /******************* ADJACENCY **********************/
1790
1791 mpls_return_enum ldp_cfg_adj_get(mpls_cfg_handle handle, ldp_adj * a,
1792   uint32_t flag)
1793 {
1794   ldp_global *global = (ldp_global *) handle;
1795   ldp_adj *adj = NULL;
1796   mpls_return_enum retval = MPLS_FAILURE;
1797
1798   MPLS_ASSERT(global != NULL && a != NULL);
1799
1800   LDP_ENTER(global->user_data, "ldp_cfg_adj_get");
1801
1802   mpls_lock_get(global->global_lock); /* LOCK */
1803
1804   if (ldp_global_find_adj_index(global, a->index, &adj) != MPLS_SUCCESS)
1805       goto ldp_cfg_adj_get_end;
1806
1807   if (flag & LDP_ADJ_CFG_REMOTE_TRADDR) {
1808     memcpy(&a->remote_transport_address, &adj->remote_transport_address,
1809       sizeof(mpls_inet_addr));
1810   }
1811   if (flag & LDP_ADJ_CFG_REMOTE_SRCADDR) {
1812     memcpy(&a->remote_source_address, &adj->remote_source_address,
1813       sizeof(mpls_inet_addr));
1814   }
1815   if (flag & LDP_ADJ_CFG_REMOTE_LSRADDR) {
1816     memcpy(&a->remote_lsr_address, &adj->remote_lsr_address,
1817       sizeof(mpls_inet_addr));
1818   }
1819   if (flag & LDP_ADJ_CFG_REMOTE_CSN) {
1820     a->remote_csn = adj->remote_csn;
1821   }
1822   if (flag & LDP_ADJ_CFG_REMOTE_LABELSPACE) {
1823     a->remote_label_space = adj->remote_label_space;
1824   }
1825   if (flag & LDP_ADJ_CFG_REMOTE_HELLOTIME) {
1826     a->remote_hellotime = adj->remote_hellotime;
1827   }
1828   if (flag & LDP_ADJ_CFG_ENTITY_INDEX) {
1829     a->entity_index = adj->entity ? adj->entity->index : 0;
1830   }
1831   if (flag & LDP_ADJ_CFG_REMOTE_SESSION_INDEX) {
1832     a->session_index = (adj->session) ? (adj->session->index) : 0;
1833   }
1834   if (flag & LDP_ADJ_CFG_ROLE) {
1835     a->role = adj->role;
1836   }
1837   retval = MPLS_SUCCESS;
1838
1839 ldp_cfg_adj_get_end:
1840
1841   mpls_lock_release(global->global_lock); /* UNLOCK */
1842
1843   LDP_EXIT(global->user_data, "ldp_cfg_adj_get");
1844
1845   return retval;
1846 }
1847
1848 mpls_return_enum ldp_cfg_adj_getnext(mpls_cfg_handle handle, ldp_adj * a,
1849   uint32_t flag)
1850 {
1851   ldp_global *g = (ldp_global *) handle;
1852   ldp_adj *adj = NULL;
1853   mpls_return_enum r = MPLS_FAILURE;
1854   mpls_bool done = MPLS_BOOL_FALSE;
1855   int index;
1856
1857   LDP_ENTER(g->user_data, "ldp_cfg_adj_getnext");
1858
1859   if (a->index == 0) {
1860     index = 1;
1861   } else {
1862     index = a->index + 1;
1863   }
1864
1865   mpls_lock_get(g->global_lock); /* LOCK */
1866   while (done == MPLS_BOOL_FALSE) {
1867     switch ((r = ldp_global_find_adj_index(g, index, &adj))) {
1868       case MPLS_SUCCESS:
1869       case MPLS_END_OF_LIST:
1870         done = MPLS_BOOL_TRUE;
1871         break;
1872       case MPLS_FAILURE:
1873         break;
1874       default:
1875         MPLS_ASSERT(0);
1876     }
1877     index++;
1878   }
1879   mpls_lock_release(g->global_lock); /* UNLOCK */
1880
1881   if (r == MPLS_SUCCESS) {
1882     a->index = adj->index;
1883     LDP_EXIT(g->user_data, "ldp_cfg_adj_getnext");
1884     return ldp_cfg_adj_get(g, a, flag);
1885   }
1886   LDP_EXIT(g->user_data, "ldp_cfg_adj_getnext");
1887   return r;
1888 }
1889
1890 /******************* SESSION **********************/
1891
1892 mpls_return_enum ldp_cfg_session_get(mpls_cfg_handle handle, ldp_session * s,
1893   uint32_t flag)
1894 {
1895   ldp_global *global = (ldp_global *) handle;
1896   ldp_session *session = NULL;
1897   mpls_return_enum retval = MPLS_FAILURE;
1898
1899   MPLS_ASSERT(global !=NULL && s != NULL);
1900
1901   LDP_ENTER(global->user_data, "ldp_cfg_session_get");
1902
1903   mpls_lock_get(global->global_lock); /* LOCK */
1904
1905   if (ldp_global_find_session_index(global, s->index, &session) != MPLS_SUCCESS)
1906       goto ldp_cfg_session_get_end;
1907
1908   if (flag & LDP_SESSION_CFG_STATE) {
1909     s->state = session->state;
1910   }
1911   if (flag & LDP_SESSION_CFG_OPER_UP) {
1912     s->oper_up = session->oper_up;
1913   }
1914   if (flag & LDP_SESSION_CFG_MAX_PDU) {
1915     s->oper_max_pdu = session->oper_max_pdu;
1916   }
1917   if (flag & LDP_SESSION_CFG_KEEPALIVE) {
1918     s->oper_keepalive = session->oper_keepalive;
1919   }
1920   if (flag & LDP_SESSION_CFG_PATH_LIMIT) {
1921     s->oper_path_vector_limit = session->oper_path_vector_limit;
1922   }
1923   if (flag & LDP_SESSION_CFG_DIST_MODE) {
1924     s->oper_distribution_mode = session->oper_distribution_mode;
1925   }
1926   if (flag & LDP_SESSION_CFG_LOOP_DETECTION) {
1927     s->oper_loop_detection = session->oper_loop_detection;
1928   }
1929   if (flag & LDP_SESSION_CFG_REMOTE_MAX_PDU) {
1930     s->remote_max_pdu = session->remote_max_pdu;
1931   }
1932   if (flag & LDP_SESSION_CFG_REMOTE_KEEPALIVE) {
1933     s->remote_keepalive = session->remote_keepalive;
1934   }
1935   if (flag & LDP_SESSION_CFG_REMOTE_PATH_LIMIT) {
1936     s->remote_path_vector_limit = session->remote_path_vector_limit;
1937   }
1938   if (flag & LDP_SESSION_CFG_REMOTE_DIST_MODE) {
1939     s->remote_distribution_mode = session->remote_distribution_mode;
1940   }
1941   if (flag & LDP_SESSION_CFG_REMOTE_LOOP_DETECTION) {
1942     s->remote_loop_detection = session->remote_loop_detection;
1943   }
1944   if (flag & LDP_SESSION_CFG_REMOTE_ADDR) {
1945     s->remote_dest.addr.type = session->remote_dest.addr.type;
1946     s->remote_dest.addr.u.ipv4 = session->remote_dest.addr.u.ipv4;
1947   }
1948   if (flag & LDP_SESSION_CFG_REMOTE_PORT) {
1949     s->remote_dest.port = session->remote_dest.port;
1950   }
1951   if (flag & LDP_SESSION_CFG_LABEL_RESOURCE_STATE_LOCAL) {
1952     s->no_label_resource_sent = session->no_label_resource_sent;
1953   }
1954   if (flag & LDP_SESSION_CFG_LABEL_RESOURCE_STATE_REMOTE) {
1955     s->no_label_resource_recv = session->no_label_resource_recv;
1956   }
1957   if (flag & LDP_SESSION_CFG_ADJ_INDEX) {
1958     ldp_adj *a = MPLS_LIST_HEAD(&session->adj_root);
1959     s->adj_index = a ? a->index : 0;
1960   }
1961   if (flag & LDP_SESSION_CFG_MESG_TX) {
1962     s->mesg_tx = session->mesg_tx;
1963   }
1964   if (flag & LDP_SESSION_CFG_MESG_RX) {
1965     s->mesg_rx = session->mesg_rx;
1966   }
1967   if (flag & LDP_SESSION_CFG_LOCAL_NAME) {
1968     if (mpls_socket_handle_verify(global->socket_handle,
1969       session->socket) == MPLS_BOOL_TRUE) {
1970       mpls_socket_get_local_name(global->socket_handle, session->socket,
1971         &s->local_name);
1972     }
1973   }
1974   if (flag & LDP_SESSION_CFG_REMOTE_NAME) {
1975     if (mpls_socket_handle_verify(global->socket_handle,
1976       session->socket) == MPLS_BOOL_TRUE) {
1977       mpls_socket_get_remote_name(global->socket_handle, session->socket,
1978         &s->remote_name);
1979     }
1980   }
1981   retval = MPLS_SUCCESS;
1982
1983 ldp_cfg_session_get_end:
1984   mpls_lock_release(global->global_lock); /* UNLOCK */
1985
1986   LDP_EXIT(global->user_data, "ldp_cfg_session_get");
1987
1988   return retval;
1989 }
1990
1991 mpls_return_enum ldp_cfg_session_getnext(mpls_cfg_handle handle, ldp_session * s,
1992   uint32_t flag)
1993 {
1994   ldp_global *g = (ldp_global *) handle;
1995   ldp_session *ses = NULL;
1996   mpls_return_enum r = MPLS_FAILURE;
1997   mpls_bool done = MPLS_BOOL_FALSE;
1998   int index;
1999
2000   LDP_ENTER(g->user_data, "ldp_cfg_session_getnext");
2001
2002   if (s->index == 0) {
2003     index = 1;
2004   } else {
2005     index = s->index + 1;
2006   }
2007
2008   mpls_lock_get(g->global_lock); /* LOCK */
2009   while (done == MPLS_BOOL_FALSE) {
2010     switch ((r = ldp_global_find_session_index(g, index, &ses))) {
2011       case MPLS_SUCCESS:
2012       case MPLS_END_OF_LIST:
2013         done = MPLS_BOOL_TRUE;
2014         break;
2015       case MPLS_FAILURE:
2016         break;
2017       default:
2018         MPLS_ASSERT(0);
2019     }
2020     index++;
2021   }
2022   mpls_lock_release(g->global_lock); /* UNLOCK */
2023
2024   if (r == MPLS_SUCCESS) {
2025     s->index = ses->index;
2026
2027     LDP_EXIT(g->user_data, "ldp_cfg_session_getnext");
2028     return ldp_cfg_session_get(g, s, flag);
2029   }
2030
2031   LDP_EXIT(g->user_data, "ldp_cfg_session_getnext");
2032
2033   return r;
2034 }
2035
2036 mpls_return_enum ldp_cfg_session_adj_getnext(mpls_cfg_handle handle,
2037   ldp_session * s)
2038 {
2039   ldp_global *g = (ldp_global *) handle;
2040   mpls_bool this_one = MPLS_BOOL_FALSE;
2041   mpls_return_enum r = MPLS_FAILURE;
2042   ldp_adj *adj_next = NULL;
2043   ldp_adj *adj = NULL;
2044   ldp_session *session = NULL;
2045
2046   LDP_ENTER(g->user_data, "ldp_cfg_session_adj_getnext");
2047
2048   /* if an adj_index of zero is sent, get the index of
2049    * the first adj in the list
2050    */
2051   if (!s->adj_index) {
2052     this_one = MPLS_BOOL_TRUE;
2053   }
2054
2055   mpls_lock_get(g->global_lock); /* LOCK */
2056
2057   if (ldp_global_find_session_index(g, s->index, &session) == MPLS_SUCCESS) {
2058     adj = MPLS_LIST_HEAD(&session->adj_root);
2059     while (adj) {
2060       if (this_one == MPLS_BOOL_TRUE) {
2061         adj_next = adj;
2062         break;
2063       }
2064
2065       /* since the entities are sort in the list ... */
2066       if (adj->index > s->adj_index) {
2067         break;
2068       } else if (adj->index == s->adj_index) {
2069         this_one = MPLS_BOOL_TRUE;
2070       }
2071       adj = MPLS_LIST_NEXT(&session->adj_root, adj, _session);
2072     }
2073   }
2074   mpls_lock_release(g->global_lock); /* UNLOCK */
2075
2076   if (adj_next) {
2077     s->adj_index = adj_next->index;
2078     r = MPLS_SUCCESS;
2079   }
2080
2081   LDP_EXIT(g->user_data, "ldp_cfg_session_adj_getnext");
2082   return r;
2083 }
2084
2085 mpls_return_enum ldp_cfg_session_raddr_get(mpls_cfg_handle handle,
2086   ldp_session * s, ldp_addr * a, uint32_t flag)
2087 {
2088   ldp_global *global = (ldp_global *) handle;
2089   ldp_session *session = NULL;
2090   ldp_addr *addr = NULL;
2091   mpls_return_enum retval = MPLS_FAILURE;
2092
2093   MPLS_ASSERT(global !=NULL && s != NULL && a != NULL);
2094
2095   LDP_ENTER(global->user_data, "ldp_cfg_session_raddr_get");
2096
2097   mpls_lock_get(global->global_lock); /* LOCK */
2098
2099   if (ldp_global_find_session_index(global, s->index, &session) != MPLS_SUCCESS)
2100       goto ldp_cfg_session_raddr_get_end;
2101
2102   if (ldp_session_find_raddr_index(session, a->index, &addr) != MPLS_SUCCESS)
2103       goto ldp_cfg_session_raddr_get_end;
2104
2105   if (flag & LDP_SESSION_RADDR_CFG_ADDR) {
2106     memcpy(&a->address,&addr->address,sizeof(struct mpls_inet_addr));
2107   }
2108   if (flag & LDP_SESSION_RADDR_CFG_INDEX) {
2109     a->index = addr->index;
2110   }
2111   retval = MPLS_SUCCESS;
2112
2113 ldp_cfg_session_raddr_get_end:
2114   mpls_lock_release(global->global_lock); /* UNLOCK */
2115
2116   LDP_EXIT(global->user_data, "ldp_cfg_session_raddr_get");
2117
2118   return retval;
2119 }
2120
2121 mpls_return_enum ldp_cfg_session_raddr_getnext(mpls_cfg_handle handle,
2122   ldp_session * s, ldp_addr * a, uint32_t flag)
2123 {
2124   ldp_global *g = (ldp_global *) handle;
2125   ldp_addr *addr = NULL;
2126   mpls_return_enum r = MPLS_FAILURE;
2127   mpls_bool done = MPLS_BOOL_FALSE;
2128   ldp_session *sp = NULL;
2129   int index;
2130
2131   LDP_ENTER(g->user_data, "ldp_cfg_session_raddr_getnext");
2132
2133   if (a->index == 0) {
2134     index = 1;
2135   } else {
2136     index = a->index + 1;
2137   }
2138
2139   r = ldp_global_find_session_index(g, s->index, &sp);
2140   if (r != MPLS_SUCCESS) {
2141     return r;
2142   }
2143
2144   mpls_lock_get(g->global_lock); /* LOCK */
2145   while (done == MPLS_BOOL_FALSE) {
2146     switch ((r = ldp_session_find_raddr_index(sp, index, &addr))) {
2147       case MPLS_SUCCESS:
2148       case MPLS_END_OF_LIST:
2149         done = MPLS_BOOL_TRUE;
2150         break;
2151       case MPLS_FAILURE:
2152         break;
2153       default:
2154         MPLS_ASSERT(0);
2155     }
2156     index++;
2157   }
2158   mpls_lock_release(g->global_lock); /* UNLOCK */
2159
2160   if (r == MPLS_SUCCESS) {
2161     a->index = addr->index;
2162     r = ldp_cfg_session_raddr_get(handle, sp, a, flag);
2163   }
2164
2165   LDP_EXIT(g->user_data, "ldp_cfg_session_getnext");
2166   return r;
2167 }
2168
2169 /******************* IN LABEL **********************/
2170
2171 mpls_return_enum ldp_cfg_inlabel_get(mpls_cfg_handle handle, ldp_inlabel * i,
2172   uint32_t flag)
2173 {
2174   ldp_global *global = (ldp_global *) handle;
2175   ldp_inlabel *inlabel = NULL;
2176   mpls_return_enum retval = MPLS_FAILURE;
2177
2178   MPLS_ASSERT(global !=NULL && i != NULL);
2179
2180   LDP_ENTER(global->user_data, "ldp_cfg_inlabel_get");
2181
2182   mpls_lock_get(global->global_lock); /* LOCK */
2183
2184   if (ldp_global_find_inlabel_index(global, i->index, &inlabel) != MPLS_SUCCESS)
2185       goto ldp_cfg_inlabel_get_end;
2186
2187   if (flag & LDP_INLABEL_CFG_LABELSPACE) {
2188     i->info.labelspace = inlabel->info.labelspace;
2189   }
2190   if (flag & LDP_INLABEL_CFG_LABEL) {
2191     memcpy(&i->info.label, &inlabel->info.label, sizeof(mpls_label_struct));
2192   }
2193   if (flag & LDP_INLABEL_CFG_OUTLABEL_INDEX) {
2194     i->outlabel_index = (inlabel->outlabel) ? (inlabel->outlabel->index) : 0;
2195   }
2196
2197   retval = MPLS_SUCCESS;
2198
2199 ldp_cfg_inlabel_get_end:
2200   mpls_lock_release(global->global_lock); /* UNLOCK */
2201
2202   LDP_EXIT(global->user_data, "ldp_cfg_inlabel_get");
2203
2204   return retval;
2205 }
2206
2207 mpls_return_enum ldp_cfg_inlabel_getnext(mpls_cfg_handle handle, ldp_inlabel * i,
2208   uint32_t flag)
2209 {
2210   ldp_global *g = (ldp_global *) handle;
2211   ldp_inlabel *inlabel = NULL;
2212   mpls_return_enum r = MPLS_FAILURE;
2213   mpls_bool done = MPLS_BOOL_FALSE;
2214   int index;
2215
2216   LDP_ENTER(g->user_data, "ldp_cfg_inlabel_getnext");
2217
2218   if (i->index == 0) {
2219     index = 1;
2220   } else {
2221     index = i->index + 1;
2222   }
2223
2224   mpls_lock_get(g->global_lock); /* LOCK */
2225   while (done == MPLS_BOOL_FALSE) {
2226     switch ((r = ldp_global_find_inlabel_index(g, index, &inlabel))) {
2227       case MPLS_SUCCESS:
2228       case MPLS_END_OF_LIST:
2229         done = MPLS_BOOL_TRUE;
2230         break;
2231       case MPLS_FAILURE:
2232         break;
2233       default:
2234         MPLS_ASSERT(0);
2235     }
2236     index++;
2237   }
2238   mpls_lock_release(g->global_lock); /* UNLOCK */
2239
2240   if (r == MPLS_SUCCESS) {
2241     i->index = inlabel->index;
2242
2243     LDP_EXIT(g->user_data, "ldp_cfg_inlabel_getnext");
2244     return ldp_cfg_inlabel_get(g, i, flag);
2245   }
2246
2247   LDP_EXIT(g->user_data, "ldp_cfg_inlabel_getnext");
2248
2249   return r;
2250 }
2251
2252 /******************* OUT LABEL **********************/
2253
2254 mpls_return_enum ldp_cfg_outlabel_get(mpls_cfg_handle handle, ldp_outlabel * o,
2255   uint32_t flag)
2256 {
2257   ldp_global *global = (ldp_global *) handle;
2258   ldp_outlabel *outlabel = NULL;
2259   mpls_return_enum retval = MPLS_FAILURE;
2260
2261   MPLS_ASSERT(global !=NULL && o != NULL);
2262
2263   LDP_ENTER(global->user_data, "ldp_cfg_outlabel_get");
2264
2265   mpls_lock_get(global->global_lock); /* LOCK */
2266
2267   if (ldp_global_find_outlabel_index(global, o->index,
2268       &outlabel) != MPLS_SUCCESS) goto ldp_cfg_outlabel_get_end;
2269
2270   if (flag & LDP_OUTLABEL_CFG_NH_INDEX) {
2271     if (outlabel->nh) {
2272       o->nh_index = outlabel->nh->index;
2273     } else {
2274       o->nh_index = 0;
2275     }
2276   }
2277   if (flag & LDP_OUTLABEL_CFG_SESSION_INDEX) {
2278     o->session_index = (outlabel->session) ? (outlabel->session->index) : 0;
2279   }
2280   if (flag & LDP_OUTLABEL_CFG_LABEL) {
2281     memcpy(&o->info.label, &outlabel->info.label, sizeof(mpls_label_struct));
2282   }
2283   if (flag & LDP_OUTLABEL_CFG_MERGE_COUNT) {
2284     o->merge_count = outlabel->merge_count;
2285   }
2286
2287   retval = MPLS_SUCCESS;
2288
2289 ldp_cfg_outlabel_get_end:
2290   mpls_lock_release(global->global_lock); /* UNLOCK */
2291
2292   LDP_EXIT(global->user_data, "ldp_cfg_outlabel_get");
2293
2294   return retval;
2295 }
2296
2297 mpls_return_enum ldp_cfg_outlabel_getnext(mpls_cfg_handle handle,
2298   ldp_outlabel * o, uint32_t flag)
2299 {
2300   ldp_global *g = (ldp_global *) handle;
2301   ldp_outlabel *outlabel = NULL;
2302   mpls_return_enum r = MPLS_FAILURE;
2303   mpls_bool done = MPLS_BOOL_FALSE;
2304   int index;
2305
2306   LDP_ENTER(g->user_data, "ldp_cfg_outlabel_getnext");
2307
2308   if (o->index == 0) {
2309     index = 1;
2310   } else {
2311     index = o->index + 1;
2312   }
2313
2314   mpls_lock_get(g->global_lock); /* LOCK */
2315   while (done == MPLS_BOOL_FALSE) {
2316     switch ((r = ldp_global_find_outlabel_index(g, index, &outlabel))) {
2317       case MPLS_SUCCESS:
2318       case MPLS_END_OF_LIST:
2319         done = MPLS_BOOL_TRUE;
2320         break;
2321       case MPLS_FAILURE:
2322         break;
2323       default:
2324         MPLS_ASSERT(0);
2325     }
2326     index++;
2327   }
2328   mpls_lock_release(g->global_lock); /* UNLOCK */
2329
2330   if (r == MPLS_SUCCESS) {
2331     o->index = outlabel->index;
2332
2333     LDP_EXIT(g->user_data, "ldp_cfg_outlabel_getnext");
2334     return ldp_cfg_outlabel_get(g, o, flag);
2335   }
2336
2337   LDP_EXIT(g->user_data, "ldp_cfg_outlabel_getnext");
2338
2339   return r;
2340 }
2341
2342 /******************* TUNNEL **********************/
2343
2344 mpls_return_enum ldp_cfg_tunnel_set(mpls_cfg_handle handle, ldp_tunnel * t,
2345   uint32_t flag)
2346 {
2347   ldp_global *global = (ldp_global *) handle;
2348   mpls_return_enum retval = MPLS_FAILURE;
2349   ldp_tunnel *tunnel = NULL;
2350
2351   MPLS_ASSERT(global !=NULL);
2352
2353   LDP_ENTER(global->user_data, "ldp_cfg_tunnel_set");
2354
2355   mpls_lock_get(global->global_lock); /* LOCK */
2356
2357   if (flag & LDP_CFG_ADD) {
2358     if (!(tunnel = ldp_tunnel_create())) {
2359       goto ldp_cfg_tunnel_set_end;
2360     }
2361     _ldp_global_add_tunnel(global, tunnel);
2362
2363     t->index = tunnel->index;
2364   } else {
2365     ldp_global_find_tunnel_index(global, t->index, &tunnel);
2366   }
2367
2368   if (!tunnel) {
2369     LDP_PRINT(global->user_data,
2370
2371       "ldp_cfg_tunnel_set:could not create tunnel\n");
2372     goto ldp_cfg_tunnel_set_end;
2373   }
2374
2375   if ((ldp_tunnel_is_active(tunnel) == MPLS_BOOL_TRUE) &&
2376     (flag & LDP_TUNNEL_CFG_WHEN_DOWN)) {
2377     LDP_PRINT(global->user_data, "ldp_cfg_tunnel_set: tunnel is active\n");
2378
2379     goto ldp_cfg_tunnel_set_end;
2380   }
2381
2382   if (flag & LDP_CFG_DEL) {
2383     if (tunnel->outlabel)
2384       ldp_tunnel_del_outlabel(global, tunnel);
2385     if (tunnel->resource)
2386       ldp_tunnel_del_resource(tunnel);
2387     if (tunnel->hop_list)
2388       ldp_tunnel_del_hop_list(tunnel);
2389     _ldp_global_del_tunnel(global, tunnel);
2390
2391     retval = MPLS_SUCCESS;
2392     goto ldp_cfg_tunnel_set_end;
2393   }
2394
2395   if (flag & LDP_TUNNEL_CFG_INGRESS) {
2396     memcpy(&tunnel->ingress_lsrid, &t->ingress_lsrid, sizeof(ldp_addr));
2397   }
2398   if (flag & LDP_TUNNEL_CFG_EGRESS) {
2399     memcpy(&tunnel->egress_lsrid, &t->egress_lsrid, sizeof(ldp_addr));
2400   }
2401   if (flag & LDP_TUNNEL_CFG_NAME) {
2402     memcpy(&tunnel->name, &t->name, MPLS_MAX_IF_NAME);
2403   }
2404   if (flag & LDP_TUNNEL_CFG_IS_IF) {
2405     tunnel->is_interface = t->is_interface;
2406   }
2407   if (flag & LDP_TUNNEL_CFG_OUTLABEL) {
2408     ldp_outlabel *outlabel = NULL;
2409
2410     if (t->outlabel_index) {
2411       ldp_global_find_outlabel_index(global, t->outlabel_index, &outlabel);
2412
2413       if (!outlabel) {
2414         goto ldp_cfg_tunnel_set_end;
2415       }
2416       ldp_tunnel_add_outlabel(tunnel, outlabel);
2417     } else {
2418       ldp_tunnel_del_outlabel(global, tunnel);
2419     }
2420   }
2421   if (flag & LDP_TUNNEL_CFG_SETUP_PRIO) {
2422     tunnel->setup_prio = t->setup_prio;
2423   }
2424   if (flag & LDP_TUNNEL_CFG_HOLD_PRIO) {
2425     tunnel->hold_prio = t->hold_prio;
2426   }
2427   if (flag & LDP_TUNNEL_CFG_INSTANCE_PRIO) {
2428     tunnel->instance_prio = t->instance_prio;
2429   }
2430   if (flag & LDP_TUNNEL_CFG_LOCAL_PROTECT) {
2431     tunnel->local_protect = t->local_protect;
2432   }
2433   if (flag & LDP_TUNNEL_CFG_RESOURCE_INDEX) {
2434     ldp_resource *resource = NULL;
2435
2436     if (t->resource_index) {
2437       ldp_global_find_resource_index(global, t->resource_index, &resource);
2438
2439       if (!resource) {
2440         goto ldp_cfg_tunnel_set_end;
2441       }
2442       ldp_tunnel_add_resource(tunnel, resource);
2443     } else {
2444       ldp_tunnel_del_resource(tunnel);
2445     }
2446   }
2447   if (flag & LDP_TUNNEL_CFG_HOP_LIST_INDEX) {
2448     ldp_hop_list *hop_list = NULL;
2449
2450     if (t->hop_list_index) {
2451       ldp_global_find_hop_list_index(global, t->hop_list_index, &hop_list);
2452
2453       if (!hop_list) {
2454         goto ldp_cfg_tunnel_set_end;
2455       }
2456       ldp_tunnel_add_hop_list(tunnel, hop_list);
2457     } else {
2458       ldp_tunnel_del_hop_list(tunnel);
2459     }
2460   }
2461   if (flag & LDP_TUNNEL_CFG_FEC) {
2462     memcpy(&tunnel->fec, &t->fec, sizeof(ldp_fec));
2463   }
2464   if (flag & LDP_TUNNEL_CFG_ADMIN_STATE) {
2465     if (ldp_tunnel_is_active(tunnel) == MPLS_BOOL_TRUE) {
2466       if (t->admin_state == MPLS_ADMIN_DISABLE) {
2467         if (ldp_tunnel_shutdown(global, tunnel, 0) == MPLS_FAILURE) {
2468           goto ldp_cfg_tunnel_set_end;
2469         }
2470       }
2471     } else {
2472       if (t->admin_state == MPLS_ADMIN_ENABLE) {
2473         if (ldp_tunnel_is_ready(tunnel) == MPLS_BOOL_TRUE) {
2474           if (ldp_tunnel_startup(global, tunnel) == MPLS_FAILURE) {
2475             goto ldp_cfg_tunnel_set_end;
2476           }
2477         } else {
2478           LDP_PRINT(global->user_data,
2479
2480             "ldp_cfg_tunnel_set: tunnel not ready\n");
2481           goto ldp_cfg_tunnel_set_end;
2482         }
2483       }
2484     }
2485   }
2486   retval = MPLS_SUCCESS;
2487
2488 ldp_cfg_tunnel_set_end:
2489
2490   mpls_lock_release(global->global_lock); /* UNLOCK */
2491
2492   LDP_EXIT(global->user_data, "ldp_cfg_tunnel_set");
2493
2494   return retval;
2495 }
2496
2497 mpls_return_enum ldp_cfg_tunnel_test(mpls_cfg_handle handle, ldp_tunnel * t,
2498   uint32_t flag)
2499 {
2500   ldp_global *global = (ldp_global *) handle;
2501   mpls_return_enum retval = MPLS_FAILURE;
2502   ldp_tunnel *tunnel = NULL;
2503
2504   MPLS_ASSERT(global !=NULL);
2505
2506   LDP_ENTER(global->user_data, "ldp_cfg_tunnel_test");
2507
2508   mpls_lock_get(global->global_lock); /* LOCK */
2509
2510   if (flag & LDP_CFG_ADD) {
2511     retval = MPLS_SUCCESS;
2512     goto ldp_cfg_tunnel_test_end;
2513   }
2514
2515   ldp_global_find_tunnel_index(global, t->index, &tunnel);
2516
2517   if (!tunnel) {
2518     goto ldp_cfg_tunnel_test_end;
2519   }
2520
2521   if (flag & LDP_TUNNEL_CFG_RESOURCE_INDEX) {
2522     ldp_resource *resource = NULL;
2523
2524     if (t->resource_index) {
2525       ldp_global_find_resource_index(global, t->resource_index, &resource);
2526
2527       if (!resource) {
2528         goto ldp_cfg_tunnel_test_end;
2529       }
2530     }
2531   }
2532   if (flag & LDP_TUNNEL_CFG_HOP_LIST_INDEX) {
2533     ldp_hop_list *hop_list = NULL;
2534
2535     if (t->hop_list_index) {
2536       ldp_global_find_hop_list_index(global, t->hop_list_index, &hop_list);
2537
2538       if (!hop_list) {
2539         goto ldp_cfg_tunnel_test_end;
2540       }
2541     }
2542   }
2543   if (flag & LDP_TUNNEL_CFG_OUTLABEL) {
2544     ldp_outlabel *outlabel = NULL;
2545
2546     if (t->outlabel_index) {
2547       ldp_global_find_outlabel_index(global, t->outlabel_index, &outlabel);
2548
2549       if (!outlabel) {
2550         goto ldp_cfg_tunnel_test_end;
2551       }
2552     }
2553   }
2554   if ((flag & LDP_TUNNEL_CFG_ADMIN_STATE) &&
2555     (ldp_tunnel_is_active(tunnel) == MPLS_BOOL_FALSE) &&
2556     (t->admin_state == MPLS_ADMIN_ENABLE) && (ldp_tunnel_is_ready(tunnel) != MPLS_BOOL_TRUE)) {
2557     goto ldp_cfg_tunnel_test_end;
2558   }
2559   retval = MPLS_SUCCESS;
2560
2561 ldp_cfg_tunnel_test_end:
2562
2563   mpls_lock_release(global->global_lock); /* UNLOCK */
2564
2565   LDP_EXIT(global->user_data, "ldp_cfg_tunnel_test");
2566
2567   return retval;
2568 }
2569
2570 mpls_return_enum ldp_cfg_tunnel_get(mpls_cfg_handle handle, ldp_tunnel * t,
2571   uint32_t flag)
2572 {
2573   ldp_global *global = (ldp_global *) handle;
2574   mpls_return_enum retval = MPLS_FAILURE;
2575   ldp_tunnel *tunnel = NULL;
2576
2577   MPLS_ASSERT(global !=NULL);
2578
2579   LDP_ENTER(global->user_data, "ldp_cfg_tunnel_get");
2580
2581   mpls_lock_get(global->global_lock); /* LOCK */
2582
2583   ldp_global_find_tunnel_index(global, t->index, &tunnel);
2584
2585   if (!tunnel) {
2586     goto ldp_cfg_tunnel_get_end;
2587   }
2588   if (flag & LDP_TUNNEL_CFG_INGRESS) {
2589     memcpy(&t->ingress_lsrid, &tunnel->ingress_lsrid, sizeof(ldp_addr));
2590   }
2591   if (flag & LDP_TUNNEL_CFG_EGRESS) {
2592     memcpy(&t->egress_lsrid, &tunnel->egress_lsrid, sizeof(ldp_addr));
2593   }
2594   if (flag & LDP_TUNNEL_CFG_NAME) {
2595     memcpy(&t->name, &tunnel->name, MPLS_MAX_IF_NAME);
2596   }
2597   if (flag & LDP_TUNNEL_CFG_IS_IF) {
2598     t->is_interface = tunnel->is_interface;
2599   }
2600   if (flag & LDP_TUNNEL_CFG_OUTLABEL) {
2601     if (tunnel->outlabel) {
2602       t->outlabel_index = tunnel->outlabel->index;
2603     } else {
2604       t->outlabel_index = 0;
2605     }
2606   }
2607   if (flag & LDP_TUNNEL_CFG_SETUP_PRIO) {
2608     t->setup_prio = tunnel->setup_prio;
2609   }
2610   if (flag & LDP_TUNNEL_CFG_HOLD_PRIO) {
2611     t->hold_prio = tunnel->hold_prio;
2612   }
2613   if (flag & LDP_TUNNEL_CFG_INSTANCE_PRIO) {
2614     tunnel->instance_prio = t->instance_prio;
2615   }
2616   if (flag & LDP_TUNNEL_CFG_LOCAL_PROTECT) {
2617     tunnel->local_protect = t->local_protect;
2618   }
2619   if (flag & LDP_TUNNEL_CFG_RESOURCE_INDEX) {
2620     if (tunnel->resource) {
2621       t->resource_index = tunnel->resource->index;
2622     } else {
2623       t->resource_index = 0;
2624     }
2625   }
2626   if (flag & LDP_TUNNEL_CFG_HOP_LIST_INDEX) {
2627     if (tunnel->hop_list) {
2628       t->hop_list_index = tunnel->hop_list->index;
2629     } else {
2630       t->hop_list_index = 0;
2631     }
2632   }
2633   if (flag & LDP_TUNNEL_CFG_FEC) {
2634     memcpy(&t->fec, &tunnel->fec, sizeof(ldp_fec));
2635   }
2636   if (flag & LDP_TUNNEL_CFG_ADMIN_STATE) {
2637     t->admin_state = tunnel->admin_state;
2638   }
2639   retval = MPLS_SUCCESS;
2640
2641 ldp_cfg_tunnel_get_end:
2642
2643   mpls_lock_release(global->global_lock); /* UNLOCK */
2644
2645   LDP_EXIT(global->user_data, "ldp_cfg_tunnel_get");
2646
2647   return retval;
2648 }
2649
2650 mpls_return_enum ldp_cfg_tunnel_getnext(mpls_cfg_handle handle,
2651   ldp_tunnel * r, uint32_t flag)
2652 {
2653   ldp_global *g = (ldp_global *) handle;
2654   ldp_tunnel *tunnel = NULL;
2655   mpls_return_enum ret = MPLS_FAILURE;
2656   mpls_bool done = MPLS_BOOL_FALSE;
2657   int index;
2658
2659   LDP_ENTER(g->user_data, "ldp_cfg_tunnel_getnext");
2660
2661   if (r->index == 0) {
2662     index = 1;
2663   } else {
2664     index = r->index + 1;
2665   }
2666
2667   mpls_lock_get(g->global_lock); /* LOCK */
2668   while (done == MPLS_BOOL_FALSE) {
2669     switch ((ret = ldp_global_find_tunnel_index(g, index, &tunnel))) {
2670       case MPLS_SUCCESS:
2671       case MPLS_END_OF_LIST:
2672         done = MPLS_BOOL_TRUE;
2673         break;
2674       case MPLS_FAILURE:
2675         break;
2676       default:
2677         MPLS_ASSERT(0);
2678     }
2679     index++;
2680   }
2681   mpls_lock_release(g->global_lock); /* UNLOCK */
2682
2683   if (ret == MPLS_SUCCESS) {
2684     r->index = tunnel->index;
2685
2686     LDP_EXIT(g->user_data, "ldp_cfg_tunnel_getnext");
2687     return ldp_cfg_tunnel_get(g, r, flag);
2688   }
2689
2690   LDP_EXIT(g->user_data, "ldp_cfg_tunnel_getnext");
2691
2692   return ret;
2693 }
2694
2695 /******************* RESOURCE **********************/
2696
2697 mpls_return_enum ldp_cfg_resource_set(mpls_cfg_handle handle, ldp_resource * r,
2698   uint32_t flag)
2699 {
2700   ldp_global *global = (ldp_global *) handle;
2701   mpls_return_enum retval = MPLS_FAILURE;
2702   ldp_resource *resource = NULL;
2703
2704   MPLS_ASSERT(global !=NULL);
2705
2706   LDP_ENTER(global->user_data, "ldp_cfg_resource_set");
2707
2708   mpls_lock_get(global->global_lock); /* LOCK */
2709
2710   if (flag & LDP_CFG_ADD) {
2711     resource = ldp_resource_create();
2712     _ldp_global_add_resource(global, resource);
2713
2714     r->index = resource->index;
2715   } else {
2716     ldp_global_find_resource_index(global, r->index, &resource);
2717   }
2718
2719   if (!resource) {
2720     goto ldp_cfg_resource_set_end;
2721   }
2722
2723   if (flag & LDP_RESOURCE_CFG_MAXBPS) {
2724     resource->max_rate = r->max_rate;
2725   }
2726   if (flag & LDP_RESOURCE_CFG_MEANBPS) {
2727     resource->mean_rate = r->mean_rate;
2728   }
2729   if (flag & LDP_RESOURCE_CFG_BURSTSIZE) {
2730     resource->burst_size = r->burst_size;
2731   }
2732   retval = MPLS_SUCCESS;
2733
2734 ldp_cfg_resource_set_end:
2735
2736   mpls_lock_release(global->global_lock); /* UNLOCK */
2737
2738   LDP_EXIT(global->user_data, "ldp_cfg_resource_set");
2739
2740   return retval;
2741 }
2742
2743 mpls_return_enum ldp_cfg_resource_test(mpls_cfg_handle handle, ldp_resource * r,
2744   uint32_t flag)
2745 {
2746   ldp_global *global = (ldp_global *) handle;
2747   mpls_return_enum retval = MPLS_FAILURE;
2748   ldp_resource *resource = NULL;
2749
2750   MPLS_ASSERT(global !=NULL);
2751
2752   LDP_ENTER(global->user_data, "ldp_cfg_resource_test");
2753
2754   mpls_lock_get(global->global_lock); /* LOCK */
2755
2756   if (flag & LDP_CFG_ADD) {
2757     retval = MPLS_SUCCESS;
2758     goto ldp_cfg_resource_test_end;
2759   }
2760
2761   ldp_global_find_resource_index(global, r->index, &resource);
2762
2763   if (!resource) {
2764     goto ldp_cfg_resource_test_end;
2765   }
2766
2767   if (ldp_resource_in_use(resource) == MPLS_BOOL_TRUE) {
2768     goto ldp_cfg_resource_test_end;
2769   }
2770   retval = MPLS_SUCCESS;
2771
2772 ldp_cfg_resource_test_end:
2773
2774   mpls_lock_release(global->global_lock); /* UNLOCK */
2775
2776   LDP_EXIT(global->user_data, "ldp_cfg_resource_test");
2777
2778   return retval;
2779 }
2780
2781 mpls_return_enum ldp_cfg_resource_get(mpls_cfg_handle handle, ldp_resource * r,
2782   uint32_t flag)
2783 {
2784   ldp_global *global = (ldp_global *) handle;
2785   mpls_return_enum retval = MPLS_FAILURE;
2786   ldp_resource *resource = NULL;
2787
2788   MPLS_ASSERT(global !=NULL);
2789
2790   LDP_ENTER(global->user_data, "ldp_cfg_resource_get");
2791
2792   mpls_lock_get(global->global_lock); /* LOCK */
2793
2794   ldp_global_find_resource_index(global, r->index, &resource);
2795
2796   if (!resource) {
2797     goto ldp_cfg_resource_get_end;
2798   }
2799
2800   if (flag & LDP_RESOURCE_CFG_MAXBPS) {
2801     r->max_rate = resource->max_rate;
2802   }
2803   if (flag & LDP_RESOURCE_CFG_MEANBPS) {
2804     r->mean_rate = resource->mean_rate;
2805   }
2806   if (flag & LDP_RESOURCE_CFG_BURSTSIZE) {
2807     r->burst_size = resource->burst_size;
2808   }
2809   retval = MPLS_SUCCESS;
2810
2811 ldp_cfg_resource_get_end:
2812
2813   mpls_lock_release(global->global_lock); /* UNLOCK */
2814
2815   LDP_EXIT(global->user_data, "ldp_cfg_resource_get");
2816
2817   return retval;
2818 }
2819
2820 mpls_return_enum ldp_cfg_resource_getnext(mpls_cfg_handle handle,
2821   ldp_resource * r, uint32_t flag)
2822 {
2823   ldp_global *g = (ldp_global *) handle;
2824   ldp_resource *resource = NULL;
2825   mpls_return_enum ret = MPLS_FAILURE;
2826   mpls_bool done = MPLS_BOOL_FALSE;
2827   int index;
2828
2829   LDP_ENTER(g->user_data, "ldp_cfg_resource_getnext");
2830
2831   if (r->index == 0) {
2832     index = 1;
2833   } else {
2834     index = r->index + 1;
2835   }
2836
2837   mpls_lock_get(g->global_lock); /* LOCK */
2838   while (done == MPLS_BOOL_FALSE) {
2839     switch ((ret = ldp_global_find_resource_index(g, index, &resource))) {
2840       case MPLS_SUCCESS:
2841       case MPLS_END_OF_LIST:
2842         done = MPLS_BOOL_TRUE;
2843         break;
2844       case MPLS_FAILURE:
2845         break;
2846       default:
2847         MPLS_ASSERT(0);
2848     }
2849     index++;
2850   }
2851   mpls_lock_release(g->global_lock); /* UNLOCK */
2852
2853   if (ret == MPLS_SUCCESS) {
2854     r->index = resource->index;
2855
2856     LDP_EXIT(g->user_data, "ldp_cfg_resource_getnext");
2857     return ldp_cfg_resource_get(g, r, flag);
2858   }
2859
2860   LDP_EXIT(g->user_data, "ldp_cfg_resource_getnext");
2861
2862   return ret;
2863 }
2864
2865 /******************* HOP **********************/
2866
2867 mpls_return_enum ldp_cfg_hop_set(mpls_cfg_handle handle, ldp_hop * h,
2868   uint32_t flag)
2869 {
2870   ldp_global *global = (ldp_global *) handle;
2871   mpls_return_enum retval = MPLS_FAILURE;
2872   ldp_hop_list *hop_list = NULL;
2873   ldp_hop *hop = NULL;
2874
2875   MPLS_ASSERT(global !=NULL);
2876
2877   LDP_ENTER(global->user_data, "ldp_cfg_hop_set");
2878
2879   if (!h->hop_list_index && !h->index) {
2880     return retval;
2881   }
2882
2883   mpls_lock_get(global->global_lock); /* LOCK */
2884
2885   ldp_global_find_hop_list_index(global, h->hop_list_index, &hop_list);
2886
2887   if (!hop_list) {
2888     if (flag & LDP_CFG_ADD) {
2889       if (!(hop_list = ldp_hop_list_create())) {
2890         goto ldp_cfg_hop_set_end;
2891       }
2892       _ldp_global_add_hop_list(global, hop_list);
2893
2894       h->hop_list_index = hop_list->index;
2895     } else {
2896       goto ldp_cfg_hop_set_end;
2897     }
2898   }
2899
2900   ldp_hop_list_find_hop_index(hop_list, h->index, &hop);
2901   if (!hop) {
2902     if (h->index && (flag & LDP_CFG_ADD)) {
2903       if (!(hop = ldp_hop_create())) {
2904         goto ldp_cfg_hop_set_end;
2905       }
2906       hop->index = h->index;
2907       ldp_hop_list_add_hop(hop_list, hop);
2908     } else {
2909       goto ldp_cfg_hop_set_end;
2910     }
2911   }
2912
2913   if (flag & LDP_HOP_CFG_PATH_OPTION) {
2914     hop->path_option = h->path_option;
2915   }
2916   if (flag & LDP_HOP_CFG_ADDR) {
2917     memcpy(&hop->addr, &h->addr, sizeof(ldp_addr));
2918   }
2919   if (flag & LDP_HOP_CFG_TYPE) {
2920     hop->type = h->type;
2921   }
2922   retval = MPLS_SUCCESS;
2923
2924 ldp_cfg_hop_set_end:
2925
2926   mpls_lock_release(global->global_lock); /* UNLOCK */
2927
2928   LDP_EXIT(global->user_data, "ldp_cfg_hop_set");
2929
2930   return retval;
2931 }
2932
2933 mpls_return_enum ldp_cfg_hop_test(mpls_cfg_handle handle, ldp_hop * h,
2934   uint32_t flag)
2935 {
2936   ldp_global *global = (ldp_global *) handle;
2937   mpls_return_enum retval = MPLS_FAILURE;
2938   ldp_hop_list *hop_list = NULL;
2939   ldp_hop *hop = NULL;
2940
2941   MPLS_ASSERT(global !=NULL);
2942
2943   LDP_ENTER(global->user_data, "ldp_cfg_hop_test");
2944
2945   mpls_lock_get(global->global_lock); /* LOCK */
2946
2947   if (flag & LDP_CFG_ADD) {
2948     retval = MPLS_SUCCESS;
2949     goto ldp_cfg_hop_test_end;
2950   }
2951
2952   ldp_global_find_hop_list_index(global, h->hop_list_index, &hop_list);
2953
2954   if (!hop_list) {
2955     goto ldp_cfg_hop_test_end;
2956   }
2957
2958   ldp_hop_list_find_hop_index(hop_list, h->index, &hop);
2959   if (!hop) {
2960     goto ldp_cfg_hop_test_end;
2961   }
2962
2963   if (ldp_hop_in_use(hop) == MPLS_BOOL_TRUE) {
2964     goto ldp_cfg_hop_test_end;
2965   }
2966   retval = MPLS_SUCCESS;
2967
2968 ldp_cfg_hop_test_end:
2969
2970   mpls_lock_release(global->global_lock); /* UNLOCK */
2971
2972   LDP_EXIT(global->user_data, "ldp_cfg_hop_test");
2973
2974   return retval;
2975 }
2976
2977 mpls_return_enum ldp_cfg_hop_get(mpls_cfg_handle handle, ldp_hop * h,
2978   uint32_t flag)
2979 {
2980   ldp_global *global = (ldp_global *) handle;
2981   mpls_return_enum retval = MPLS_FAILURE;
2982   ldp_hop_list *hop_list = NULL;
2983   ldp_hop *hop = NULL;
2984
2985   MPLS_ASSERT(global !=NULL);
2986
2987   LDP_ENTER(global->user_data, "ldp_cfg_hop_get");
2988
2989   mpls_lock_get(global->global_lock); /* LOCK */
2990
2991   ldp_global_find_hop_list_index(global, h->hop_list_index, &hop_list);
2992
2993   if (!hop_list) {
2994     goto ldp_cfg_hop_get_end;
2995   }
2996
2997   ldp_hop_list_find_hop_index(hop_list, h->index, &hop);
2998   if (!hop) {
2999     goto ldp_cfg_hop_get_end;
3000   }
3001
3002   if (flag & LDP_HOP_CFG_PATH_OPTION) {
3003     h->path_option = hop->path_option;
3004   }
3005   if (flag & LDP_HOP_CFG_ADDR) {
3006     memcpy(&h->addr, &hop->addr, sizeof(ldp_addr));
3007   }
3008   if (flag & LDP_HOP_CFG_TYPE) {
3009     h->type = hop->type;
3010   }
3011   retval = MPLS_SUCCESS;
3012
3013 ldp_cfg_hop_get_end:
3014
3015   mpls_lock_release(global->global_lock); /* UNLOCK */
3016
3017   LDP_EXIT(global->user_data, "ldp_cfg_hop_get");
3018
3019   return retval;
3020 }
3021
3022 /******************* NEXTHOP **********************/
3023 mpls_return_enum ldp_cfg_nexthop_get(mpls_cfg_handle handle, ldp_nexthop * n,
3024   uint32_t flag)
3025 {
3026   ldp_global *global = (ldp_global *) handle;
3027   ldp_nexthop *nexthop = NULL;
3028   mpls_return_enum retval = MPLS_FAILURE;
3029
3030   MPLS_ASSERT(global !=NULL && n != NULL);
3031
3032   LDP_ENTER(global->user_data, "ldp_cfg_nexthop_get");
3033
3034   mpls_lock_get(global->global_lock); /* LOCK */
3035
3036   if (ldp_global_find_nexthop_index(global, n->index, &nexthop) != MPLS_SUCCESS)
3037       goto ldp_cfg_nexthop_get_end;
3038
3039   if (nexthop->fec)
3040     n->fec_index  = nexthop->fec->index;
3041   if (nexthop->addr)
3042     n->addr_index = nexthop->addr->index;
3043   if (nexthop->outlabel)
3044     n->outlabel_index = nexthop->outlabel->index;
3045   if (nexthop->iff)
3046     n->if_index = nexthop->iff->index;
3047
3048   memcpy (&n->info, &nexthop->info, sizeof(nexthop->info));
3049
3050   retval = MPLS_SUCCESS;
3051
3052 ldp_cfg_nexthop_get_end:
3053   mpls_lock_release(global->global_lock); /* UNLOCK */
3054
3055   LDP_EXIT(global->user_data, "ldp_cfg_nexthop_get");
3056
3057   return retval;
3058 }
3059
3060 mpls_return_enum ldp_cfg_nexthop_getnext(mpls_cfg_handle handle, ldp_nexthop * n,
3061   uint32_t flag)
3062 {
3063   ldp_global *g = (ldp_global *) handle;
3064   ldp_nexthop *ses = NULL;
3065   mpls_return_enum r = MPLS_FAILURE;
3066   mpls_bool done = MPLS_BOOL_FALSE;
3067   int index;
3068
3069   LDP_ENTER(g->user_data, "ldp_cfg_nexthop_getnext");
3070
3071   if (n->index == 0) {
3072     index = 1;
3073   } else {
3074     index = n->index + 1;
3075   }
3076
3077   mpls_lock_get(g->global_lock); /* LOCK */
3078   while (done == MPLS_BOOL_FALSE) {
3079     switch ((r = ldp_global_find_nexthop_index(g, index, &ses))) {
3080       case MPLS_SUCCESS:
3081       case MPLS_END_OF_LIST:
3082         done = MPLS_BOOL_TRUE;
3083         break;
3084       case MPLS_FAILURE:
3085         break;
3086       default:
3087         MPLS_ASSERT(0);
3088     }
3089     index++;
3090   }
3091   mpls_lock_release(g->global_lock); /* UNLOCK */
3092
3093   if (r == MPLS_SUCCESS) {
3094     n->index = ses->index;
3095
3096     LDP_EXIT(g->user_data, "ldp_cfg_nexthop_getnext");
3097     return ldp_cfg_nexthop_get(g, n, flag);
3098   }
3099
3100   LDP_EXIT(g->user_data, "ldp_cfg_nexthop_getnext");
3101
3102   return r;
3103 }