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