?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implement the tie between adding/removing interface addresses and
[mpls-ldp-portable.git] / ldp / ldp_cfg.c
blob97a3ab70f4a9a617cf46e6287bff154c0410e089
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 ldp_addr_process_add(global, addr);
1741 } else {
1742 if (flag & LDP_IF_ADDR_CFG_BY_INDEX) {
1743 ldp_if_find_addr_index(iff, a->index, &addr);
1744 } else {
1745 addr = ldp_if_addr_find(iff, &a->address);
1746 }
1747 }
1748
1749 if (addr == NULL) {
1750 LDP_PRINT(global->user_data, "ldp_cfg_if_addr_set: no such addr\n");
1751 goto ldp_cfg_if_addr_set_end;
1752 }
1753
1754 if (flag & LDP_CFG_DEL) {
1755 ldp_addr_process_remove(global, addr);
1756 ldp_if_del_addr(global, iff, addr);
1757 }
1758
1759 retval = MPLS_SUCCESS;
1760
1761 ldp_cfg_if_addr_set_end:
1762 mpls_lock_release(global->global_lock); /* UNLOCK */
1763
1764 LDP_EXIT(global->user_data, "ldp_cfg_if_addr_set");
1765
1766 return retval;
1767 }
1768
1769 /******************* ADJACENCY **********************/
1770
1771 mpls_return_enum ldp_cfg_adj_get(mpls_cfg_handle handle, ldp_adj * a,
1772 uint32_t flag)
1773 {
1774 ldp_global *global = (ldp_global *) handle;
1775 ldp_adj *adj = NULL;
1776 mpls_return_enum retval = MPLS_FAILURE;
1777
1778 MPLS_ASSERT(global != NULL && a != NULL);
1779
1780 LDP_ENTER(global->user_data, "ldp_cfg_adj_get");
1781
1782 mpls_lock_get(global->global_lock); /* LOCK */
1783
1784 if (ldp_global_find_adj_index(global, a->index, &adj) != MPLS_SUCCESS)
1785 goto ldp_cfg_adj_get_end;
1786
1787 if (flag & LDP_ADJ_CFG_REMOTE_TRADDR) {
1788 memcpy(&a->remote_transport_address, &adj->remote_transport_address,
1789 sizeof(mpls_inet_addr));
1790 }
1791 if (flag & LDP_ADJ_CFG_REMOTE_SRCADDR) {
1792 memcpy(&a->remote_source_address, &adj->remote_source_address,
1793 sizeof(mpls_inet_addr));
1794 }
1795 if (flag & LDP_ADJ_CFG_REMOTE_LSRADDR) {
1796 memcpy(&a->remote_lsr_address, &adj->remote_lsr_address,
1797 sizeof(mpls_inet_addr));
1798 }
1799 if (flag & LDP_ADJ_CFG_REMOTE_CSN) {
1800 a->remote_csn = adj->remote_csn;
1801 }
1802 if (flag & LDP_ADJ_CFG_REMOTE_LABELSPACE) {
1803 a->remote_label_space = adj->remote_label_space;
1804 }
1805 if (flag & LDP_ADJ_CFG_REMOTE_HELLOTIME) {
1806 a->remote_hellotime = adj->remote_hellotime;
1807 }
1808 if (flag & LDP_ADJ_CFG_ENTITY_INDEX) {
1809 a->entity_index = adj->entity ? adj->entity->index : 0;
1810 }
1811 if (flag & LDP_ADJ_CFG_REMOTE_SESSION_INDEX) {
1812 a->session_index = (adj->session) ? (adj->session->index) : 0;
1813 }
1814 if (flag & LDP_ADJ_CFG_ROLE) {
1815 a->role = adj->role;
1816 }
1817 retval = MPLS_SUCCESS;
1818
1819 ldp_cfg_adj_get_end:
1820
1821 mpls_lock_release(global->global_lock); /* UNLOCK */
1822
1823 LDP_EXIT(global->user_data, "ldp_cfg_adj_get");
1824
1825 return retval;
1826 }
1827
1828 mpls_return_enum ldp_cfg_adj_getnext(mpls_cfg_handle handle, ldp_adj * a,
1829 uint32_t flag)
1830 {
1831 ldp_global *g = (ldp_global *) handle;
1832 ldp_adj *adj = NULL;
1833 mpls_return_enum r = MPLS_FAILURE;
1834 mpls_bool done = MPLS_BOOL_FALSE;
1835 int index;
1836
1837 LDP_ENTER(g->user_data, "ldp_cfg_adj_getnext");
1838
1839 if (a->index == 0) {
1840 index = 1;
1841 } else {
1842 index = a->index + 1;
1843 }
1844
1845 mpls_lock_get(g->global_lock); /* LOCK */
1846 while (done == MPLS_BOOL_FALSE) {
1847 switch ((r = ldp_global_find_adj_index(g, index, &adj))) {
1848 case MPLS_SUCCESS:
1849 case MPLS_END_OF_LIST:
1850 done = MPLS_BOOL_TRUE;
1851 break;
1852 case MPLS_FAILURE:
1853 break;
1854 default:
1855 MPLS_ASSERT(0);
1856 }
1857 index++;
1858 }
1859 mpls_lock_release(g->global_lock); /* UNLOCK */
1860
1861 if (r == MPLS_SUCCESS) {
1862 a->index = adj->index;
1863 LDP_EXIT(g->user_data, "ldp_cfg_adj_getnext");
1864 return ldp_cfg_adj_get(g, a, flag);
1865 }
1866 LDP_EXIT(g->user_data, "ldp_cfg_adj_getnext");
1867 return r;
1868 }
1869
1870 /******************* SESSION **********************/
1871
1872 mpls_return_enum ldp_cfg_session_get(mpls_cfg_handle handle, ldp_session * s,
1873 uint32_t flag)
1874 {
1875 ldp_global *global = (ldp_global *) handle;
1876 ldp_session *session = NULL;
1877 mpls_return_enum retval = MPLS_FAILURE;
1878
1879 MPLS_ASSERT(global !=NULL && s != NULL);
1880
1881 LDP_ENTER(global->user_data, "ldp_cfg_session_get");
1882
1883 mpls_lock_get(global->global_lock); /* LOCK */
1884
1885 if (ldp_global_find_session_index(global, s->index, &session) != MPLS_SUCCESS)
1886 goto ldp_cfg_session_get_end;
1887
1888 if (flag & LDP_SESSION_CFG_STATE) {
1889 s->state = session->state;
1890 }
1891 if (flag & LDP_SESSION_CFG_OPER_UP) {
1892 s->oper_up = session->oper_up;
1893 }
1894 if (flag & LDP_SESSION_CFG_MAX_PDU) {
1895 s->oper_max_pdu = session->oper_max_pdu;
1896 }
1897 if (flag & LDP_SESSION_CFG_KEEPALIVE) {
1898 s->oper_keepalive = session->oper_keepalive;
1899 }
1900 if (flag & LDP_SESSION_CFG_PATH_LIMIT) {
1901 s->oper_path_vector_limit = session->oper_path_vector_limit;
1902 }
1903 if (flag & LDP_SESSION_CFG_DIST_MODE) {
1904 s->oper_distribution_mode = session->oper_distribution_mode;
1905 }
1906 if (flag & LDP_SESSION_CFG_LOOP_DETECTION) {
1907 s->oper_loop_detection = session->oper_loop_detection;
1908 }
1909 if (flag & LDP_SESSION_CFG_REMOTE_MAX_PDU) {
1910 s->remote_max_pdu = session->remote_max_pdu;
1911 }
1912 if (flag & LDP_SESSION_CFG_REMOTE_KEEPALIVE) {
1913 s->remote_keepalive = session->remote_keepalive;
1914 }
1915 if (flag & LDP_SESSION_CFG_REMOTE_PATH_LIMIT) {
1916 s->remote_path_vector_limit = session->remote_path_vector_limit;
1917 }
1918 if (flag & LDP_SESSION_CFG_REMOTE_DIST_MODE) {
1919 s->remote_distribution_mode = session->remote_distribution_mode;
1920 }
1921 if (flag & LDP_SESSION_CFG_REMOTE_LOOP_DETECTION) {
1922 s->remote_loop_detection = session->remote_loop_detection;
1923 }
1924 if (flag & LDP_SESSION_CFG_REMOTE_ADDR) {
1925 s->remote_dest.addr.type = session->remote_dest.addr.type;
1926 s->remote_dest.addr.u.ipv4 = session->remote_dest.addr.u.ipv4;
1927 }
1928 if (flag & LDP_SESSION_CFG_REMOTE_PORT) {
1929 s->remote_dest.port = session->remote_dest.port;
1930 }
1931 if (flag & LDP_SESSION_CFG_LABEL_RESOURCE_STATE_LOCAL) {
1932 s->no_label_resource_sent = session->no_label_resource_sent;
1933 }
1934 if (flag & LDP_SESSION_CFG_LABEL_RESOURCE_STATE_REMOTE) {
1935 s->no_label_resource_recv = session->no_label_resource_recv;
1936 }
1937 if (flag & LDP_SESSION_CFG_ADJ_INDEX) {
1938 ldp_adj *a = MPLS_LIST_HEAD(&session->adj_root);
1939 s->adj_index = a ? a->index : 0;
1940 }
1941 if (flag & LDP_SESSION_CFG_MESG_TX) {
1942 s->mesg_tx = session->mesg_tx;
1943 }
1944 if (flag & LDP_SESSION_CFG_MESG_RX) {
1945 s->mesg_rx = session->mesg_rx;
1946 }
1947 retval = MPLS_SUCCESS;
1948
1949 ldp_cfg_session_get_end:
1950 mpls_lock_release(global->global_lock); /* UNLOCK */
1951
1952 LDP_EXIT(global->user_data, "ldp_cfg_session_get");
1953
1954 return retval;
1955 }
1956
1957 mpls_return_enum ldp_cfg_session_getnext(mpls_cfg_handle handle, ldp_session * s,
1958 uint32_t flag)
1959 {
1960 ldp_global *g = (ldp_global *) handle;
1961 ldp_session *ses = NULL;
1962 mpls_return_enum r = MPLS_FAILURE;
1963 mpls_bool done = MPLS_BOOL_FALSE;
1964 int index;
1965
1966 LDP_ENTER(g->user_data, "ldp_cfg_session_getnext");
1967
1968 if (s->index == 0) {
1969 index = 1;
1970 } else {
1971 index = s->index + 1;
1972 }
1973
1974 mpls_lock_get(g->global_lock); /* LOCK */
1975 while (done == MPLS_BOOL_FALSE) {
1976 switch ((r = ldp_global_find_session_index(g, index, &ses))) {
1977 case MPLS_SUCCESS:
1978 case MPLS_END_OF_LIST:
1979 done = MPLS_BOOL_TRUE;
1980 break;
1981 case MPLS_FAILURE:
1982 break;
1983 default:
1984 MPLS_ASSERT(0);
1985 }
1986 index++;
1987 }
1988 mpls_lock_release(g->global_lock); /* UNLOCK */
1989
1990 if (r == MPLS_SUCCESS) {
1991 s->index = ses->index;
1992
1993 LDP_EXIT(g->user_data, "ldp_cfg_session_getnext");
1994 return ldp_cfg_session_get(g, s, flag);
1995 }
1996
1997 LDP_EXIT(g->user_data, "ldp_cfg_session_getnext");
1998
1999 return r;
2000 }
2001
2002 mpls_return_enum ldp_cfg_session_adj_getnext(mpls_cfg_handle handle,
2003 ldp_session * s)
2004 {
2005 ldp_global *g = (ldp_global *) handle;
2006 mpls_bool this_one = MPLS_BOOL_FALSE;
2007 mpls_return_enum r = MPLS_FAILURE;
2008 ldp_adj *adj_next = NULL;
2009 ldp_adj *adj = NULL;
2010 ldp_session *session = NULL;
2011
2012 LDP_ENTER(g->user_data, "ldp_cfg_session_adj_getnext");
2013
2014 /* if an adj_index of zero is sent, get the index of
2015 * the first adj in the list
2016 */
2017 if (!s->adj_index) {
2018 this_one = MPLS_BOOL_TRUE;
2019 }
2020
2021 mpls_lock_get(g->global_lock); /* LOCK */
2022
2023 if (ldp_global_find_session_index(g, s->index, &session) == MPLS_SUCCESS) {
2024 adj = MPLS_LIST_HEAD(&session->adj_root);
2025 while (adj) {
2026 if (this_one == MPLS_BOOL_TRUE) {
2027 adj_next = adj;
2028 break;
2029 }
2030
2031 /* since the entities are sort in the list ... */
2032 if (adj->index > s->adj_index) {
2033 break;
2034 } else if (adj->index == s->adj_index) {
2035 this_one = MPLS_BOOL_TRUE;
2036 }
2037 adj = MPLS_LIST_NEXT(&session->adj_root, adj, _session);
2038 }
2039 }
2040 mpls_lock_release(g->global_lock); /* UNLOCK */
2041
2042 if (adj_next) {
2043 s->adj_index = adj_next->index;
2044 r = MPLS_SUCCESS;
2045 }
2046
2047 LDP_EXIT(g->user_data, "ldp_cfg_session_adj_getnext");
2048 return r;
2049 }
2050
2051 mpls_return_enum ldp_cfg_session_raddr_get(mpls_cfg_handle handle,
2052 ldp_session * s, ldp_addr * a, uint32_t flag)
2053 {
2054 ldp_global *global = (ldp_global *) handle;
2055 ldp_session *session = NULL;
2056 ldp_addr *addr = NULL;
2057 mpls_return_enum retval = MPLS_FAILURE;
2058
2059 MPLS_ASSERT(global !=NULL && s != NULL && a != NULL);
2060
2061 LDP_ENTER(global->user_data, "ldp_cfg_session_raddr_get");
2062
2063 mpls_lock_get(global->global_lock); /* LOCK */
2064
2065 if (ldp_global_find_session_index(global, s->index, &session) != MPLS_SUCCESS)
2066 goto ldp_cfg_session_raddr_get_end;
2067
2068 if (ldp_session_find_raddr_index(session, a->index, &addr) != MPLS_SUCCESS)
2069 goto ldp_cfg_session_raddr_get_end;
2070
2071 if (flag & LDP_SESSION_RADDR_CFG_ADDR) {
2072 memcpy(&a->address,&addr->address,sizeof(struct mpls_inet_addr));
2073 }
2074 if (flag & LDP_SESSION_RADDR_CFG_INDEX) {
2075 a->index = addr->index;
2076 }
2077 retval = MPLS_SUCCESS;
2078
2079 ldp_cfg_session_raddr_get_end:
2080 mpls_lock_release(global->global_lock); /* UNLOCK */
2081
2082 LDP_EXIT(global->user_data, "ldp_cfg_session_raddr_get");
2083
2084 return retval;
2085 }
2086
2087 mpls_return_enum ldp_cfg_session_raddr_getnext(mpls_cfg_handle handle,
2088 ldp_session * s, ldp_addr * a, uint32_t flag)
2089 {
2090 ldp_global *g = (ldp_global *) handle;
2091 ldp_addr *addr = NULL;
2092 mpls_return_enum r = MPLS_FAILURE;
2093 mpls_bool done = MPLS_BOOL_FALSE;
2094 ldp_session *sp = NULL;
2095 int index;
2096
2097 LDP_ENTER(g->user_data, "ldp_cfg_session_raddr_getnext");
2098
2099 if (a->index == 0) {
2100 index = 1;
2101 } else {
2102 index = a->index + 1;
2103 }
2104
2105 r = ldp_global_find_session_index(g, s->index, &sp);
2106 if (r != MPLS_SUCCESS) {
2107 return r;
2108 }
2109
2110 mpls_lock_get(g->global_lock); /* LOCK */
2111 while (done == MPLS_BOOL_FALSE) {
2112 switch ((r = ldp_session_find_raddr_index(sp, index, &addr))) {
2113 case MPLS_SUCCESS:
2114 case MPLS_END_OF_LIST:
2115 done = MPLS_BOOL_TRUE;
2116 break;
2117 case MPLS_FAILURE:
2118 break;
2119 default:
2120 MPLS_ASSERT(0);
2121 }
2122 index++;
2123 }
2124 mpls_lock_release(g->global_lock); /* UNLOCK */
2125
2126 if (r == MPLS_SUCCESS) {
2127 a->index = addr->index;
2128 r = ldp_cfg_session_raddr_get(handle, sp, a, flag);
2129 }
2130
2131 LDP_EXIT(g->user_data, "ldp_cfg_session_getnext");
2132 return r;
2133 }
2134
2135 /******************* IN LABEL **********************/
2136
2137 mpls_return_enum ldp_cfg_inlabel_get(mpls_cfg_handle handle, ldp_inlabel * i,
2138 uint32_t flag)
2139 {
2140 ldp_global *global = (ldp_global *) handle;
2141 ldp_inlabel *inlabel = NULL;
2142 mpls_return_enum retval = MPLS_FAILURE;
2143
2144 MPLS_ASSERT(global !=NULL && i != NULL);
2145
2146 LDP_ENTER(global->user_data, "ldp_cfg_inlabel_get");
2147
2148 mpls_lock_get(global->global_lock); /* LOCK */
2149
2150 if (ldp_global_find_inlabel_index(global, i->index, &inlabel) != MPLS_SUCCESS)
2151 goto ldp_cfg_inlabel_get_end;
2152
2153 if (flag & LDP_INLABEL_CFG_LABELSPACE) {
2154 i->info.labelspace = inlabel->info.labelspace;
2155 }
2156 if (flag & LDP_INLABEL_CFG_LABEL) {
2157 memcpy(&i->info.label, &inlabel->info.label, sizeof(mpls_label_struct));
2158 }
2159 if (flag & LDP_INLABEL_CFG_OUTLABEL_INDEX) {
2160 i->outlabel_index = (inlabel->outlabel) ? (inlabel->outlabel->index) : 0;
2161 }
2162
2163 retval = MPLS_SUCCESS;
2164
2165 ldp_cfg_inlabel_get_end:
2166 mpls_lock_release(global->global_lock); /* UNLOCK */
2167
2168 LDP_EXIT(global->user_data, "ldp_cfg_inlabel_get");
2169
2170 return retval;
2171 }
2172
2173 mpls_return_enum ldp_cfg_inlabel_getnext(mpls_cfg_handle handle, ldp_inlabel * i,
2174 uint32_t flag)
2175 {
2176 ldp_global *g = (ldp_global *) handle;
2177 ldp_inlabel *inlabel = NULL;
2178 mpls_return_enum r = MPLS_FAILURE;
2179 mpls_bool done = MPLS_BOOL_FALSE;
2180 int index;
2181
2182 LDP_ENTER(g->user_data, "ldp_cfg_inlabel_getnext");
2183
2184 if (i->index == 0) {
2185 index = 1;
2186 } else {
2187 index = i->index + 1;
2188 }
2189
2190 mpls_lock_get(g->global_lock); /* LOCK */
2191 while (done == MPLS_BOOL_FALSE) {
2192 switch ((r = ldp_global_find_inlabel_index(g, index, &inlabel))) {
2193 case MPLS_SUCCESS:
2194 case MPLS_END_OF_LIST:
2195 done = MPLS_BOOL_TRUE;
2196 break;
2197 case MPLS_FAILURE:
2198 break;
2199 default:
2200 MPLS_ASSERT(0);
2201 }
2202 index++;
2203 }
2204 mpls_lock_release(g->global_lock); /* UNLOCK */
2205
2206 if (r == MPLS_SUCCESS) {
2207 i->index = inlabel->index;
2208
2209 LDP_EXIT(g->user_data, "ldp_cfg_inlabel_getnext");
2210 return ldp_cfg_inlabel_get(g, i, flag);
2211 }
2212
2213 LDP_EXIT(g->user_data, "ldp_cfg_inlabel_getnext");
2214
2215 return r;
2216 }
2217
2218 /******************* OUT LABEL **********************/
2219
2220 mpls_return_enum ldp_cfg_outlabel_get(mpls_cfg_handle handle, ldp_outlabel * o,
2221 uint32_t flag)
2222 {
2223 ldp_global *global = (ldp_global *) handle;
2224 ldp_outlabel *outlabel = NULL;
2225 mpls_return_enum retval = MPLS_FAILURE;
2226
2227 MPLS_ASSERT(global !=NULL && o != NULL);
2228
2229 LDP_ENTER(global->user_data, "ldp_cfg_outlabel_get");
2230
2231 mpls_lock_get(global->global_lock); /* LOCK */
2232
2233 if (ldp_global_find_outlabel_index(global, o->index,
2234 &outlabel) != MPLS_SUCCESS) goto ldp_cfg_outlabel_get_end;
2235
2236 if (flag & LDP_OUTLABEL_CFG_NH_INDEX) {
2237 if (outlabel->nh) {
2238 o->nh_index = outlabel->nh->index;
2239 } else {
2240 o->nh_index = 0;
2241 }
2242 }
2243 if (flag & LDP_OUTLABEL_CFG_SESSION_INDEX) {
2244 o->session_index = (outlabel->session) ? (outlabel->session->index) : 0;
2245 }
2246 if (flag & LDP_OUTLABEL_CFG_LABEL) {
2247 memcpy(&o->info.label, &outlabel->info.label, sizeof(mpls_label_struct));
2248 }
2249 if (flag & LDP_OUTLABEL_CFG_MERGE_COUNT) {
2250 o->merge_count = outlabel->merge_count;
2251 }
2252
2253 retval = MPLS_SUCCESS;
2254
2255 ldp_cfg_outlabel_get_end:
2256 mpls_lock_release(global->global_lock); /* UNLOCK */
2257
2258 LDP_EXIT(global->user_data, "ldp_cfg_outlabel_get");
2259
2260 return retval;
2261 }
2262
2263 mpls_return_enum ldp_cfg_outlabel_getnext(mpls_cfg_handle handle,
2264 ldp_outlabel * o, uint32_t flag)
2265 {
2266 ldp_global *g = (ldp_global *) handle;
2267 ldp_outlabel *outlabel = NULL;
2268 mpls_return_enum r = MPLS_FAILURE;
2269 mpls_bool done = MPLS_BOOL_FALSE;
2270 int index;
2271
2272 LDP_ENTER(g->user_data, "ldp_cfg_outlabel_getnext");
2273
2274 if (o->index == 0) {
2275 index = 1;
2276 } else {
2277 index = o->index + 1;
2278 }
2279
2280 mpls_lock_get(g->global_lock); /* LOCK */
2281 while (done == MPLS_BOOL_FALSE) {
2282 switch ((r = ldp_global_find_outlabel_index(g, index, &outlabel))) {
2283 case MPLS_SUCCESS:
2284 case MPLS_END_OF_LIST:
2285 done = MPLS_BOOL_TRUE;
2286 break;
2287 case MPLS_FAILURE:
2288 break;
2289 default:
2290 MPLS_ASSERT(0);
2291 }
2292 index++;
2293 }
2294 mpls_lock_release(g->global_lock); /* UNLOCK */
2295
2296 if (r == MPLS_SUCCESS) {
2297 o->index = outlabel->index;
2298
2299 LDP_EXIT(g->user_data, "ldp_cfg_outlabel_getnext");
2300 return ldp_cfg_outlabel_get(g, o, flag);
2301 }
2302
2303 LDP_EXIT(g->user_data, "ldp_cfg_outlabel_getnext");
2304
2305 return r;
2306 }
2307
2308 /******************* TUNNEL **********************/
2309
2310 mpls_return_enum ldp_cfg_tunnel_set(mpls_cfg_handle handle, ldp_tunnel * t,
2311 uint32_t flag)
2312 {
2313 ldp_global *global = (ldp_global *) handle;
2314 mpls_return_enum retval = MPLS_FAILURE;
2315 ldp_tunnel *tunnel = NULL;
2316
2317 MPLS_ASSERT(global !=NULL);
2318
2319 LDP_ENTER(global->user_data, "ldp_cfg_tunnel_set");
2320
2321 mpls_lock_get(global->global_lock); /* LOCK */
2322
2323 if (flag & LDP_CFG_ADD) {
2324 if (!(tunnel = ldp_tunnel_create())) {
2325 goto ldp_cfg_tunnel_set_end;
2326 }
2327 _ldp_global_add_tunnel(global, tunnel);
2328
2329 t->index = tunnel->index;
2330 } else {
2331 ldp_global_find_tunnel_index(global, t->index, &tunnel);
2332 }
2333
2334 if (!tunnel) {
2335 LDP_PRINT(global->user_data,
2336
2337 "ldp_cfg_tunnel_set:could not create tunnel\n");
2338 goto ldp_cfg_tunnel_set_end;
2339 }
2340
2341 if ((ldp_tunnel_is_active(tunnel) == MPLS_BOOL_TRUE) &&
2342 (flag & LDP_TUNNEL_CFG_WHEN_DOWN)) {
2343 LDP_PRINT(global->user_data, "ldp_cfg_tunnel_set: tunnel is active\n");
2344
2345 goto ldp_cfg_tunnel_set_end;
2346 }
2347
2348 if (flag & LDP_CFG_DEL) {
2349 if (tunnel->outlabel)
2350 ldp_tunnel_del_outlabel(tunnel);
2351 if (tunnel->resource)
2352 ldp_tunnel_del_resource(tunnel);
2353 if (tunnel->hop_list)
2354 ldp_tunnel_del_hop_list(tunnel);
2355 _ldp_global_del_tunnel(global, tunnel);
2356
2357 retval = MPLS_SUCCESS;
2358 goto ldp_cfg_tunnel_set_end;
2359 }
2360
2361 if (flag & LDP_TUNNEL_CFG_INGRESS) {
2362 memcpy(&tunnel->ingress_lsrid, &t->ingress_lsrid, sizeof(ldp_addr));
2363 }
2364 if (flag & LDP_TUNNEL_CFG_EGRESS) {
2365 memcpy(&tunnel->egress_lsrid, &t->egress_lsrid, sizeof(ldp_addr));
2366 }
2367 if (flag & LDP_TUNNEL_CFG_NAME) {
2368 memcpy(&tunnel->name, &t->name, MPLS_MAX_IF_NAME);
2369 }
2370 if (flag & LDP_TUNNEL_CFG_IS_IF) {
2371 tunnel->is_interface = t->is_interface;
2372 }
2373 if (flag & LDP_TUNNEL_CFG_OUTLABEL) {
2374 ldp_outlabel *outlabel = NULL;
2375
2376 if (t->outlabel_index) {
2377 ldp_global_find_outlabel_index(global, t->outlabel_index, &outlabel);
2378
2379 if (!outlabel) {
2380 goto ldp_cfg_tunnel_set_end;
2381 }
2382 ldp_tunnel_add_outlabel(tunnel, outlabel);
2383 } else {
2384 ldp_tunnel_del_outlabel(tunnel);
2385 }
2386 }
2387 if (flag & LDP_TUNNEL_CFG_SETUP_PRIO) {
2388 tunnel->setup_prio = t->setup_prio;
2389 }
2390 if (flag & LDP_TUNNEL_CFG_HOLD_PRIO) {
2391 tunnel->hold_prio = t->hold_prio;
2392 }
2393 if (flag & LDP_TUNNEL_CFG_INSTANCE_PRIO) {
2394 tunnel->instance_prio = t->instance_prio;
2395 }
2396 if (flag & LDP_TUNNEL_CFG_LOCAL_PROTECT) {
2397 tunnel->local_protect = t->local_protect;
2398 }
2399 if (flag & LDP_TUNNEL_CFG_RESOURCE_INDEX) {
2400 ldp_resource *resource = NULL;
2401
2402 if (t->resource_index) {
2403 ldp_global_find_resource_index(global, t->resource_index, &resource);
2404
2405 if (!resource) {
2406 goto ldp_cfg_tunnel_set_end;
2407 }
2408 ldp_tunnel_add_resource(tunnel, resource);
2409 } else {
2410 ldp_tunnel_del_resource(tunnel);
2411 }
2412 }
2413 if (flag & LDP_TUNNEL_CFG_HOP_LIST_INDEX) {
2414 ldp_hop_list *hop_list = NULL;
2415
2416 if (t->hop_list_index) {
2417 ldp_global_find_hop_list_index(global, t->hop_list_index, &hop_list);
2418
2419 if (!hop_list) {
2420 goto ldp_cfg_tunnel_set_end;
2421 }
2422 ldp_tunnel_add_hop_list(tunnel, hop_list);
2423 } else {
2424 ldp_tunnel_del_hop_list(tunnel);
2425 }
2426 }
2427 if (flag & LDP_TUNNEL_CFG_FEC) {
2428 memcpy(&tunnel->fec, &t->fec, sizeof(ldp_fec));
2429 }
2430 if (flag & LDP_TUNNEL_CFG_ADMIN_STATE) {
2431 if (ldp_tunnel_is_active(tunnel) == MPLS_BOOL_TRUE) {
2432 if (t->admin_state == MPLS_ADMIN_DISABLE) {
2433 if (ldp_tunnel_shutdown(global, tunnel, 0) == MPLS_FAILURE) {
2434 goto ldp_cfg_tunnel_set_end;
2435 }
2436 }
2437 } else {
2438 if (t->admin_state == MPLS_ADMIN_ENABLE) {
2439 if (ldp_tunnel_is_ready(tunnel) == MPLS_BOOL_TRUE) {
2440 if (ldp_tunnel_startup(global, tunnel) == MPLS_FAILURE) {
2441 goto ldp_cfg_tunnel_set_end;
2442 }
2443 } else {
2444 LDP_PRINT(global->user_data,
2445
2446 "ldp_cfg_tunnel_set: tunnel not ready\n");
2447 goto ldp_cfg_tunnel_set_end;
2448 }
2449 }
2450 }
2451 }
2452 retval = MPLS_SUCCESS;
2453
2454 ldp_cfg_tunnel_set_end:
2455
2456 mpls_lock_release(global->global_lock); /* UNLOCK */
2457
2458 LDP_EXIT(global->user_data, "ldp_cfg_tunnel_set");
2459
2460 return retval;
2461 }
2462
2463 mpls_return_enum ldp_cfg_tunnel_test(mpls_cfg_handle handle, ldp_tunnel * t,
2464 uint32_t flag)
2465 {
2466 ldp_global *global = (ldp_global *) handle;
2467 mpls_return_enum retval = MPLS_FAILURE;
2468 ldp_tunnel *tunnel = NULL;
2469
2470 MPLS_ASSERT(global !=NULL);
2471
2472 LDP_ENTER(global->user_data, "ldp_cfg_tunnel_test");
2473
2474 mpls_lock_get(global->global_lock); /* LOCK */
2475
2476 if (flag & LDP_CFG_ADD) {
2477 retval = MPLS_SUCCESS;
2478 goto ldp_cfg_tunnel_test_end;
2479 }
2480
2481 ldp_global_find_tunnel_index(global, t->index, &tunnel);
2482
2483 if (!tunnel) {
2484 goto ldp_cfg_tunnel_test_end;
2485 }
2486
2487 if (flag & LDP_TUNNEL_CFG_RESOURCE_INDEX) {
2488 ldp_resource *resource = NULL;
2489
2490 if (t->resource_index) {
2491 ldp_global_find_resource_index(global, t->resource_index, &resource);
2492
2493 if (!resource) {
2494 goto ldp_cfg_tunnel_test_end;
2495 }
2496 }
2497 }
2498 if (flag & LDP_TUNNEL_CFG_HOP_LIST_INDEX) {
2499 ldp_hop_list *hop_list = NULL;
2500
2501 if (t->hop_list_index) {
2502 ldp_global_find_hop_list_index(global, t->hop_list_index, &hop_list);
2503
2504 if (!hop_list) {
2505 goto ldp_cfg_tunnel_test_end;
2506 }
2507 }
2508 }
2509 if (flag & LDP_TUNNEL_CFG_OUTLABEL) {
2510 ldp_outlabel *outlabel = NULL;
2511
2512 if (t->outlabel_index) {
2513 ldp_global_find_outlabel_index(global, t->outlabel_index, &outlabel);
2514
2515 if (!outlabel) {
2516 goto ldp_cfg_tunnel_test_end;
2517 }
2518 }
2519 }
2520 if ((flag & LDP_TUNNEL_CFG_ADMIN_STATE) &&
2521 (ldp_tunnel_is_active(tunnel) == MPLS_BOOL_FALSE) &&
2522 (t->admin_state == MPLS_ADMIN_ENABLE) && (ldp_tunnel_is_ready(tunnel) != MPLS_BOOL_TRUE)) {
2523 goto ldp_cfg_tunnel_test_end;
2524 }
2525 retval = MPLS_SUCCESS;
2526
2527 ldp_cfg_tunnel_test_end:
2528
2529 mpls_lock_release(global->global_lock); /* UNLOCK */
2530
2531 LDP_EXIT(global->user_data, "ldp_cfg_tunnel_test");
2532
2533 return retval;
2534 }
2535
2536 mpls_return_enum ldp_cfg_tunnel_get(mpls_cfg_handle handle, ldp_tunnel * t,
2537 uint32_t flag)
2538 {
2539 ldp_global *global = (ldp_global *) handle;
2540 mpls_return_enum retval = MPLS_FAILURE;
2541 ldp_tunnel *tunnel = NULL;
2542
2543 MPLS_ASSERT(global !=NULL);
2544
2545 LDP_ENTER(global->user_data, "ldp_cfg_tunnel_get");
2546
2547 mpls_lock_get(global->global_lock); /* LOCK */
2548
2549 ldp_global_find_tunnel_index(global, t->index, &tunnel);
2550
2551 if (!tunnel) {
2552 goto ldp_cfg_tunnel_get_end;
2553 }
2554 if (flag & LDP_TUNNEL_CFG_INGRESS) {
2555 memcpy(&t->ingress_lsrid, &tunnel->ingress_lsrid, sizeof(ldp_addr));
2556 }
2557 if (flag & LDP_TUNNEL_CFG_EGRESS) {
2558 memcpy(&t->egress_lsrid, &tunnel->egress_lsrid, sizeof(ldp_addr));
2559 }
2560 if (flag & LDP_TUNNEL_CFG_NAME) {
2561 memcpy(&t->name, &tunnel->name, MPLS_MAX_IF_NAME);
2562 }
2563 if (flag & LDP_TUNNEL_CFG_IS_IF) {
2564 t->is_interface = tunnel->is_interface;
2565 }
2566 if (flag & LDP_TUNNEL_CFG_OUTLABEL) {
2567 if (tunnel->outlabel) {
2568 t->outlabel_index = tunnel->outlabel->index;
2569 } else {
2570 t->outlabel_index = 0;
2571 }
2572 }
2573 if (flag & LDP_TUNNEL_CFG_SETUP_PRIO) {
2574 t->setup_prio = tunnel->setup_prio;
2575 }
2576 if (flag & LDP_TUNNEL_CFG_HOLD_PRIO) {
2577 t->hold_prio = tunnel->hold_prio;
2578 }
2579 if (flag & LDP_TUNNEL_CFG_INSTANCE_PRIO) {
2580 tunnel->instance_prio = t->instance_prio;
2581 }
2582 if (flag & LDP_TUNNEL_CFG_LOCAL_PROTECT) {
2583 tunnel->local_protect = t->local_protect;
2584 }
2585 if (flag & LDP_TUNNEL_CFG_RESOURCE_INDEX) {
2586 if (tunnel->resource) {
2587 t->resource_index = tunnel->resource->index;
2588 } else {
2589 t->resource_index = 0;
2590 }
2591 }
2592 if (flag & LDP_TUNNEL_CFG_HOP_LIST_INDEX) {
2593 if (tunnel->hop_list) {
2594 t->hop_list_index = tunnel->hop_list->index;
2595 } else {
2596 t->hop_list_index = 0;
2597 }
2598 }
2599 if (flag & LDP_TUNNEL_CFG_FEC) {
2600 memcpy(&t->fec, &tunnel->fec, sizeof(ldp_fec));
2601 }
2602 if (flag & LDP_TUNNEL_CFG_ADMIN_STATE) {
2603 t->admin_state = tunnel->admin_state;
2604 }
2605 retval = MPLS_SUCCESS;
2606
2607 ldp_cfg_tunnel_get_end:
2608
2609 mpls_lock_release(global->global_lock); /* UNLOCK */
2610
2611 LDP_EXIT(global->user_data, "ldp_cfg_tunnel_get");
2612
2613 return retval;
2614 }
2615
2616 /******************* RESOURCE **********************/
2617
2618 mpls_return_enum ldp_cfg_resource_set(mpls_cfg_handle handle, ldp_resource * r,
2619 uint32_t flag)
2620 {
2621 ldp_global *global = (ldp_global *) handle;
2622 mpls_return_enum retval = MPLS_FAILURE;
2623 ldp_resource *resource = NULL;
2624
2625 MPLS_ASSERT(global !=NULL);
2626
2627 LDP_ENTER(global->user_data, "ldp_cfg_resource_set");
2628
2629 mpls_lock_get(global->global_lock); /* LOCK */
2630
2631 if (flag & LDP_CFG_ADD) {
2632 resource = ldp_resource_create();
2633 _ldp_global_add_resource(global, resource);
2634
2635 r->index = resource->index;
2636 } else {
2637 ldp_global_find_resource_index(global, r->index, &resource);
2638 }
2639
2640 if (!resource) {
2641 goto ldp_cfg_resource_set_end;
2642 }
2643
2644 if (flag & LDP_RESOURCE_CFG_MAXBPS) {
2645 resource->max_rate = r->max_rate;
2646 }
2647 if (flag & LDP_RESOURCE_CFG_MEANBPS) {
2648 resource->mean_rate = r->mean_rate;
2649 }
2650 if (flag & LDP_RESOURCE_CFG_BURSTSIZE) {
2651 resource->burst_size = r->burst_size;
2652 }
2653 retval = MPLS_SUCCESS;
2654
2655 ldp_cfg_resource_set_end:
2656
2657 mpls_lock_release(global->global_lock); /* UNLOCK */
2658
2659 LDP_EXIT(global->user_data, "ldp_cfg_resource_set");
2660
2661 return retval;
2662 }
2663
2664 mpls_return_enum ldp_cfg_resource_test(mpls_cfg_handle handle, ldp_resource * r,
2665 uint32_t flag)
2666 {
2667 ldp_global *global = (ldp_global *) handle;
2668 mpls_return_enum retval = MPLS_FAILURE;
2669 ldp_resource *resource = NULL;
2670
2671 MPLS_ASSERT(global !=NULL);
2672
2673 LDP_ENTER(global->user_data, "ldp_cfg_resource_test");
2674
2675 mpls_lock_get(global->global_lock); /* LOCK */
2676
2677 if (flag & LDP_CFG_ADD) {
2678 retval = MPLS_SUCCESS;
2679 goto ldp_cfg_resource_test_end;
2680 }
2681
2682 ldp_global_find_resource_index(global, r->index, &resource);
2683
2684 if (!resource) {
2685 goto ldp_cfg_resource_test_end;
2686 }
2687
2688 if (ldp_resource_in_use(resource) == MPLS_BOOL_TRUE) {
2689 goto ldp_cfg_resource_test_end;
2690 }
2691 retval = MPLS_SUCCESS;
2692
2693 ldp_cfg_resource_test_end:
2694
2695 mpls_lock_release(global->global_lock); /* UNLOCK */
2696
2697 LDP_EXIT(global->user_data, "ldp_cfg_resource_test");
2698
2699 return retval;
2700 }
2701
2702 mpls_return_enum ldp_cfg_resource_get(mpls_cfg_handle handle, ldp_resource * r,
2703 uint32_t flag)
2704 {
2705 ldp_global *global = (ldp_global *) handle;
2706 mpls_return_enum retval = MPLS_FAILURE;
2707 ldp_resource *resource = NULL;
2708
2709 MPLS_ASSERT(global !=NULL);
2710
2711 LDP_ENTER(global->user_data, "ldp_cfg_resource_get");
2712
2713 mpls_lock_get(global->global_lock); /* LOCK */
2714
2715 ldp_global_find_resource_index(global, r->index, &resource);
2716
2717 if (!resource) {
2718 goto ldp_cfg_resource_get_end;
2719 }
2720
2721 if (flag & LDP_RESOURCE_CFG_MAXBPS) {
2722 r->max_rate = resource->max_rate;
2723 }
2724 if (flag & LDP_RESOURCE_CFG_MEANBPS) {
2725 r->mean_rate = resource->mean_rate;
2726 }
2727 if (flag & LDP_RESOURCE_CFG_BURSTSIZE) {
2728 r->burst_size = resource->burst_size;
2729 }
2730 retval = MPLS_SUCCESS;
2731
2732 ldp_cfg_resource_get_end:
2733
2734 mpls_lock_release(global->global_lock); /* UNLOCK */
2735
2736 LDP_EXIT(global->user_data, "ldp_cfg_resource_get");
2737
2738 return retval;
2739 }
2740
2741 /******************* HOP **********************/
2742
2743 mpls_return_enum ldp_cfg_hop_set(mpls_cfg_handle handle, ldp_hop * h,
2744 uint32_t flag)
2745 {
2746 ldp_global *global = (ldp_global *) handle;
2747 mpls_return_enum retval = MPLS_FAILURE;
2748 ldp_hop_list *hop_list = NULL;
2749 ldp_hop *hop = NULL;
2750
2751 MPLS_ASSERT(global !=NULL);
2752
2753 LDP_ENTER(global->user_data, "ldp_cfg_hop_set");
2754
2755 if (!h->hop_list_index && !h->index) {
2756 return retval;
2757 }
2758
2759 mpls_lock_get(global->global_lock); /* LOCK */
2760
2761 ldp_global_find_hop_list_index(global, h->hop_list_index, &hop_list);
2762
2763 if (!hop_list) {
2764 if (flag & LDP_CFG_ADD) {
2765 if (!(hop_list = ldp_hop_list_create())) {
2766 goto ldp_cfg_hop_set_end;
2767 }
2768 _ldp_global_add_hop_list(global, hop_list);
2769
2770 h->hop_list_index = hop_list->index;
2771 } else {
2772 goto ldp_cfg_hop_set_end;
2773 }
2774 }
2775
2776 ldp_hop_list_find_hop_index(hop_list, h->index, &hop);
2777 if (!hop) {
2778 if (h->index && (flag & LDP_CFG_ADD)) {
2779 if (!(hop = ldp_hop_create())) {
2780 goto ldp_cfg_hop_set_end;
2781 }
2782 hop->index = h->index;
2783 ldp_hop_list_add_hop(hop_list, hop);
2784 } else {
2785 goto ldp_cfg_hop_set_end;
2786 }
2787 }
2788
2789 if (flag & LDP_HOP_CFG_PATH_OPTION) {
2790 hop->path_option = h->path_option;
2791 }
2792 if (flag & LDP_HOP_CFG_ADDR) {
2793 memcpy(&hop->addr, &h->addr, sizeof(ldp_addr));
2794 }
2795 if (flag & LDP_HOP_CFG_TYPE) {
2796 hop->type = h->type;
2797 }
2798 retval = MPLS_SUCCESS;
2799
2800 ldp_cfg_hop_set_end:
2801
2802 mpls_lock_release(global->global_lock); /* UNLOCK */
2803
2804 LDP_EXIT(global->user_data, "ldp_cfg_hop_set");
2805
2806 return retval;
2807 }
2808
2809 mpls_return_enum ldp_cfg_hop_test(mpls_cfg_handle handle, ldp_hop * h,
2810 uint32_t flag)
2811 {
2812 ldp_global *global = (ldp_global *) handle;
2813 mpls_return_enum retval = MPLS_FAILURE;
2814 ldp_hop_list *hop_list = NULL;
2815 ldp_hop *hop = NULL;
2816
2817 MPLS_ASSERT(global !=NULL);
2818
2819 LDP_ENTER(global->user_data, "ldp_cfg_hop_test");
2820
2821 mpls_lock_get(global->global_lock); /* LOCK */
2822
2823 if (flag & LDP_CFG_ADD) {
2824 retval = MPLS_SUCCESS;
2825 goto ldp_cfg_hop_test_end;
2826 }
2827
2828 ldp_global_find_hop_list_index(global, h->hop_list_index, &hop_list);
2829
2830 if (!hop_list) {
2831 goto ldp_cfg_hop_test_end;
2832 }
2833
2834 ldp_hop_list_find_hop_index(hop_list, h->index, &hop);
2835 if (!hop) {
2836 goto ldp_cfg_hop_test_end;
2837 }
2838
2839 if (ldp_hop_in_use(hop) == MPLS_BOOL_TRUE) {
2840 goto ldp_cfg_hop_test_end;
2841 }
2842 retval = MPLS_SUCCESS;
2843
2844 ldp_cfg_hop_test_end:
2845
2846 mpls_lock_release(global->global_lock); /* UNLOCK */
2847
2848 LDP_EXIT(global->user_data, "ldp_cfg_hop_test");
2849
2850 return retval;
2851 }
2852
2853 mpls_return_enum ldp_cfg_hop_get(mpls_cfg_handle handle, ldp_hop * h,
2854 uint32_t flag)
2855 {
2856 ldp_global *global = (ldp_global *) handle;
2857 mpls_return_enum retval = MPLS_FAILURE;
2858 ldp_hop_list *hop_list = NULL;
2859 ldp_hop *hop = NULL;
2860
2861 MPLS_ASSERT(global !=NULL);
2862
2863 LDP_ENTER(global->user_data, "ldp_cfg_hop_get");
2864
2865 mpls_lock_get(global->global_lock); /* LOCK */
2866
2867 ldp_global_find_hop_list_index(global, h->hop_list_index, &hop_list);
2868
2869 if (!hop_list) {
2870 goto ldp_cfg_hop_get_end;
2871 }
2872
2873 ldp_hop_list_find_hop_index(hop_list, h->index, &hop);
2874 if (!hop) {
2875 goto ldp_cfg_hop_get_end;
2876 }
2877
2878 if (flag & LDP_HOP_CFG_PATH_OPTION) {
2879 h->path_option = hop->path_option;
2880 }
2881 if (flag & LDP_HOP_CFG_ADDR) {
2882 memcpy(&h->addr, &hop->addr, sizeof(ldp_addr));
2883 }
2884 if (flag & LDP_HOP_CFG_TYPE) {
2885 h->type = hop->type;
2886 }
2887 retval = MPLS_SUCCESS;
2888
2889 ldp_cfg_hop_get_end:
2890
2891 mpls_lock_release(global->global_lock); /* UNLOCK */
2892
2893 LDP_EXIT(global->user_data, "ldp_cfg_hop_get");
2894
2895 return retval;
2896 }
Portable Implementation of RFC3036