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(global, 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(global, 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(global)) == 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   } else {
 853     ldp_global_find_if_index(global, i->index, &iff);
 854   }
 855
 856   if ((iff == NULL) ||
 857     ((ldp_if_is_active(iff) == MPLS_BOOL_TRUE) &&
 858 (flag & LDP_IF_CFG_WHEN_DOWN))) goto ldp_cfg_if_set_end;
 859
 860   if (flag & LDP_CFG_DEL) {
 861     if (iff->entity != NULL) {
 862       goto ldp_cfg_if_set_end;
 863     }
 864
 865     iff->used_by_ldp = MPLS_BOOL_FALSE;
 866     MPLS_REFCNT_RELEASE2(global, iff, ldp_if_delete);
 867
 868     retval = MPLS_SUCCESS;
 869     goto ldp_cfg_if_set_end;
 870   }
 871   if (flag & LDP_IF_CFG_INDEX) {
 872     iff->index = i->index;
 873   }
 874   if (flag & LDP_IF_CFG_LABEL_SPACE) {
 875     iff->label_space = i->label_space;
 876   }
 877   global->configuration_sequence_number++;
 878
 879   retval = MPLS_SUCCESS;
 880
 881 ldp_cfg_if_set_end:
 882   mpls_lock_release(global->global_lock); /* UNLOCK */
 883
 884   LDP_EXIT(global->user_data, "ldp_cfg_if_set");
 885
 886   return retval;
 887 }
 888
 889 /******************* ATTR **********************/
 890
 891 mpls_return_enum ldp_cfg_attr_get(mpls_cfg_handle handle, ldp_attr * a,
 892   uint32_t flag)
 893 {
 894   ldp_global *global = (ldp_global *) handle;
 895   ldp_attr *attr = NULL;
 896   mpls_return_enum retval = MPLS_FAILURE;
 897
 898   MPLS_ASSERT(global !=NULL && a != NULL);
 899
 900   LDP_ENTER(global->user_data, "ldp_cfg_attr_get");
 901
 902   mpls_lock_get(global->global_lock); /* LOCK */
 903
 904   if (ldp_global_find_attr_index(global, a->index, &attr) != MPLS_SUCCESS)
 905       goto ldp_cfg_attr_get_end;
 906
 907   if (flag & LDP_ATTR_CFG_STATE) {
 908     a->state = attr->state;
 909   }
 910   if (flag & LDP_ATTR_CFG_FEC) {
 911     ldp_attr2ldp_attr(attr, a, LDP_ATTR_FEC);
 912   }
 913   if (flag & LDP_ATTR_CFG_LABEL) {
 914     ldp_attr2ldp_attr(attr, a, LDP_ATTR_LABEL);
 915   }
 916   if (flag & LDP_ATTR_CFG_HOP_COUNT) {
 917     ldp_attr2ldp_attr(attr, a, LDP_ATTR_HOPCOUNT);
 918   }
 919   if (flag & LDP_ATTR_CFG_PATH) {
 920     ldp_attr2ldp_attr(attr, a, LDP_ATTR_PATH);
 921   }
 922   if (flag & LDP_ATTR_CFG_SESSION_INDEX) {
 923     a->session_index = (attr->session) ? (attr->session->index) : 0;
 924   }
 925   if (flag & LDP_ATTR_CFG_INLABEL_INDEX) {
 926     a->inlabel_index = (attr->inlabel) ? (attr->inlabel->index) : 0;
 927   }
 928   if (flag & LDP_ATTR_CFG_OUTLABEL_INDEX) {
 929     a->outlabel_index = (attr->outlabel) ? (attr->outlabel->index) : 0;
 930   }
 931   if (flag & LDP_ATTR_CFG_INGRESS) {
 932     a->ingress = attr->ingress;
 933   }
 934   retval = MPLS_SUCCESS;
 935
 936 ldp_cfg_attr_get_end:
 937   mpls_lock_release(global->global_lock); /* UNLOCK */
 938
 939   LDP_EXIT(global->user_data, "ldp_cfg_attr_get");
 940
 941   return retval;
 942 }
 943
 944 mpls_return_enum ldp_cfg_attr_getnext(mpls_cfg_handle handle, ldp_attr * a,
 945   uint32_t flag)
 946 {
 947   ldp_global *g = (ldp_global *) handle;
 948   ldp_attr *attr = NULL;
 949   mpls_return_enum r = MPLS_FAILURE;
 950   mpls_bool done = MPLS_BOOL_FALSE;
 951   int index;
 952
 953   LDP_ENTER(g->user_data, "ldp_cfg_attr_getnext");
 954
 955   if (a->index == 0) {
 956     index = 1;
 957   } else {
 958     index = a->index + 1;
 959   }
 960
 961   mpls_lock_get(g->global_lock); /* LOCK */
 962   while (done == MPLS_BOOL_FALSE) {
 963     switch ((r = ldp_global_find_attr_index(g, index, &attr))) {
 964       case MPLS_SUCCESS:
 965       case MPLS_END_OF_LIST:
 966         done = MPLS_BOOL_TRUE;
 967         break;
 968       case MPLS_FAILURE:
 969         break;
 970       default:
 971         MPLS_ASSERT(0);
 972     }
 973     index++;
 974   }
 975   mpls_lock_release(g->global_lock); /* UNLOCK */
 976
 977   if (r == MPLS_SUCCESS) {
 978     a->index = attr->index;
 979     LDP_EXIT(g->user_data, "ldp_cfg_attr_getnext");
 980     return ldp_cfg_attr_get(g, a, flag);
 981   }
 982   LDP_EXIT(g->user_data, "ldp_cfg_attr_getnext");
 983   return r;
 984 }
 985
 986 /******************* PEER **********************/
 987
 988 mpls_return_enum ldp_cfg_peer_get(mpls_cfg_handle handle, ldp_peer * p,
 989   uint32_t flag)
 990 {
 991   ldp_global *global = (ldp_global *) handle;
 992   ldp_peer *peer = NULL;
 993   mpls_return_enum retval = MPLS_FAILURE;
 994
 995   MPLS_ASSERT(global !=NULL && p != NULL);
 996
 997   LDP_ENTER(global->user_data, "ldp_cfg_peer_get");
 998
 999   mpls_lock_get(global->global_lock); /* LOCK */
1000
1001   if (ldp_global_find_peer_index(global, p->index, &peer) != MPLS_SUCCESS)
1002       goto ldp_cfg_peer_get_end;
1003
1004   if (flag & LDP_PEER_CFG_LABEL_SPACE) {
1005     p->label_space = peer->label_space;
1006   }
1007   if (flag & LDP_PEER_CFG_TARGET_ROLE) {
1008     p->target_role = peer->target_role;
1009   }
1010   if (flag & LDP_PEER_CFG_DEST_ADDR) {
1011     memcpy(&p->dest.addr, &peer->dest.addr, sizeof(mpls_inet_addr));
1012   }
1013   if (flag & LDP_PEER_CFG_ENTITY_INDEX) {
1014     p->entity_index = peer->entity->index;
1015   }
1016   if (flag & LDP_PEER_CFG_OPER_STATE) {
1017     p->oper_state = peer->oper_state;
1018   }
1019   if (flag & LDP_PEER_CFG_PEER_NAME) {
1020     strncpy(p->peer_name, peer->peer_name, MPLS_MAX_IF_NAME);
1021   }
1022   if (flag & LDP_PEER_CFG_LOCAL_SOURCE_ADDR) {
1023     memcpy(&p->local_source_address, &peer->local_source_address,
1024       sizeof(mpls_inet_addr));
1025   }
1026   retval = MPLS_SUCCESS;
1027
1028 ldp_cfg_peer_get_end:
1029   mpls_lock_release(global->global_lock); /* UNLOCK */
1030
1031   LDP_EXIT(global->user_data, "ldp_cfg_peer_get");
1032
1033   return retval;
1034 }
1035
1036 mpls_return_enum ldp_cfg_peer_getnext(mpls_cfg_handle handle, ldp_peer * p,
1037   uint32_t flag)
1038 {
1039   ldp_global *g = (ldp_global *) handle;
1040   ldp_peer *peer = NULL;
1041   mpls_return_enum r = MPLS_FAILURE;
1042   mpls_bool done = MPLS_BOOL_FALSE;
1043   int index;
1044
1045   LDP_ENTER(g->user_data, "ldp_cfg_peer_getnext");
1046
1047   if (p->index == 0) {
1048     index = 1;
1049   } else {
1050     index = p->index + 1;
1051   }
1052
1053   mpls_lock_get(g->global_lock); /* LOCK */
1054   while (done == MPLS_BOOL_FALSE) {
1055     switch ((r = ldp_global_find_peer_index(g, index, &peer))) {
1056       case MPLS_SUCCESS:
1057       case MPLS_END_OF_LIST:
1058         done = MPLS_BOOL_TRUE;
1059         break;
1060       case MPLS_FAILURE:
1061         break;
1062       default:
1063         MPLS_ASSERT(0);
1064     }
1065     index++;
1066   }
1067   mpls_lock_release(g->global_lock); /* UNLOCK */
1068
1069   if (r == MPLS_SUCCESS) {
1070     p->index = peer->index;
1071     LDP_EXIT(g->user_data, "ldp_cfg_peer_getnext");
1072     return ldp_cfg_peer_get(g, p, flag);
1073   }
1074   LDP_EXIT(g->user_data, "ldp_cfg_peer_getnext");
1075   return r;
1076 }
1077
1078 mpls_return_enum ldp_cfg_peer_test(mpls_cfg_handle handle, ldp_peer * p,
1079   uint32_t flag)
1080 {
1081   // ldp_global* g = (ldp_global*)handle;
1082   return MPLS_SUCCESS;
1083 }
1084
1085 mpls_return_enum ldp_cfg_peer_set(mpls_cfg_handle handle, ldp_peer * p,
1086   uint32_t flag)
1087 {
1088   ldp_global *global = (ldp_global *) handle;
1089   ldp_peer *peer = NULL;
1090   mpls_return_enum retval = MPLS_FAILURE;
1091
1092   MPLS_ASSERT(global !=NULL && p != NULL);
1093
1094   LDP_ENTER(global->user_data, "ldp_cfg_peer_set");
1095
1096   mpls_lock_get(global->global_lock); /* LOCK */
1097
1098   if (flag & LDP_CFG_ADD) {
1099     if ((peer = ldp_peer_create()) == NULL) {
1100       goto ldp_cfg_peer_set_end;
1101     }
1102     p->index = peer->index;
1103     _ldp_global_add_peer(global, peer);
1104   } else {
1105     ldp_global_find_peer_index(global, p->index, &peer);
1106   }
1107
1108   if (peer == NULL) {
1109     LDP_PRINT(global->user_data, "ldp_cfg_peer_set: no such peer\n");
1110
1111     goto ldp_cfg_peer_set_end;
1112   }
1113   if ((ldp_peer_is_active(peer) == MPLS_BOOL_TRUE) && (flag & LDP_PEER_CFG_WHEN_DOWN)) {
1114     LDP_PRINT(global->user_data, "ldp_cfg_peer_set: peer is activer\n");
1115
1116     goto ldp_cfg_peer_set_end;
1117   }
1118
1119   if (flag & LDP_CFG_DEL) {
1120     if (peer->entity != NULL) {
1121       LDP_PRINT(global->user_data,
1122         "ldp_cfg_peer_set: not cleanup correctly is activer\n");
1123
1124       goto ldp_cfg_peer_set_end;
1125     }
1126
1127     _ldp_global_del_peer(global, peer);
1128
1129     retval = MPLS_SUCCESS;
1130     goto ldp_cfg_peer_set_end;
1131   }
1132   if (flag & LDP_PEER_CFG_LABEL_SPACE) {
1133     peer->label_space = p->label_space;
1134   }
1135   if (flag & LDP_PEER_CFG_TARGET_ROLE) {
1136     peer->target_role = p->target_role;
1137   }
1138   if (flag & LDP_PEER_CFG_DEST_ADDR) {
1139     memcpy(&peer->dest.addr, &p->dest.addr, sizeof(mpls_inet_addr));
1140   }
1141   if (flag & LDP_PEER_CFG_PEER_NAME) {
1142     LDP_PRINT(global->user_data, "ldp_cfg_peer_set: peer_name = %s\n",
1143
1144       p->peer_name);
1145     strncpy(peer->peer_name, p->peer_name, MPLS_MAX_IF_NAME);
1146   }
1147   global->configuration_sequence_number++;
1148
1149   retval = MPLS_SUCCESS;
1150
1151 ldp_cfg_peer_set_end:
1152   mpls_lock_release(global->global_lock); /* UNLOCK */
1153
1154   LDP_EXIT(global->user_data, "ldp_cfg_peer_set");
1155
1156   return retval;
1157 }
1158 /******************* FEC **********************/
1159
1160 mpls_return_enum ldp_cfg_fec_get(mpls_cfg_handle handle, mpls_fec * f,
1161   uint32_t flag)
1162 {
1163   ldp_global *global = (ldp_global *) handle;
1164   ldp_fec *fec = NULL;
1165   mpls_return_enum retval = MPLS_FAILURE;
1166
1167   MPLS_ASSERT(global !=NULL && f != NULL);
1168
1169   LDP_ENTER(global->user_data, "ldp_cfg_fec_get");
1170
1171   mpls_lock_get(global->global_lock); /* LOCK */
1172
1173   if (flag & LDP_FEC_CFG_BY_INDEX) {
1174     ldp_global_find_fec_index(global, f->index, &fec);
1175   } else {
1176     fec = ldp_fec_find(global, f);
1177   }
1178   if (!fec)
1179       goto ldp_cfg_fec_get_end;
1180
1181   memcpy(f, &fec->info, sizeof(mpls_fec));
1182   retval = MPLS_SUCCESS;
1183
1184 ldp_cfg_fec_get_end:
1185   mpls_lock_release(global->global_lock); /* UNLOCK */
1186
1187   LDP_EXIT(global->user_data, "ldp_cfg_fec_get");
1188
1189   return retval;
1190 }
1191
1192 mpls_return_enum ldp_cfg_fec_getnext(mpls_cfg_handle handle, mpls_fec * f,
1193   uint32_t flag)
1194 {
1195   ldp_global *g = (ldp_global *) handle;
1196   ldp_fec *fec = NULL;
1197   mpls_return_enum r = MPLS_FAILURE;
1198   mpls_bool done = MPLS_BOOL_FALSE;
1199   int index;
1200
1201   LDP_ENTER(g->user_data, "ldp_cfg_fec_getnext");
1202
1203   if (f->index == 0) {
1204     index = 1;
1205   } else {
1206     index = f->index + 1;
1207   }
1208
1209   mpls_lock_get(g->global_lock); /* LOCK */
1210   while (done == MPLS_BOOL_FALSE) {
1211     switch ((r = ldp_global_find_fec_index(g, index, &fec))) {
1212       case MPLS_SUCCESS:
1213       case MPLS_END_OF_LIST:
1214         done = MPLS_BOOL_TRUE;
1215         break;
1216       case MPLS_FAILURE:
1217         break;
1218       default:
1219         MPLS_ASSERT(0);
1220     }
1221     index++;
1222   }
1223   mpls_lock_release(g->global_lock); /* UNLOCK */
1224
1225   if (r == MPLS_SUCCESS) {
1226     f->index = fec->index;
1227     LDP_EXIT(g->user_data, "ldp_cfg_fec_getnext");
1228     return ldp_cfg_fec_get(g, f, flag);
1229   }
1230   LDP_EXIT(g->user_data, "ldp_cfg_fec_getnext");
1231   return r;
1232 }
1233
1234 mpls_return_enum ldp_cfg_fec_test(mpls_cfg_handle handle, mpls_fec * f,
1235   uint32_t flag)
1236 {
1237   // ldp_global* g = (ldp_global*)handle;
1238   return MPLS_SUCCESS;
1239 }
1240
1241 mpls_return_enum ldp_cfg_fec_set(mpls_cfg_handle handle, mpls_fec * f,
1242   uint32_t flag)
1243 {
1244   ldp_global *global = (ldp_global *) handle;
1245   ldp_fec *fec = NULL;
1246   mpls_return_enum retval = MPLS_FAILURE;
1247
1248   MPLS_ASSERT(global !=NULL && f != NULL);
1249
1250   LDP_ENTER(global->user_data, "ldp_cfg_fec_set");
1251
1252   mpls_lock_get(global->global_lock); /* LOCK */
1253
1254   if (flag & LDP_CFG_ADD) {
1255     if (ldp_fec_find(global, f) || (fec = ldp_fec_create()) == NULL) {
1256       goto ldp_cfg_fec_set_end;
1257     }
1258     f->index = fec->index;
1259     mpls_fec2ldp_fec(f, fec);
1260     _ldp_global_add_fec(global, fec);
1261     ldp_fec_insert2(global, fec);
1262   } else {
1263     if (flag & LDP_FEC_CFG_BY_INDEX) {
1264       ldp_global_find_fec_index(global, f->index, &fec);
1265     } else {
1266       fec = ldp_fec_find(global, f);
1267     }
1268   }
1269
1270   if (fec == NULL) {
1271     LDP_PRINT(global->user_data, "ldp_cfg_fec_set: no such fec\n");
1272     goto ldp_cfg_fec_set_end;
1273   }
1274
1275   if (flag & LDP_CFG_DEL) {
1276     ldp_fec_remove(global,&fec->info);
1277     _ldp_global_del_fec(global, fec);
1278   }
1279
1280   retval = MPLS_SUCCESS;
1281
1282 ldp_cfg_fec_set_end:
1283   mpls_lock_release(global->global_lock); /* UNLOCK */
1284
1285   LDP_EXIT(global->user_data, "ldp_cfg_fec_set");
1286
1287   return retval;
1288 }
1289
1290 mpls_return_enum ldp_cfg_fec_nexthop_get(mpls_cfg_handle handle, mpls_fec * f,
1291   mpls_nexthop *n, uint32_t flag)
1292 {
1293   ldp_global *global = (ldp_global *) handle;
1294   ldp_fec *fec = NULL;
1295   ldp_nexthop *nh = NULL;
1296   mpls_return_enum retval = MPLS_FAILURE;
1297
1298   MPLS_ASSERT(global !=NULL && f != NULL);
1299
1300   LDP_ENTER(global->user_data, "ldp_cfg_fec_nexthop_get");
1301
1302   mpls_lock_get(global->global_lock); /* LOCK */
1303
1304   if (flag & LDP_FEC_CFG_BY_INDEX) {
1305     ldp_global_find_fec_index(global, f->index, &fec);
1306   } else {
1307     fec = ldp_fec_find(global, f);
1308   }
1309   if (!fec)
1310       goto ldp_cfg_fec_nexthop_get_end;
1311
1312   if (flag & LDP_FEC_NEXTHOP_CFG_BY_INDEX) {
1313     ldp_fec_find_nexthop_index(fec, n->index, &nh);
1314   } else {
1315     nh = ldp_fec_nexthop_find(fec, n);
1316   }
1317   if (!nh)
1318     goto ldp_cfg_fec_nexthop_get_end;
1319
1320   memcpy(n, nh, sizeof(mpls_nexthop));
1321   retval = MPLS_SUCCESS;
1322
1323 ldp_cfg_fec_nexthop_get_end:
1324   mpls_lock_release(global->global_lock); /* UNLOCK */
1325
1326   LDP_EXIT(global->user_data, "ldp_cfg_fec_nexthop_get");
1327
1328   return retval;
1329 }
1330
1331 mpls_return_enum ldp_cfg_fec_nexthop_getnext(mpls_cfg_handle handle,
1332   mpls_fec * f, mpls_nexthop *n, uint32_t flag)
1333 {
1334   ldp_global *global = (ldp_global *) handle;
1335   ldp_fec *fec = NULL;
1336   ldp_nexthop *nh = NULL;
1337   mpls_return_enum r = MPLS_FAILURE;
1338   mpls_bool done = MPLS_BOOL_FALSE;
1339   int index;
1340
1341   LDP_ENTER(global->user_data, "ldp_cfg_fec_nexthop_getnext");
1342
1343   if (n->index == 0) {
1344     index = 1;
1345   } else {
1346     index = n->index + 1;
1347   }
1348
1349   mpls_lock_get(global->global_lock); /* LOCK */
1350
1351   if (flag & LDP_FEC_CFG_BY_INDEX) {
1352     ldp_global_find_fec_index(global, f->index, &fec);
1353   } else {
1354     fec = ldp_fec_find(global, f);
1355   }
1356   if (!fec)
1357       goto ldp_cfg_fec_nexthop_getnext_end;
1358
1359   while (done == MPLS_BOOL_FALSE) {
1360     switch ((r = ldp_fec_find_nexthop_index(fec, index, &nh))) {
1361       case MPLS_SUCCESS:
1362       case MPLS_END_OF_LIST:
1363         done = MPLS_BOOL_TRUE;
1364         break;
1365       case MPLS_FAILURE:
1366         break;
1367       default:
1368         MPLS_ASSERT(0);
1369     }
1370     index++;
1371   }
1372   mpls_lock_release(global->global_lock); /* UNLOCK */
1373
1374   if (r == MPLS_SUCCESS) {
1375     n->index = nh->index;
1376     LDP_EXIT(global->user_data, "ldp_cfg_fec_getnext");
1377     return ldp_cfg_fec_nexthop_get(global, f, n,
1378       flag & ~LDP_FEC_NEXTHOP_CFG_BY_INDEX);
1379   }
1380
1381 ldp_cfg_fec_nexthop_getnext_end:
1382
1383   LDP_EXIT(global->user_data, "ldp_cfg_fec_getnext");
1384   return r;
1385 }
1386
1387 mpls_return_enum ldp_cfg_fec_nexthop_test(mpls_cfg_handle handle, mpls_fec * f,
1388   mpls_nexthop *n, uint32_t flag)
1389 {
1390   // ldp_global* g = (ldp_global*)handle;
1391   return MPLS_SUCCESS;
1392 }
1393
1394 mpls_return_enum ldp_cfg_fec_nexthop_set(mpls_cfg_handle handle, mpls_fec * f,
1395   mpls_nexthop *n, uint32_t flag)
1396 {
1397   ldp_global *global = (ldp_global *) handle;
1398   ldp_fec *fec = NULL;
1399   ldp_nexthop *nh = NULL;
1400   mpls_return_enum retval = MPLS_FAILURE;
1401
1402   MPLS_ASSERT(global !=NULL && f != NULL && n != NULL);
1403
1404   LDP_ENTER(global->user_data, "ldp_cfg_fec_nexthop_set");
1405
1406   mpls_lock_get(global->global_lock); /* LOCK */
1407
1408   if (flag & LDP_FEC_CFG_BY_INDEX) {
1409     ldp_global_find_fec_index(global, f->index, &fec);
1410   } else {
1411     fec = ldp_fec_find(global, f);
1412   }
1413   if (!fec)
1414       goto ldp_cfg_fec_nexthop_set_end;
1415
1416   if (flag & LDP_CFG_ADD) {
1417     if (ldp_fec_nexthop_find(fec, n) || (nh = ldp_nexthop_create()) == NULL) {
1418       goto ldp_cfg_fec_nexthop_set_end;
1419     }
1420     n->index = nh->index;
1421     mpls_nexthop2ldp_nexthop(n, nh);
1422     _ldp_global_add_nexthop(global, nh);
1423     ldp_fec_add_nexthop(global, fec, nh);
1424   } else {
1425     if (flag & LDP_FEC_NEXTHOP_CFG_BY_INDEX) {
1426       ldp_fec_find_nexthop_index(fec, n->index, &nh);
1427     } else {
1428       nh = ldp_fec_nexthop_find(fec, n);
1429     }
1430   }
1431
1432   if (nh == NULL) {
1433     LDP_PRINT(global->user_data, "ldp_cfg_fec_nexthop_set: no such nh\n");
1434     goto ldp_cfg_fec_nexthop_set_end;
1435   }
1436
1437   if (flag & LDP_CFG_DEL) {
1438     ldp_fec_del_nexthop(global, fec,nh);
1439     _ldp_global_del_nexthop(global, nh);
1440   }
1441
1442   retval = MPLS_SUCCESS;
1443
1444 ldp_cfg_fec_nexthop_set_end:
1445   mpls_lock_release(global->global_lock); /* UNLOCK */
1446
1447   LDP_EXIT(global->user_data, "ldp_cfg_fec_nexthop_set");
1448
1449   return retval;
1450 }
1451
1452 /******************* ADJACENCY **********************/
1453
1454 mpls_return_enum ldp_cfg_adj_get(mpls_cfg_handle handle, ldp_adj * a,
1455   uint32_t flag)
1456 {
1457   ldp_global *global = (ldp_global *) handle;
1458   ldp_adj *adj = NULL;
1459   mpls_return_enum retval = MPLS_FAILURE;
1460
1461   MPLS_ASSERT(global !=NULL && a != NULL);
1462
1463   LDP_ENTER(global->user_data, "ldp_cfg_adj_get");
1464
1465   mpls_lock_get(global->global_lock); /* LOCK */
1466
1467   if (ldp_global_find_adj_index(global, a->index, &adj) != MPLS_SUCCESS)
1468       goto ldp_cfg_adj_get_end;
1469
1470   if (flag & LDP_ADJ_CFG_REMOTE_TRADDR) {
1471     memcpy(&a->remote_transport_address, &adj->remote_transport_address,
1472       sizeof(mpls_inet_addr));
1473   }
1474   if (flag & LDP_ADJ_CFG_REMOTE_SRCADDR) {
1475     memcpy(&a->remote_source_address, &adj->remote_source_address,
1476       sizeof(mpls_inet_addr));
1477   }
1478   if (flag & LDP_ADJ_CFG_REMOTE_LSRADDR) {
1479     memcpy(&a->remote_lsr_address, &adj->remote_lsr_address,
1480       sizeof(mpls_inet_addr));
1481   }
1482   if (flag & LDP_ADJ_CFG_REMOTE_CSN) {
1483     a->remote_csn = adj->remote_csn;
1484   }
1485   if (flag & LDP_ADJ_CFG_REMOTE_LABELSPACE) {
1486     a->remote_label_space = adj->remote_label_space;
1487   }
1488   if (flag & LDP_ADJ_CFG_REMOTE_HELLOTIME) {
1489     a->remote_hellotime = adj->remote_hellotime;
1490   }
1491   if (flag & LDP_ADJ_CFG_ENTITY_INDEX) {
1492     a->entity_index = adj->entity ? adj->entity->index : 0;
1493   }
1494   if (flag & LDP_ADJ_CFG_REMOTE_SESSION_INDEX) {
1495     a->session_index = (adj->session) ? (adj->session->index) : 0;
1496   }
1497   if (flag & LDP_ADJ_CFG_ROLE) {
1498     a->role = adj->role;
1499   }
1500   retval = MPLS_SUCCESS;
1501
1502 ldp_cfg_adj_get_end:
1503
1504   mpls_lock_release(global->global_lock); /* UNLOCK */
1505
1506   LDP_EXIT(global->user_data, "ldp_cfg_adj_get");
1507
1508   return retval;
1509 }
1510
1511 mpls_return_enum ldp_cfg_adj_getnext(mpls_cfg_handle handle, ldp_adj * a,
1512   uint32_t flag)
1513 {
1514   ldp_global *g = (ldp_global *) handle;
1515   ldp_adj *adj = NULL;
1516   mpls_return_enum r = MPLS_FAILURE;
1517   mpls_bool done = MPLS_BOOL_FALSE;
1518   int index;
1519
1520   LDP_ENTER(g->user_data, "ldp_cfg_adj_getnext");
1521
1522   if (a->index == 0) {
1523     index = 1;
1524   } else {
1525     index = a->index + 1;
1526   }
1527
1528   mpls_lock_get(g->global_lock); /* LOCK */
1529   while (done == MPLS_BOOL_FALSE) {
1530     switch ((r = ldp_global_find_adj_index(g, index, &adj))) {
1531       case MPLS_SUCCESS:
1532       case MPLS_END_OF_LIST:
1533         done = MPLS_BOOL_TRUE;
1534         break;
1535       case MPLS_FAILURE:
1536         break;
1537       default:
1538         MPLS_ASSERT(0);
1539     }
1540     index++;
1541   }
1542   mpls_lock_release(g->global_lock); /* UNLOCK */
1543
1544   if (r == MPLS_SUCCESS) {
1545     a->index = adj->index;
1546     LDP_EXIT(g->user_data, "ldp_cfg_adj_getnext");
1547     return ldp_cfg_adj_get(g, a, flag);
1548   }
1549   LDP_EXIT(g->user_data, "ldp_cfg_adj_getnext");
1550   return r;
1551 }
1552
1553 /******************* SESSION **********************/
1554
1555 mpls_return_enum ldp_cfg_session_get(mpls_cfg_handle handle, ldp_session * s,
1556   uint32_t flag)
1557 {
1558   ldp_global *global = (ldp_global *) handle;
1559   ldp_session *session = NULL;
1560   mpls_return_enum retval = MPLS_FAILURE;
1561
1562   MPLS_ASSERT(global !=NULL && s != NULL);
1563
1564   LDP_ENTER(global->user_data, "ldp_cfg_session_get");
1565
1566   mpls_lock_get(global->global_lock); /* LOCK */
1567
1568   if (ldp_global_find_session_index(global, s->index, &session) != MPLS_SUCCESS)
1569       goto ldp_cfg_session_get_end;
1570
1571   if (flag & LDP_SESSION_CFG_STATE) {
1572     s->state = session->state;
1573   }
1574   if (flag & LDP_SESSION_CFG_OPER_UP) {
1575     s->oper_up = session->oper_up;
1576   }
1577   if (flag & LDP_SESSION_CFG_MAX_PDU) {
1578     s->oper_max_pdu = session->oper_max_pdu;
1579   }
1580   if (flag & LDP_SESSION_CFG_KEEPALIVE) {
1581     s->oper_keepalive = session->oper_keepalive;
1582   }
1583   if (flag & LDP_SESSION_CFG_PATH_LIMIT) {
1584     s->oper_path_vector_limit = session->oper_path_vector_limit;
1585   }
1586   if (flag & LDP_SESSION_CFG_DIST_MODE) {
1587     s->oper_distribution_mode = session->oper_distribution_mode;
1588   }
1589   if (flag & LDP_SESSION_CFG_LOOP_DETECTION) {
1590     s->oper_loop_detection = session->oper_loop_detection;
1591   }
1592   if (flag & LDP_SESSION_CFG_REMOTE_MAX_PDU) {
1593     s->remote_max_pdu = session->remote_max_pdu;
1594   }
1595   if (flag & LDP_SESSION_CFG_REMOTE_KEEPALIVE) {
1596     s->remote_keepalive = session->remote_keepalive;
1597   }
1598   if (flag & LDP_SESSION_CFG_REMOTE_PATH_LIMIT) {
1599     s->remote_path_vector_limit = session->remote_path_vector_limit;
1600   }
1601   if (flag & LDP_SESSION_CFG_REMOTE_DIST_MODE) {
1602     s->remote_distribution_mode = session->remote_distribution_mode;
1603   }
1604   if (flag & LDP_SESSION_CFG_REMOTE_LOOP_DETECTION) {
1605     s->remote_loop_detection = session->remote_loop_detection;
1606   }
1607   if (flag & LDP_SESSION_CFG_REMOTE_ADDR) {
1608     s->remote_dest.addr.type = session->remote_dest.addr.type;
1609     s->remote_dest.addr.u.ipv4 = session->remote_dest.addr.u.ipv4;
1610   }
1611   if (flag & LDP_SESSION_CFG_REMOTE_PORT) {
1612     s->remote_dest.port = session->remote_dest.port;
1613   }
1614   if (flag & LDP_SESSION_CFG_LABEL_RESOURCE_STATE_LOCAL) {
1615     s->no_label_resource_sent = session->no_label_resource_sent;
1616   }
1617   if (flag & LDP_SESSION_CFG_LABEL_RESOURCE_STATE_REMOTE) {
1618     s->no_label_resource_recv = session->no_label_resource_recv;
1619   }
1620   if (flag & LDP_SESSION_CFG_ADJ_INDEX) {
1621     ldp_adj *a = MPLS_LIST_HEAD(&session->adj_root);
1622     s->adj_index = a ? a->index : 0;
1623   }
1624   if (flag & LDP_SESSION_CFG_MESG_TX) {
1625     s->mesg_tx = session->mesg_tx;
1626   }
1627   if (flag & LDP_SESSION_CFG_MESG_RX) {
1628     s->mesg_rx = session->mesg_rx;
1629   }
1630   retval = MPLS_SUCCESS;
1631
1632 ldp_cfg_session_get_end:
1633   mpls_lock_release(global->global_lock); /* UNLOCK */
1634
1635   LDP_EXIT(global->user_data, "ldp_cfg_session_get");
1636
1637   return retval;
1638 }
1639
1640 mpls_return_enum ldp_cfg_session_getnext(mpls_cfg_handle handle, ldp_session * s,
1641   uint32_t flag)
1642 {
1643   ldp_global *g = (ldp_global *) handle;
1644   ldp_session *ses = NULL;
1645   mpls_return_enum r = MPLS_FAILURE;
1646   mpls_bool done = MPLS_BOOL_FALSE;
1647   int index;
1648
1649   LDP_ENTER(g->user_data, "ldp_cfg_session_getnext");
1650
1651   if (s->index == 0) {
1652     index = 1;
1653   } else {
1654     index = s->index + 1;
1655   }
1656
1657   mpls_lock_get(g->global_lock); /* LOCK */
1658   while (done == MPLS_BOOL_FALSE) {
1659     switch ((r = ldp_global_find_session_index(g, index, &ses))) {
1660       case MPLS_SUCCESS:
1661       case MPLS_END_OF_LIST:
1662         done = MPLS_BOOL_TRUE;
1663         break;
1664       case MPLS_FAILURE:
1665         break;
1666       default:
1667         MPLS_ASSERT(0);
1668     }
1669     index++;
1670   }
1671   mpls_lock_release(g->global_lock); /* UNLOCK */
1672
1673   if (r == MPLS_SUCCESS) {
1674     s->index = ses->index;
1675
1676     LDP_EXIT(g->user_data, "ldp_cfg_session_getnext");
1677     return ldp_cfg_session_get(g, s, flag);
1678   }
1679
1680   LDP_EXIT(g->user_data, "ldp_cfg_session_getnext");
1681
1682   return r;
1683 }
1684
1685 mpls_return_enum ldp_cfg_session_adj_getnext(mpls_cfg_handle handle,
1686   ldp_session * s)
1687 {
1688   ldp_global *g = (ldp_global *) handle;
1689   mpls_bool this_one = MPLS_BOOL_FALSE;
1690   mpls_return_enum r = MPLS_FAILURE;
1691   ldp_adj *adj_next = NULL;
1692   ldp_adj *adj = NULL;
1693   ldp_session *session = NULL;
1694
1695   LDP_ENTER(g->user_data, "ldp_cfg_session_adj_getnext");
1696
1697   /* if an adj_index of zero is sent, get the index of
1698    * the first adj in the list
1699    */
1700   if (!s->adj_index) {
1701     this_one = MPLS_BOOL_TRUE;
1702   }
1703
1704   mpls_lock_get(g->global_lock); /* LOCK */
1705
1706   if (ldp_global_find_session_index(g, s->index, &session) == MPLS_SUCCESS) {
1707     adj = MPLS_LIST_HEAD(&session->adj_root);
1708     while (adj) {
1709       if (this_one == MPLS_BOOL_TRUE) {
1710         adj_next = adj;
1711         break;
1712       }
1713
1714       /* since the entities are sort in the list ... */
1715       if (adj->index > s->adj_index) {
1716         break;
1717       } else if (adj->index == s->adj_index) {
1718         this_one = MPLS_BOOL_TRUE;
1719       }
1720       adj = MPLS_LIST_NEXT(&session->adj_root, adj, _session);
1721     }
1722   }
1723   mpls_lock_release(g->global_lock); /* UNLOCK */
1724
1725   if (adj_next) {
1726     s->adj_index = adj_next->index;
1727     r = MPLS_SUCCESS;
1728   }
1729
1730   LDP_EXIT(g->user_data, "ldp_cfg_session_adj_getnext");
1731   return r;
1732 }
1733
1734 mpls_return_enum ldp_cfg_session_raddr_get(mpls_cfg_handle handle,
1735   ldp_session * s, ldp_addr * a, uint32_t flag)
1736 {
1737   ldp_global *global = (ldp_global *) handle;
1738   ldp_session *session = NULL;
1739   ldp_addr *addr = NULL;
1740   mpls_return_enum retval = MPLS_FAILURE;
1741
1742   MPLS_ASSERT(global !=NULL && s != NULL && a != NULL);
1743
1744   LDP_ENTER(global->user_data, "ldp_cfg_session_raddr_get");
1745
1746   mpls_lock_get(global->global_lock); /* LOCK */
1747
1748   if (ldp_global_find_session_index(global, s->index, &session) != MPLS_SUCCESS)
1749       goto ldp_cfg_session_raddr_get_end;
1750
1751   if (ldp_session_find_raddr_index(session, a->index, &addr) != MPLS_SUCCESS)
1752       goto ldp_cfg_session_raddr_get_end;
1753
1754   if (flag & LDP_SESSION_RADDR_CFG_ADDR) {
1755     memcpy(&a->address,&addr->address,sizeof(struct mpls_inet_addr));
1756   }
1757   if (flag & LDP_SESSION_RADDR_CFG_INDEX) {
1758     a->index = addr->index;
1759   }
1760   retval = MPLS_SUCCESS;
1761
1762 ldp_cfg_session_raddr_get_end:
1763   mpls_lock_release(global->global_lock); /* UNLOCK */
1764
1765   LDP_EXIT(global->user_data, "ldp_cfg_session_raddr_get");
1766
1767   return retval;
1768 }
1769
1770 mpls_return_enum ldp_cfg_session_raddr_getnext(mpls_cfg_handle handle,
1771   ldp_session * s, ldp_addr * a, uint32_t flag)
1772 {
1773   ldp_global *g = (ldp_global *) handle;
1774   ldp_addr *addr = NULL;
1775   mpls_return_enum r = MPLS_FAILURE;
1776   mpls_bool done = MPLS_BOOL_FALSE;
1777   ldp_session *sp = NULL;
1778   int index;
1779
1780   LDP_ENTER(g->user_data, "ldp_cfg_session_raddr_getnext");
1781
1782   if (a->index == 0) {
1783     index = 1;
1784   } else {
1785     index = a->index + 1;
1786   }
1787
1788   r = ldp_global_find_session_index(g, s->index, &sp);
1789   if (r != MPLS_SUCCESS) {
1790     return r;
1791   }
1792
1793   mpls_lock_get(g->global_lock); /* LOCK */
1794   while (done == MPLS_BOOL_FALSE) {
1795     switch ((r = ldp_session_find_raddr_index(sp, index, &addr))) {
1796       case MPLS_SUCCESS:
1797       case MPLS_END_OF_LIST:
1798         done = MPLS_BOOL_TRUE;
1799         break;
1800       case MPLS_FAILURE:
1801         break;
1802       default:
1803         MPLS_ASSERT(0);
1804     }
1805     index++;
1806   }
1807   mpls_lock_release(g->global_lock); /* UNLOCK */
1808
1809   if (r == MPLS_SUCCESS) {
1810     a->index = addr->index;
1811     r = ldp_cfg_session_raddr_get(handle, sp, a, flag);
1812   }
1813
1814   LDP_EXIT(g->user_data, "ldp_cfg_session_getnext");
1815   return r;
1816 }
1817
1818 /******************* IN LABEL **********************/
1819
1820 mpls_return_enum ldp_cfg_inlabel_get(mpls_cfg_handle handle, ldp_inlabel * i,
1821   uint32_t flag)
1822 {
1823   ldp_global *global = (ldp_global *) handle;
1824   ldp_inlabel *inlabel = NULL;
1825   mpls_return_enum retval = MPLS_FAILURE;
1826
1827   MPLS_ASSERT(global !=NULL && i != NULL);
1828
1829   LDP_ENTER(global->user_data, "ldp_cfg_inlabel_get");
1830
1831   mpls_lock_get(global->global_lock); /* LOCK */
1832
1833   if (ldp_global_find_inlabel_index(global, i->index, &inlabel) != MPLS_SUCCESS)
1834       goto ldp_cfg_inlabel_get_end;
1835
1836   if (flag & LDP_INLABEL_CFG_LABELSPACE) {
1837     i->info.labelspace = inlabel->info.labelspace;
1838   }
1839   if (flag & LDP_INLABEL_CFG_LABEL) {
1840     memcpy(&i->info.label, &inlabel->info.label, sizeof(mpls_label_struct));
1841   }
1842   if (flag & LDP_INLABEL_CFG_OUTLABEL_INDEX) {
1843     i->outlabel_index = (inlabel->outlabel) ? (inlabel->outlabel->index) : 0;
1844   }
1845
1846   retval = MPLS_SUCCESS;
1847
1848 ldp_cfg_inlabel_get_end:
1849   mpls_lock_release(global->global_lock); /* UNLOCK */
1850
1851   LDP_EXIT(global->user_data, "ldp_cfg_inlabel_get");
1852
1853   return retval;
1854 }
1855
1856 mpls_return_enum ldp_cfg_inlabel_getnext(mpls_cfg_handle handle, ldp_inlabel * i,
1857   uint32_t flag)
1858 {
1859   ldp_global *g = (ldp_global *) handle;
1860   ldp_inlabel *inlabel = NULL;
1861   mpls_return_enum r = MPLS_FAILURE;
1862   mpls_bool done = MPLS_BOOL_FALSE;
1863   int index;
1864
1865   LDP_ENTER(g->user_data, "ldp_cfg_inlabel_getnext");
1866
1867   if (i->index == 0) {
1868     index = 1;
1869   } else {
1870     index = i->index + 1;
1871   }
1872
1873   mpls_lock_get(g->global_lock); /* LOCK */
1874   while (done == MPLS_BOOL_FALSE) {
1875     switch ((r = ldp_global_find_inlabel_index(g, index, &inlabel))) {
1876       case MPLS_SUCCESS:
1877       case MPLS_END_OF_LIST:
1878         done = MPLS_BOOL_TRUE;
1879         break;
1880       case MPLS_FAILURE:
1881         break;
1882       default:
1883         MPLS_ASSERT(0);
1884     }
1885     index++;
1886   }
1887   mpls_lock_release(g->global_lock); /* UNLOCK */
1888
1889   if (r == MPLS_SUCCESS) {
1890     i->index = inlabel->index;
1891
1892     LDP_EXIT(g->user_data, "ldp_cfg_inlabel_getnext");
1893     return ldp_cfg_inlabel_get(g, i, flag);
1894   }
1895
1896   LDP_EXIT(g->user_data, "ldp_cfg_inlabel_getnext");
1897
1898   return r;
1899 }
1900
1901 /******************* OUT LABEL **********************/
1902
1903 mpls_return_enum ldp_cfg_outlabel_get(mpls_cfg_handle handle, ldp_outlabel * o,
1904   uint32_t flag)
1905 {
1906   ldp_global *global = (ldp_global *) handle;
1907   ldp_outlabel *outlabel = NULL;
1908   mpls_return_enum retval = MPLS_FAILURE;
1909
1910   MPLS_ASSERT(global !=NULL && o != NULL);
1911
1912   LDP_ENTER(global->user_data, "ldp_cfg_outlabel_get");
1913
1914   mpls_lock_get(global->global_lock); /* LOCK */
1915
1916   if (ldp_global_find_outlabel_index(global, o->index,
1917       &outlabel) != MPLS_SUCCESS) goto ldp_cfg_outlabel_get_end;
1918
1919   if (flag & LDP_OUTLABEL_CFG_NH_INDEX) {
1920     if (outlabel->nh) {
1921       o->nh_index = outlabel->nh->index;
1922     } else {
1923       o->nh_index = 0;
1924     }
1925   }
1926   if (flag & LDP_OUTLABEL_CFG_SESSION_INDEX) {
1927     o->session_index = (outlabel->session) ? (outlabel->session->index) : 0;
1928   }
1929   if (flag & LDP_OUTLABEL_CFG_LABEL) {
1930     memcpy(&o->info.label, &outlabel->info.label, sizeof(mpls_label_struct));
1931   }
1932   if (flag & LDP_OUTLABEL_CFG_MERGE_COUNT) {
1933     o->merge_count = outlabel->merge_count;
1934   }
1935
1936   retval = MPLS_SUCCESS;
1937
1938 ldp_cfg_outlabel_get_end:
1939   mpls_lock_release(global->global_lock); /* UNLOCK */
1940
1941   LDP_EXIT(global->user_data, "ldp_cfg_outlabel_get");
1942
1943   return retval;
1944 }
1945
1946 mpls_return_enum ldp_cfg_outlabel_getnext(mpls_cfg_handle handle,
1947   ldp_outlabel * o, uint32_t flag)
1948 {
1949   ldp_global *g = (ldp_global *) handle;
1950   ldp_outlabel *outlabel = NULL;
1951   mpls_return_enum r = MPLS_FAILURE;
1952   mpls_bool done = MPLS_BOOL_FALSE;
1953   int index;
1954
1955   LDP_ENTER(g->user_data, "ldp_cfg_outlabel_getnext");
1956
1957   if (o->index == 0) {
1958     index = 1;
1959   } else {
1960     index = o->index + 1;
1961   }
1962
1963   mpls_lock_get(g->global_lock); /* LOCK */
1964   while (done == MPLS_BOOL_FALSE) {
1965     switch ((r = ldp_global_find_outlabel_index(g, index, &outlabel))) {
1966       case MPLS_SUCCESS:
1967       case MPLS_END_OF_LIST:
1968         done = MPLS_BOOL_TRUE;
1969         break;
1970       case MPLS_FAILURE:
1971         break;
1972       default:
1973         MPLS_ASSERT(0);
1974     }
1975     index++;
1976   }
1977   mpls_lock_release(g->global_lock); /* UNLOCK */
1978
1979   if (r == MPLS_SUCCESS) {
1980     o->index = outlabel->index;
1981
1982     LDP_EXIT(g->user_data, "ldp_cfg_outlabel_getnext");
1983     return ldp_cfg_outlabel_get(g, o, flag);
1984   }
1985
1986   LDP_EXIT(g->user_data, "ldp_cfg_outlabel_getnext");
1987
1988   return r;
1989 }
1990
1991 /******************* TUNNEL **********************/
1992
1993 mpls_return_enum ldp_cfg_tunnel_set(mpls_cfg_handle handle, ldp_tunnel * t,
1994   uint32_t flag)
1995 {
1996   ldp_global *global = (ldp_global *) handle;
1997   mpls_return_enum retval = MPLS_FAILURE;
1998   ldp_tunnel *tunnel = NULL;
1999
2000   MPLS_ASSERT(global !=NULL);
2001
2002   LDP_ENTER(global->user_data, "ldp_cfg_tunnel_set");
2003
2004   mpls_lock_get(global->global_lock); /* LOCK */
2005
2006   if (flag & LDP_CFG_ADD) {
2007     if (!(tunnel = ldp_tunnel_create())) {
2008       goto ldp_cfg_tunnel_set_end;
2009     }
2010     _ldp_global_add_tunnel(global, tunnel);
2011
2012     t->index = tunnel->index;
2013   } else {
2014     ldp_global_find_tunnel_index(global, t->index, &tunnel);
2015   }
2016
2017   if (!tunnel) {
2018     LDP_PRINT(global->user_data,
2019
2020       "ldp_cfg_tunnel_set:could not create tunnel\n");
2021     goto ldp_cfg_tunnel_set_end;
2022   }
2023
2024   if ((ldp_tunnel_is_active(tunnel) == MPLS_BOOL_TRUE) &&
2025     (flag & LDP_TUNNEL_CFG_WHEN_DOWN)) {
2026     LDP_PRINT(global->user_data, "ldp_cfg_tunnel_set: tunnel is active\n");
2027
2028     goto ldp_cfg_tunnel_set_end;
2029   }
2030
2031   if (flag & LDP_CFG_DEL) {
2032     if (tunnel->outlabel)
2033       ldp_tunnel_del_outlabel(tunnel);
2034     if (tunnel->resource)
2035       ldp_tunnel_del_resource(tunnel);
2036     if (tunnel->hop_list)
2037       ldp_tunnel_del_hop_list(tunnel);
2038     _ldp_global_del_tunnel(global, tunnel);
2039
2040     retval = MPLS_SUCCESS;
2041     goto ldp_cfg_tunnel_set_end;
2042   }
2043
2044   if (flag & LDP_TUNNEL_CFG_INGRESS) {
2045     memcpy(&tunnel->ingress_lsrid, &t->ingress_lsrid, sizeof(ldp_addr));
2046   }
2047   if (flag & LDP_TUNNEL_CFG_EGRESS) {
2048     memcpy(&tunnel->egress_lsrid, &t->egress_lsrid, sizeof(ldp_addr));
2049   }
2050   if (flag & LDP_TUNNEL_CFG_NAME) {
2051     memcpy(&tunnel->name, &t->name, MPLS_MAX_IF_NAME);
2052   }
2053   if (flag & LDP_TUNNEL_CFG_IS_IF) {
2054     tunnel->is_interface = t->is_interface;
2055   }
2056   if (flag & LDP_TUNNEL_CFG_OUTLABEL) {
2057     ldp_outlabel *outlabel = NULL;
2058
2059     if (t->outlabel_index) {
2060       ldp_global_find_outlabel_index(global, t->outlabel_index, &outlabel);
2061
2062       if (!outlabel) {
2063         goto ldp_cfg_tunnel_set_end;
2064       }
2065       ldp_tunnel_add_outlabel(tunnel, outlabel);
2066     } else {
2067       ldp_tunnel_del_outlabel(tunnel);
2068     }
2069   }
2070   if (flag & LDP_TUNNEL_CFG_SETUP_PRIO) {
2071     tunnel->setup_prio = t->setup_prio;
2072   }
2073   if (flag & LDP_TUNNEL_CFG_HOLD_PRIO) {
2074     tunnel->hold_prio = t->hold_prio;
2075   }
2076   if (flag & LDP_TUNNEL_CFG_INSTANCE_PRIO) {
2077     tunnel->instance_prio = t->instance_prio;
2078   }
2079   if (flag & LDP_TUNNEL_CFG_LOCAL_PROTECT) {
2080     tunnel->local_protect = t->local_protect;
2081   }
2082   if (flag & LDP_TUNNEL_CFG_RESOURCE_INDEX) {
2083     ldp_resource *resource = NULL;
2084
2085     if (t->resource_index) {
2086       ldp_global_find_resource_index(global, t->resource_index, &resource);
2087
2088       if (!resource) {
2089         goto ldp_cfg_tunnel_set_end;
2090       }
2091       ldp_tunnel_add_resource(tunnel, resource);
2092     } else {
2093       ldp_tunnel_del_resource(tunnel);
2094     }
2095   }
2096   if (flag & LDP_TUNNEL_CFG_HOP_LIST_INDEX) {
2097     ldp_hop_list *hop_list = NULL;
2098
2099     if (t->hop_list_index) {
2100       ldp_global_find_hop_list_index(global, t->hop_list_index, &hop_list);
2101
2102       if (!hop_list) {
2103         goto ldp_cfg_tunnel_set_end;
2104       }
2105       ldp_tunnel_add_hop_list(tunnel, hop_list);
2106     } else {
2107       ldp_tunnel_del_hop_list(tunnel);
2108     }
2109   }
2110   if (flag & LDP_TUNNEL_CFG_FEC) {
2111     memcpy(&tunnel->fec, &t->fec, sizeof(ldp_fec));
2112   }
2113   if (flag & LDP_TUNNEL_CFG_ADMIN_STATE) {
2114     if (ldp_tunnel_is_active(tunnel) == MPLS_BOOL_TRUE) {
2115       if (t->admin_state == MPLS_ADMIN_DISABLE) {
2116         if (ldp_tunnel_shutdown(global, tunnel, 0) == MPLS_FAILURE) {
2117           goto ldp_cfg_tunnel_set_end;
2118         }
2119       }
2120     } else {
2121       if (t->admin_state == MPLS_ADMIN_ENABLE) {
2122         if (ldp_tunnel_is_ready(tunnel) == MPLS_BOOL_TRUE) {
2123           if (ldp_tunnel_startup(global, tunnel) == MPLS_FAILURE) {
2124             goto ldp_cfg_tunnel_set_end;
2125           }
2126         } else {
2127           LDP_PRINT(global->user_data,
2128
2129             "ldp_cfg_tunnel_set: tunnel not ready\n");
2130           goto ldp_cfg_tunnel_set_end;
2131         }
2132       }
2133     }
2134   }
2135   retval = MPLS_SUCCESS;
2136
2137 ldp_cfg_tunnel_set_end:
2138
2139   mpls_lock_release(global->global_lock); /* UNLOCK */
2140
2141   LDP_EXIT(global->user_data, "ldp_cfg_tunnel_set");
2142
2143   return retval;
2144 }
2145
2146 mpls_return_enum ldp_cfg_tunnel_test(mpls_cfg_handle handle, ldp_tunnel * t,
2147   uint32_t flag)
2148 {
2149   ldp_global *global = (ldp_global *) handle;
2150   mpls_return_enum retval = MPLS_FAILURE;
2151   ldp_tunnel *tunnel = NULL;
2152
2153   MPLS_ASSERT(global !=NULL);
2154
2155   LDP_ENTER(global->user_data, "ldp_cfg_tunnel_test");
2156
2157   mpls_lock_get(global->global_lock); /* LOCK */
2158
2159   if (flag & LDP_CFG_ADD) {
2160     retval = MPLS_SUCCESS;
2161     goto ldp_cfg_tunnel_test_end;
2162   }
2163
2164   ldp_global_find_tunnel_index(global, t->index, &tunnel);
2165
2166   if (!tunnel) {
2167     goto ldp_cfg_tunnel_test_end;
2168   }
2169
2170   if (flag & LDP_TUNNEL_CFG_RESOURCE_INDEX) {
2171     ldp_resource *resource = NULL;
2172
2173     if (t->resource_index) {
2174       ldp_global_find_resource_index(global, t->resource_index, &resource);
2175
2176       if (!resource) {
2177         goto ldp_cfg_tunnel_test_end;
2178       }
2179     }
2180   }
2181   if (flag & LDP_TUNNEL_CFG_HOP_LIST_INDEX) {
2182     ldp_hop_list *hop_list = NULL;
2183
2184     if (t->hop_list_index) {
2185       ldp_global_find_hop_list_index(global, t->hop_list_index, &hop_list);
2186
2187       if (!hop_list) {
2188         goto ldp_cfg_tunnel_test_end;
2189       }
2190     }
2191   }
2192   if (flag & LDP_TUNNEL_CFG_OUTLABEL) {
2193     ldp_outlabel *outlabel = NULL;
2194
2195     if (t->outlabel_index) {
2196       ldp_global_find_outlabel_index(global, t->outlabel_index, &outlabel);
2197
2198       if (!outlabel) {
2199         goto ldp_cfg_tunnel_test_end;
2200       }
2201     }
2202   }
2203   if ((flag & LDP_TUNNEL_CFG_ADMIN_STATE) &&
2204     (ldp_tunnel_is_active(tunnel) == MPLS_BOOL_FALSE) &&
2205     (t->admin_state == MPLS_ADMIN_ENABLE) && (ldp_tunnel_is_ready(tunnel) != MPLS_BOOL_TRUE)) {
2206     goto ldp_cfg_tunnel_test_end;
2207   }
2208   retval = MPLS_SUCCESS;
2209
2210 ldp_cfg_tunnel_test_end:
2211
2212   mpls_lock_release(global->global_lock); /* UNLOCK */
2213
2214   LDP_EXIT(global->user_data, "ldp_cfg_tunnel_test");
2215
2216   return retval;
2217 }
2218
2219 mpls_return_enum ldp_cfg_tunnel_get(mpls_cfg_handle handle, ldp_tunnel * t,
2220   uint32_t flag)
2221 {
2222   ldp_global *global = (ldp_global *) handle;
2223   mpls_return_enum retval = MPLS_FAILURE;
2224   ldp_tunnel *tunnel = NULL;
2225
2226   MPLS_ASSERT(global !=NULL);
2227
2228   LDP_ENTER(global->user_data, "ldp_cfg_tunnel_get");
2229
2230   mpls_lock_get(global->global_lock); /* LOCK */
2231
2232   ldp_global_find_tunnel_index(global, t->index, &tunnel);
2233
2234   if (!tunnel) {
2235     goto ldp_cfg_tunnel_get_end;
2236   }
2237   if (flag & LDP_TUNNEL_CFG_INGRESS) {
2238     memcpy(&t->ingress_lsrid, &tunnel->ingress_lsrid, sizeof(ldp_addr));
2239   }
2240   if (flag & LDP_TUNNEL_CFG_EGRESS) {
2241     memcpy(&t->egress_lsrid, &tunnel->egress_lsrid, sizeof(ldp_addr));
2242   }
2243   if (flag & LDP_TUNNEL_CFG_NAME) {
2244     memcpy(&t->name, &tunnel->name, MPLS_MAX_IF_NAME);
2245   }
2246   if (flag & LDP_TUNNEL_CFG_IS_IF) {
2247     t->is_interface = tunnel->is_interface;
2248   }
2249   if (flag & LDP_TUNNEL_CFG_OUTLABEL) {
2250     if (tunnel->outlabel) {
2251       t->outlabel_index = tunnel->outlabel->index;
2252     } else {
2253       t->outlabel_index = 0;
2254     }
2255   }
2256   if (flag & LDP_TUNNEL_CFG_SETUP_PRIO) {
2257     t->setup_prio = tunnel->setup_prio;
2258   }
2259   if (flag & LDP_TUNNEL_CFG_HOLD_PRIO) {
2260     t->hold_prio = tunnel->hold_prio;
2261   }
2262   if (flag & LDP_TUNNEL_CFG_INSTANCE_PRIO) {
2263     tunnel->instance_prio = t->instance_prio;
2264   }
2265   if (flag & LDP_TUNNEL_CFG_LOCAL_PROTECT) {
2266     tunnel->local_protect = t->local_protect;
2267   }
2268   if (flag & LDP_TUNNEL_CFG_RESOURCE_INDEX) {
2269     if (tunnel->resource) {
2270       t->resource_index = tunnel->resource->index;
2271     } else {
2272       t->resource_index = 0;
2273     }
2274   }
2275   if (flag & LDP_TUNNEL_CFG_HOP_LIST_INDEX) {
2276     if (tunnel->hop_list) {
2277       t->hop_list_index = tunnel->hop_list->index;
2278     } else {
2279       t->hop_list_index = 0;
2280     }
2281   }
2282   if (flag & LDP_TUNNEL_CFG_FEC) {
2283     memcpy(&t->fec, &tunnel->fec, sizeof(ldp_fec));
2284   }
2285   if (flag & LDP_TUNNEL_CFG_ADMIN_STATE) {
2286     t->admin_state = tunnel->admin_state;
2287   }
2288   retval = MPLS_SUCCESS;
2289
2290 ldp_cfg_tunnel_get_end:
2291
2292   mpls_lock_release(global->global_lock); /* UNLOCK */
2293
2294   LDP_EXIT(global->user_data, "ldp_cfg_tunnel_get");
2295
2296   return retval;
2297 }
2298
2299 /******************* RESOURCE **********************/
2300
2301 mpls_return_enum ldp_cfg_resource_set(mpls_cfg_handle handle, ldp_resource * r,
2302   uint32_t flag)
2303 {
2304   ldp_global *global = (ldp_global *) handle;
2305   mpls_return_enum retval = MPLS_FAILURE;
2306   ldp_resource *resource = NULL;
2307
2308   MPLS_ASSERT(global !=NULL);
2309
2310   LDP_ENTER(global->user_data, "ldp_cfg_resource_set");
2311
2312   mpls_lock_get(global->global_lock); /* LOCK */
2313
2314   if (flag & LDP_CFG_ADD) {
2315     resource = ldp_resource_create();
2316     _ldp_global_add_resource(global, resource);
2317
2318     r->index = resource->index;
2319   } else {
2320     ldp_global_find_resource_index(global, r->index, &resource);
2321   }
2322
2323   if (!resource) {
2324     goto ldp_cfg_resource_set_end;
2325   }
2326
2327   if (flag & LDP_RESOURCE_CFG_MAXBPS) {
2328     resource->max_rate = r->max_rate;
2329   }
2330   if (flag & LDP_RESOURCE_CFG_MEANBPS) {
2331     resource->mean_rate = r->mean_rate;
2332   }
2333   if (flag & LDP_RESOURCE_CFG_BURSTSIZE) {
2334     resource->burst_size = r->burst_size;
2335   }
2336   retval = MPLS_SUCCESS;
2337
2338 ldp_cfg_resource_set_end:
2339
2340   mpls_lock_release(global->global_lock); /* UNLOCK */
2341
2342   LDP_EXIT(global->user_data, "ldp_cfg_resource_set");
2343
2344   return retval;
2345 }
2346
2347 mpls_return_enum ldp_cfg_resource_test(mpls_cfg_handle handle, ldp_resource * r,
2348   uint32_t flag)
2349 {
2350   ldp_global *global = (ldp_global *) handle;
2351   mpls_return_enum retval = MPLS_FAILURE;
2352   ldp_resource *resource = NULL;
2353
2354   MPLS_ASSERT(global !=NULL);
2355
2356   LDP_ENTER(global->user_data, "ldp_cfg_resource_test");
2357
2358   mpls_lock_get(global->global_lock); /* LOCK */
2359
2360   if (flag & LDP_CFG_ADD) {
2361     retval = MPLS_SUCCESS;
2362     goto ldp_cfg_resource_test_end;
2363   }
2364
2365   ldp_global_find_resource_index(global, r->index, &resource);
2366
2367   if (!resource) {
2368     goto ldp_cfg_resource_test_end;
2369   }
2370
2371   if (ldp_resource_in_use(resource) == MPLS_BOOL_TRUE) {
2372     goto ldp_cfg_resource_test_end;
2373   }
2374   retval = MPLS_SUCCESS;
2375
2376 ldp_cfg_resource_test_end:
2377
2378   mpls_lock_release(global->global_lock); /* UNLOCK */
2379
2380   LDP_EXIT(global->user_data, "ldp_cfg_resource_test");
2381
2382   return retval;
2383 }
2384
2385 mpls_return_enum ldp_cfg_resource_get(mpls_cfg_handle handle, ldp_resource * r,
2386   uint32_t flag)
2387 {
2388   ldp_global *global = (ldp_global *) handle;
2389   mpls_return_enum retval = MPLS_FAILURE;
2390   ldp_resource *resource = NULL;
2391
2392   MPLS_ASSERT(global !=NULL);
2393
2394   LDP_ENTER(global->user_data, "ldp_cfg_resource_get");
2395
2396   mpls_lock_get(global->global_lock); /* LOCK */
2397
2398   ldp_global_find_resource_index(global, r->index, &resource);
2399
2400   if (!resource) {
2401     goto ldp_cfg_resource_get_end;
2402   }
2403
2404   if (flag & LDP_RESOURCE_CFG_MAXBPS) {
2405     r->max_rate = resource->max_rate;
2406   }
2407   if (flag & LDP_RESOURCE_CFG_MEANBPS) {
2408     r->mean_rate = resource->mean_rate;
2409   }
2410   if (flag & LDP_RESOURCE_CFG_BURSTSIZE) {
2411     r->burst_size = resource->burst_size;
2412   }
2413   retval = MPLS_SUCCESS;
2414
2415 ldp_cfg_resource_get_end:
2416
2417   mpls_lock_release(global->global_lock); /* UNLOCK */
2418
2419   LDP_EXIT(global->user_data, "ldp_cfg_resource_get");
2420
2421   return retval;
2422 }
2423
2424 /******************* HOP **********************/
2425
2426 mpls_return_enum ldp_cfg_hop_set(mpls_cfg_handle handle, ldp_hop * h,
2427   uint32_t flag)
2428 {
2429   ldp_global *global = (ldp_global *) handle;
2430   mpls_return_enum retval = MPLS_FAILURE;
2431   ldp_hop_list *hop_list = NULL;
2432   ldp_hop *hop = NULL;
2433
2434   MPLS_ASSERT(global !=NULL);
2435
2436   LDP_ENTER(global->user_data, "ldp_cfg_hop_set");
2437
2438   if (!h->hop_list_index && !h->index) {
2439     return retval;
2440   }
2441
2442   mpls_lock_get(global->global_lock); /* LOCK */
2443
2444   ldp_global_find_hop_list_index(global, h->hop_list_index, &hop_list);
2445
2446   if (!hop_list) {
2447     if (flag & LDP_CFG_ADD) {
2448       if (!(hop_list = ldp_hop_list_create())) {
2449         goto ldp_cfg_hop_set_end;
2450       }
2451       _ldp_global_add_hop_list(global, hop_list);
2452
2453       h->hop_list_index = hop_list->index;
2454     } else {
2455       goto ldp_cfg_hop_set_end;
2456     }
2457   }
2458
2459   ldp_hop_list_find_hop_index(hop_list, h->index, &hop);
2460   if (!hop) {
2461     if (h->index && (flag & LDP_CFG_ADD)) {
2462       if (!(hop = ldp_hop_create())) {
2463         goto ldp_cfg_hop_set_end;
2464       }
2465       hop->index = h->index;
2466       ldp_hop_list_add_hop(hop_list, hop);
2467     } else {
2468       goto ldp_cfg_hop_set_end;
2469     }
2470   }
2471
2472   if (flag & LDP_HOP_CFG_PATH_OPTION) {
2473     hop->path_option = h->path_option;
2474   }
2475   if (flag & LDP_HOP_CFG_ADDR) {
2476     memcpy(&hop->addr, &h->addr, sizeof(ldp_addr));
2477   }
2478   if (flag & LDP_HOP_CFG_TYPE) {
2479     hop->type = h->type;
2480   }
2481   retval = MPLS_SUCCESS;
2482
2483 ldp_cfg_hop_set_end:
2484
2485   mpls_lock_release(global->global_lock); /* UNLOCK */
2486
2487   LDP_EXIT(global->user_data, "ldp_cfg_hop_set");
2488
2489   return retval;
2490 }
2491
2492 mpls_return_enum ldp_cfg_hop_test(mpls_cfg_handle handle, ldp_hop * h,
2493   uint32_t flag)
2494 {
2495   ldp_global *global = (ldp_global *) handle;
2496   mpls_return_enum retval = MPLS_FAILURE;
2497   ldp_hop_list *hop_list = NULL;
2498   ldp_hop *hop = NULL;
2499
2500   MPLS_ASSERT(global !=NULL);
2501
2502   LDP_ENTER(global->user_data, "ldp_cfg_hop_test");
2503
2504   mpls_lock_get(global->global_lock); /* LOCK */
2505
2506   if (flag & LDP_CFG_ADD) {
2507     retval = MPLS_SUCCESS;
2508     goto ldp_cfg_hop_test_end;
2509   }
2510
2511   ldp_global_find_hop_list_index(global, h->hop_list_index, &hop_list);
2512
2513   if (!hop_list) {
2514     goto ldp_cfg_hop_test_end;
2515   }
2516
2517   ldp_hop_list_find_hop_index(hop_list, h->index, &hop);
2518   if (!hop) {
2519     goto ldp_cfg_hop_test_end;
2520   }
2521
2522   if (ldp_hop_in_use(hop) == MPLS_BOOL_TRUE) {
2523     goto ldp_cfg_hop_test_end;
2524   }
2525   retval = MPLS_SUCCESS;
2526
2527 ldp_cfg_hop_test_end:
2528
2529   mpls_lock_release(global->global_lock); /* UNLOCK */
2530
2531   LDP_EXIT(global->user_data, "ldp_cfg_hop_test");
2532
2533   return retval;
2534 }
2535
2536 mpls_return_enum ldp_cfg_hop_get(mpls_cfg_handle handle, ldp_hop * h,
2537   uint32_t flag)
2538 {
2539   ldp_global *global = (ldp_global *) handle;
2540   mpls_return_enum retval = MPLS_FAILURE;
2541   ldp_hop_list *hop_list = NULL;
2542   ldp_hop *hop = NULL;
2543
2544   MPLS_ASSERT(global !=NULL);
2545
2546   LDP_ENTER(global->user_data, "ldp_cfg_hop_get");
2547
2548   mpls_lock_get(global->global_lock); /* LOCK */
2549
2550   ldp_global_find_hop_list_index(global, h->hop_list_index, &hop_list);
2551
2552   if (!hop_list) {
2553     goto ldp_cfg_hop_get_end;
2554   }
2555
2556   ldp_hop_list_find_hop_index(hop_list, h->index, &hop);
2557   if (!hop) {
2558     goto ldp_cfg_hop_get_end;
2559   }
2560
2561   if (flag & LDP_HOP_CFG_PATH_OPTION) {
2562     h->path_option = hop->path_option;
2563   }
2564   if (flag & LDP_HOP_CFG_ADDR) {
2565     memcpy(&h->addr, &hop->addr, sizeof(ldp_addr));
2566   }
2567   if (flag & LDP_HOP_CFG_TYPE) {
2568     h->type = hop->type;
2569   }
2570   retval = MPLS_SUCCESS;
2571
2572 ldp_cfg_hop_get_end:
2573
2574   mpls_lock_release(global->global_lock); /* UNLOCK */
2575
2576   LDP_EXIT(global->user_data, "ldp_cfg_hop_get");
2577
2578   return retval;
2579 }