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