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