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