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