]>
Commit | Line | Data |
---|---|---|
6c574029 RW |
1 | /* |
2 | * BFD daemon northbound implementation. | |
3 | * | |
4 | * Copyright (C) 2019 Network Device Education Foundation, Inc. ("NetDEF") | |
5 | * Rafael Zalamena | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with this program; if not, write to the Free Software | |
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
20 | * 02110-1301 USA. | |
21 | */ | |
22 | ||
23 | #include <zebra.h> | |
24 | ||
25 | #include "lib/log.h" | |
26 | #include "lib/northbound.h" | |
27 | ||
28 | #include "bfd.h" | |
29 | #include "bfdd_nb.h" | |
30 | ||
31 | /* | |
32 | * Helpers. | |
33 | */ | |
34 | static void bfd_session_get_key(bool mhop, const struct lyd_node *dnode, | |
35 | struct bfd_key *bk) | |
36 | { | |
37 | const char *ifname = NULL, *vrfname = NULL; | |
38 | struct sockaddr_any psa, lsa; | |
39 | ||
40 | /* Required destination parameter. */ | |
41 | strtosa(yang_dnode_get_string(dnode, "./dest-addr"), &psa); | |
42 | ||
43 | /* Get optional source address. */ | |
44 | memset(&lsa, 0, sizeof(lsa)); | |
45 | if (yang_dnode_exists(dnode, "./source-addr")) | |
46 | strtosa(yang_dnode_get_string(dnode, "./source-addr"), &lsa); | |
47 | ||
2e8d2925 | 48 | vrfname = yang_dnode_get_string(dnode, "./vrf"); |
6c574029 | 49 | |
874ca769 IR |
50 | if (!mhop) { |
51 | ifname = yang_dnode_get_string(dnode, "./interface"); | |
52 | if (strcmp(ifname, "*") == 0) | |
53 | ifname = NULL; | |
54 | } | |
4ec8e74b | 55 | |
6c574029 RW |
56 | /* Generate the corresponding key. */ |
57 | gen_bfd_key(bk, &psa, &lsa, mhop, ifname, vrfname); | |
58 | } | |
59 | ||
632f3610 IR |
60 | struct session_iter { |
61 | int count; | |
62 | bool wildcard; | |
63 | }; | |
64 | ||
65 | static int session_iter_cb(const struct lyd_node *dnode, void *arg) | |
66 | { | |
67 | struct session_iter *iter = arg; | |
68 | const char *ifname; | |
69 | ||
70 | ifname = yang_dnode_get_string(dnode, "./interface"); | |
71 | ||
72 | if (strmatch(ifname, "*")) | |
73 | iter->wildcard = true; | |
74 | ||
75 | iter->count++; | |
76 | ||
77 | return YANG_ITER_CONTINUE; | |
78 | } | |
79 | ||
5e4d0fbc | 80 | static int bfd_session_create(struct nb_cb_create_args *args, bool mhop) |
6c574029 | 81 | { |
632f3610 IR |
82 | const struct lyd_node *sess_dnode; |
83 | struct session_iter iter; | |
6c574029 | 84 | struct bfd_session *bs; |
632f3610 | 85 | const char *dest; |
6c574029 | 86 | const char *ifname; |
632f3610 | 87 | const char *vrfname; |
6c574029 RW |
88 | struct bfd_key bk; |
89 | struct prefix p; | |
90 | ||
5e4d0fbc | 91 | switch (args->event) { |
6c574029 | 92 | case NB_EV_VALIDATE: |
874ca769 IR |
93 | yang_dnode_get_prefix(&p, args->dnode, "./dest-addr"); |
94 | ||
95 | if (mhop) { | |
96 | /* | |
97 | * Do not allow IPv6 link-local address for multihop. | |
98 | */ | |
99 | if (p.family == AF_INET6 | |
100 | && IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6)) { | |
101 | snprintf( | |
102 | args->errmsg, args->errmsg_len, | |
103 | "Cannot use link-local address for multihop sessions"); | |
104 | return NB_ERR_VALIDATION; | |
105 | } | |
106 | return NB_OK; | |
107 | } | |
108 | ||
6c574029 RW |
109 | /* |
110 | * When `dest-addr` is IPv6 and link-local we must | |
111 | * require interface name, otherwise we can't figure | |
112 | * which interface to use to send the packets. | |
113 | */ | |
5e4d0fbc | 114 | ifname = yang_dnode_get_string(args->dnode, "./interface"); |
6c574029 RW |
115 | |
116 | if (p.family == AF_INET6 && IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6) | |
4ec8e74b | 117 | && strcmp(ifname, "*") == 0) { |
5e4d0fbc IR |
118 | snprintf( |
119 | args->errmsg, args->errmsg_len, | |
120 | "When using link-local you must specify an interface"); | |
6c574029 RW |
121 | return NB_ERR_VALIDATION; |
122 | } | |
632f3610 IR |
123 | |
124 | iter.count = 0; | |
125 | iter.wildcard = false; | |
126 | ||
127 | sess_dnode = yang_dnode_get_parent(args->dnode, "sessions"); | |
128 | ||
129 | dest = yang_dnode_get_string(args->dnode, "./dest-addr"); | |
130 | vrfname = yang_dnode_get_string(args->dnode, "./vrf"); | |
131 | ||
874ca769 IR |
132 | yang_dnode_iterate(session_iter_cb, &iter, sess_dnode, |
133 | "./single-hop[dest-addr='%s'][vrf='%s']", | |
134 | dest, vrfname); | |
632f3610 IR |
135 | |
136 | if (iter.wildcard && iter.count > 1) { | |
137 | snprintf( | |
138 | args->errmsg, args->errmsg_len, | |
139 | "It is not allowed to configure the same peer with and without ifname"); | |
140 | return NB_ERR_VALIDATION; | |
141 | } | |
6c574029 RW |
142 | break; |
143 | ||
144 | case NB_EV_PREPARE: | |
5e4d0fbc | 145 | bfd_session_get_key(mhop, args->dnode, &bk); |
6c574029 RW |
146 | bs = bfd_key_lookup(bk); |
147 | ||
148 | /* This session was already configured by another daemon. */ | |
149 | if (bs != NULL) { | |
150 | /* Now it is configured also by CLI. */ | |
b88113ef | 151 | SET_FLAG(bs->flags, BFD_SESS_FLAG_CONFIG); |
6c574029 RW |
152 | bs->refcount++; |
153 | ||
5e4d0fbc | 154 | args->resource->ptr = bs; |
6c574029 RW |
155 | break; |
156 | } | |
157 | ||
158 | bs = bfd_session_new(); | |
6c574029 RW |
159 | |
160 | /* Fill the session key. */ | |
5e4d0fbc | 161 | bfd_session_get_key(mhop, args->dnode, &bs->key); |
6c574029 RW |
162 | |
163 | /* Set configuration flags. */ | |
164 | bs->refcount = 1; | |
b88113ef | 165 | SET_FLAG(bs->flags, BFD_SESS_FLAG_CONFIG); |
6c574029 | 166 | if (mhop) |
b88113ef | 167 | SET_FLAG(bs->flags, BFD_SESS_FLAG_MH); |
6c574029 | 168 | if (bs->key.family == AF_INET6) |
b88113ef | 169 | SET_FLAG(bs->flags, BFD_SESS_FLAG_IPV6); |
6c574029 | 170 | |
5e4d0fbc | 171 | args->resource->ptr = bs; |
6c574029 RW |
172 | break; |
173 | ||
174 | case NB_EV_APPLY: | |
5e4d0fbc | 175 | bs = args->resource->ptr; |
6c574029 RW |
176 | |
177 | /* Only attempt to registrate if freshly allocated. */ | |
178 | if (bs->discrs.my_discr == 0 && bs_registrate(bs) == NULL) | |
179 | return NB_ERR_RESOURCE; | |
180 | ||
5e4d0fbc | 181 | nb_running_set_entry(args->dnode, bs); |
6c574029 RW |
182 | break; |
183 | ||
184 | case NB_EV_ABORT: | |
5e4d0fbc | 185 | bs = args->resource->ptr; |
6c574029 | 186 | if (bs->refcount <= 1) |
5e4d0fbc | 187 | bfd_session_free(bs); |
6c574029 RW |
188 | break; |
189 | } | |
190 | ||
191 | return NB_OK; | |
192 | } | |
193 | ||
194 | static int bfd_session_destroy(enum nb_event event, | |
195 | const struct lyd_node *dnode, bool mhop) | |
196 | { | |
197 | struct bfd_session *bs; | |
198 | struct bfd_key bk; | |
199 | ||
200 | switch (event) { | |
201 | case NB_EV_VALIDATE: | |
202 | bfd_session_get_key(mhop, dnode, &bk); | |
203 | if (bfd_key_lookup(bk) == NULL) | |
204 | return NB_ERR_INCONSISTENCY; | |
205 | break; | |
206 | ||
207 | case NB_EV_PREPARE: | |
208 | /* NOTHING */ | |
209 | break; | |
210 | ||
211 | case NB_EV_APPLY: | |
212 | bs = nb_running_unset_entry(dnode); | |
213 | /* CLI is not using this session anymore. */ | |
b88113ef | 214 | if (CHECK_FLAG(bs->flags, BFD_SESS_FLAG_CONFIG) == 0) |
6c574029 RW |
215 | break; |
216 | ||
b88113ef | 217 | UNSET_FLAG(bs->flags, BFD_SESS_FLAG_CONFIG); |
6c574029 RW |
218 | bs->refcount--; |
219 | /* There are still daemons using it. */ | |
220 | if (bs->refcount > 0) | |
221 | break; | |
222 | ||
223 | bfd_session_free(bs); | |
224 | break; | |
225 | ||
226 | case NB_EV_ABORT: | |
227 | /* NOTHING */ | |
228 | break; | |
229 | } | |
230 | ||
231 | return NB_OK; | |
232 | } | |
233 | ||
234 | /* | |
235 | * XPath: /frr-bfdd:bfdd/bfd | |
236 | */ | |
60ee8be1 | 237 | int bfdd_bfd_create(struct nb_cb_create_args *args) |
6c574029 | 238 | { |
f13ad7c5 IR |
239 | if (args->event != NB_EV_APPLY) |
240 | return NB_OK; | |
241 | ||
242 | /* | |
243 | * Set any non-NULL value to be able to call | |
244 | * nb_running_unset_entry in bfdd_bfd_destroy. | |
245 | */ | |
246 | nb_running_set_entry(args->dnode, (void *)0x1); | |
247 | ||
6c574029 RW |
248 | return NB_OK; |
249 | } | |
250 | ||
60ee8be1 | 251 | int bfdd_bfd_destroy(struct nb_cb_destroy_args *args) |
6c574029 | 252 | { |
60ee8be1 | 253 | switch (args->event) { |
6c574029 RW |
254 | case NB_EV_VALIDATE: |
255 | /* NOTHING */ | |
256 | return NB_OK; | |
257 | ||
258 | case NB_EV_PREPARE: | |
259 | /* NOTHING */ | |
260 | return NB_OK; | |
261 | ||
262 | case NB_EV_APPLY: | |
f13ad7c5 IR |
263 | /* |
264 | * We need to call this to unset pointers from | |
265 | * the child nodes - sessions and profiles. | |
266 | */ | |
267 | nb_running_unset_entry(args->dnode); | |
268 | ||
6c574029 | 269 | bfd_sessions_remove_manual(); |
e93c3c00 | 270 | bfd_profiles_remove(); |
6c574029 RW |
271 | break; |
272 | ||
273 | case NB_EV_ABORT: | |
274 | /* NOTHING */ | |
275 | return NB_OK; | |
276 | } | |
277 | ||
278 | return NB_OK; | |
279 | } | |
280 | ||
ccc9ada8 RZ |
281 | /* |
282 | * XPath: /frr-bfdd:bfdd/bfd/profile | |
283 | */ | |
284 | int bfdd_bfd_profile_create(struct nb_cb_create_args *args) | |
285 | { | |
286 | struct bfd_profile *bp; | |
287 | const char *name; | |
288 | ||
289 | if (args->event != NB_EV_APPLY) | |
290 | return NB_OK; | |
291 | ||
292 | name = yang_dnode_get_string(args->dnode, "./name"); | |
293 | bp = bfd_profile_new(name); | |
294 | nb_running_set_entry(args->dnode, bp); | |
295 | ||
296 | return NB_OK; | |
297 | } | |
298 | ||
299 | int bfdd_bfd_profile_destroy(struct nb_cb_destroy_args *args) | |
300 | { | |
301 | struct bfd_profile *bp; | |
302 | ||
303 | if (args->event != NB_EV_APPLY) | |
304 | return NB_OK; | |
305 | ||
306 | bp = nb_running_unset_entry(args->dnode); | |
307 | bfd_profile_free(bp); | |
308 | ||
309 | return NB_OK; | |
310 | } | |
311 | ||
312 | /* | |
313 | * XPath: /frr-bfdd:bfdd/bfd/profile/detection-multiplier | |
314 | */ | |
315 | int bfdd_bfd_profile_detection_multiplier_modify(struct nb_cb_modify_args *args) | |
316 | { | |
317 | struct bfd_profile *bp; | |
318 | ||
319 | if (args->event != NB_EV_APPLY) | |
320 | return NB_OK; | |
321 | ||
322 | bp = nb_running_get_entry(args->dnode, NULL, true); | |
323 | bp->detection_multiplier = yang_dnode_get_uint8(args->dnode, NULL); | |
2975f578 | 324 | bfd_profile_update(bp); |
ccc9ada8 RZ |
325 | |
326 | return NB_OK; | |
327 | } | |
328 | ||
329 | /* | |
330 | * XPath: /frr-bfdd:bfdd/bfd/profile/desired-transmission-interval | |
331 | */ | |
332 | int bfdd_bfd_profile_desired_transmission_interval_modify( | |
333 | struct nb_cb_modify_args *args) | |
334 | { | |
335 | struct bfd_profile *bp; | |
ccc9ada8 RZ |
336 | |
337 | switch (args->event) { | |
338 | case NB_EV_VALIDATE: | |
ccc9ada8 RZ |
339 | break; |
340 | ||
341 | case NB_EV_PREPARE: | |
342 | /* NOTHING */ | |
343 | break; | |
344 | ||
345 | case NB_EV_APPLY: | |
ccc9ada8 | 346 | bp = nb_running_get_entry(args->dnode, NULL, true); |
ebf8b885 | 347 | bp->min_tx = yang_dnode_get_uint32(args->dnode, NULL); |
ccc9ada8 RZ |
348 | bfd_profile_update(bp); |
349 | break; | |
350 | ||
351 | case NB_EV_ABORT: | |
352 | /* NOTHING */ | |
353 | break; | |
354 | } | |
355 | ||
356 | return NB_OK; | |
357 | } | |
358 | ||
359 | /* | |
360 | * XPath: /frr-bfdd:bfdd/bfd/profile/required-receive-interval | |
361 | */ | |
362 | int bfdd_bfd_profile_required_receive_interval_modify( | |
363 | struct nb_cb_modify_args *args) | |
364 | { | |
365 | struct bfd_profile *bp; | |
ccc9ada8 RZ |
366 | |
367 | switch (args->event) { | |
368 | case NB_EV_VALIDATE: | |
ccc9ada8 RZ |
369 | break; |
370 | ||
371 | case NB_EV_PREPARE: | |
372 | /* NOTHING */ | |
373 | break; | |
374 | ||
375 | case NB_EV_APPLY: | |
ccc9ada8 | 376 | bp = nb_running_get_entry(args->dnode, NULL, true); |
ebf8b885 | 377 | bp->min_rx = yang_dnode_get_uint32(args->dnode, NULL); |
ccc9ada8 RZ |
378 | bfd_profile_update(bp); |
379 | break; | |
380 | ||
381 | case NB_EV_ABORT: | |
382 | /* NOTHING */ | |
383 | break; | |
384 | } | |
385 | ||
386 | return NB_OK; | |
387 | } | |
388 | ||
389 | /* | |
390 | * XPath: /frr-bfdd:bfdd/bfd/profile/administrative-down | |
391 | */ | |
392 | int bfdd_bfd_profile_administrative_down_modify(struct nb_cb_modify_args *args) | |
393 | { | |
394 | struct bfd_profile *bp; | |
ccc9ada8 RZ |
395 | |
396 | if (args->event != NB_EV_APPLY) | |
397 | return NB_OK; | |
398 | ||
ccc9ada8 | 399 | bp = nb_running_get_entry(args->dnode, NULL, true); |
ebf8b885 | 400 | bp->admin_shutdown = yang_dnode_get_bool(args->dnode, NULL); |
ccc9ada8 RZ |
401 | bfd_profile_update(bp); |
402 | ||
403 | return NB_OK; | |
404 | } | |
405 | ||
1a2e2fff RZ |
406 | /* |
407 | * XPath: /frr-bfdd:bfdd/bfd/profile/passive-mode | |
408 | */ | |
409 | int bfdd_bfd_profile_passive_mode_modify(struct nb_cb_modify_args *args) | |
410 | { | |
411 | struct bfd_profile *bp; | |
1a2e2fff RZ |
412 | |
413 | if (args->event != NB_EV_APPLY) | |
414 | return NB_OK; | |
415 | ||
1a2e2fff | 416 | bp = nb_running_get_entry(args->dnode, NULL, true); |
ebf8b885 | 417 | bp->passive = yang_dnode_get_bool(args->dnode, NULL); |
1a2e2fff RZ |
418 | bfd_profile_update(bp); |
419 | ||
420 | return NB_OK; | |
421 | } | |
422 | ||
262e1d25 RZ |
423 | /* |
424 | * XPath: /frr-bfdd:bfdd/bfd/profile/minimum-ttl | |
425 | */ | |
426 | int bfdd_bfd_profile_minimum_ttl_modify(struct nb_cb_modify_args *args) | |
427 | { | |
428 | struct bfd_profile *bp; | |
262e1d25 RZ |
429 | |
430 | if (args->event != NB_EV_APPLY) | |
431 | return NB_OK; | |
432 | ||
262e1d25 | 433 | bp = nb_running_get_entry(args->dnode, NULL, true); |
ebf8b885 | 434 | bp->minimum_ttl = yang_dnode_get_uint8(args->dnode, NULL); |
262e1d25 RZ |
435 | bfd_profile_update(bp); |
436 | ||
437 | return NB_OK; | |
438 | } | |
439 | ||
440 | int bfdd_bfd_profile_minimum_ttl_destroy(struct nb_cb_destroy_args *args) | |
441 | { | |
442 | struct bfd_profile *bp; | |
443 | ||
444 | if (args->event != NB_EV_APPLY) | |
445 | return NB_OK; | |
446 | ||
447 | bp = nb_running_get_entry(args->dnode, NULL, true); | |
448 | bp->minimum_ttl = BFD_DEF_MHOP_TTL; | |
449 | bfd_profile_update(bp); | |
450 | ||
451 | return NB_OK; | |
452 | } | |
453 | ||
ccc9ada8 RZ |
454 | /* |
455 | * XPath: /frr-bfdd:bfdd/bfd/profile/echo-mode | |
456 | */ | |
457 | int bfdd_bfd_profile_echo_mode_modify(struct nb_cb_modify_args *args) | |
458 | { | |
459 | struct bfd_profile *bp; | |
460 | bool echo; | |
461 | ||
462 | if (args->event != NB_EV_APPLY) | |
463 | return NB_OK; | |
464 | ||
465 | echo = yang_dnode_get_bool(args->dnode, NULL); | |
466 | bp = nb_running_get_entry(args->dnode, NULL, true); | |
467 | if (bp->echo_mode == echo) | |
468 | return NB_OK; | |
469 | ||
470 | bp->echo_mode = echo; | |
471 | bfd_profile_update(bp); | |
472 | ||
473 | return NB_OK; | |
474 | } | |
475 | ||
476 | /* | |
4df3e31c | 477 | * XPath: /frr-bfdd:bfdd/bfd/profile/desired-echo-transmission-interval |
ccc9ada8 RZ |
478 | */ |
479 | int bfdd_bfd_profile_desired_echo_transmission_interval_modify( | |
480 | struct nb_cb_modify_args *args) | |
4df3e31c IR |
481 | { |
482 | struct bfd_profile *bp; | |
4df3e31c IR |
483 | |
484 | switch (args->event) { | |
485 | case NB_EV_VALIDATE: | |
4df3e31c IR |
486 | break; |
487 | ||
488 | case NB_EV_PREPARE: | |
489 | /* NOTHING */ | |
490 | break; | |
491 | ||
492 | case NB_EV_APPLY: | |
4df3e31c | 493 | bp = nb_running_get_entry(args->dnode, NULL, true); |
ebf8b885 | 494 | bp->min_echo_tx = yang_dnode_get_uint32(args->dnode, NULL); |
4df3e31c IR |
495 | bfd_profile_update(bp); |
496 | break; | |
497 | ||
498 | case NB_EV_ABORT: | |
499 | /* NOTHING */ | |
500 | break; | |
501 | } | |
502 | ||
503 | return NB_OK; | |
504 | } | |
505 | ||
506 | /* | |
507 | * XPath: /frr-bfdd:bfdd/bfd/profile/required-echo-receive-interval | |
508 | */ | |
509 | int bfdd_bfd_profile_required_echo_receive_interval_modify( | |
510 | struct nb_cb_modify_args *args) | |
ccc9ada8 RZ |
511 | { |
512 | struct bfd_profile *bp; | |
ccc9ada8 RZ |
513 | |
514 | switch (args->event) { | |
515 | case NB_EV_VALIDATE: | |
ccc9ada8 RZ |
516 | break; |
517 | ||
518 | case NB_EV_PREPARE: | |
519 | /* NOTHING */ | |
520 | break; | |
521 | ||
522 | case NB_EV_APPLY: | |
ccc9ada8 | 523 | bp = nb_running_get_entry(args->dnode, NULL, true); |
ebf8b885 | 524 | bp->min_echo_rx = yang_dnode_get_uint32(args->dnode, NULL); |
ccc9ada8 RZ |
525 | bfd_profile_update(bp); |
526 | break; | |
527 | ||
528 | case NB_EV_ABORT: | |
529 | /* NOTHING */ | |
530 | break; | |
531 | } | |
532 | ||
533 | return NB_OK; | |
534 | } | |
535 | ||
6c574029 RW |
536 | /* |
537 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop | |
538 | */ | |
60ee8be1 | 539 | int bfdd_bfd_sessions_single_hop_create(struct nb_cb_create_args *args) |
6c574029 | 540 | { |
5e4d0fbc | 541 | return bfd_session_create(args, false); |
6c574029 RW |
542 | } |
543 | ||
60ee8be1 | 544 | int bfdd_bfd_sessions_single_hop_destroy(struct nb_cb_destroy_args *args) |
6c574029 | 545 | { |
60ee8be1 | 546 | return bfd_session_destroy(args->event, args->dnode, false); |
6c574029 RW |
547 | } |
548 | ||
549 | /* | |
550 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/source-addr | |
551 | */ | |
60ee8be1 RW |
552 | int bfdd_bfd_sessions_single_hop_source_addr_modify( |
553 | struct nb_cb_modify_args *args) | |
6c574029 RW |
554 | { |
555 | return NB_OK; | |
556 | } | |
557 | ||
558 | int bfdd_bfd_sessions_single_hop_source_addr_destroy( | |
60ee8be1 | 559 | struct nb_cb_destroy_args *args) |
6c574029 RW |
560 | { |
561 | return NB_OK; | |
562 | } | |
563 | ||
ccc9ada8 RZ |
564 | /* |
565 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/profile | |
566 | */ | |
567 | int bfdd_bfd_sessions_single_hop_profile_modify(struct nb_cb_modify_args *args) | |
568 | { | |
569 | struct bfd_session *bs; | |
570 | ||
571 | if (args->event != NB_EV_APPLY) | |
572 | return NB_OK; | |
573 | ||
574 | bs = nb_running_get_entry(args->dnode, NULL, true); | |
575 | bfd_profile_apply(yang_dnode_get_string(args->dnode, NULL), bs); | |
576 | ||
577 | return NB_OK; | |
578 | } | |
579 | ||
580 | int bfdd_bfd_sessions_single_hop_profile_destroy( | |
581 | struct nb_cb_destroy_args *args) | |
582 | { | |
583 | struct bfd_session *bs; | |
584 | ||
585 | if (args->event != NB_EV_APPLY) | |
586 | return NB_OK; | |
587 | ||
588 | bs = nb_running_get_entry(args->dnode, NULL, true); | |
589 | bfd_profile_remove(bs); | |
590 | ||
591 | return NB_OK; | |
592 | } | |
593 | ||
6c574029 RW |
594 | /* |
595 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/detection-multiplier | |
596 | */ | |
597 | int bfdd_bfd_sessions_single_hop_detection_multiplier_modify( | |
60ee8be1 | 598 | struct nb_cb_modify_args *args) |
6c574029 | 599 | { |
60ee8be1 | 600 | uint8_t detection_multiplier = yang_dnode_get_uint8(args->dnode, NULL); |
6c574029 RW |
601 | struct bfd_session *bs; |
602 | ||
60ee8be1 | 603 | switch (args->event) { |
6c574029 RW |
604 | case NB_EV_VALIDATE: |
605 | break; | |
606 | ||
607 | case NB_EV_PREPARE: | |
608 | /* NOTHING */ | |
609 | break; | |
610 | ||
611 | case NB_EV_APPLY: | |
60ee8be1 | 612 | bs = nb_running_get_entry(args->dnode, NULL, true); |
ccc9ada8 | 613 | bs->peer_profile.detection_multiplier = detection_multiplier; |
4e38f82a | 614 | bfd_session_apply(bs); |
6c574029 RW |
615 | break; |
616 | ||
617 | case NB_EV_ABORT: | |
618 | /* NOTHING */ | |
619 | break; | |
620 | } | |
621 | ||
622 | return NB_OK; | |
623 | } | |
624 | ||
625 | /* | |
626 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/desired-transmission-interval | |
627 | */ | |
628 | int bfdd_bfd_sessions_single_hop_desired_transmission_interval_modify( | |
60ee8be1 | 629 | struct nb_cb_modify_args *args) |
6c574029 | 630 | { |
6c574029 RW |
631 | struct bfd_session *bs; |
632 | ||
60ee8be1 | 633 | switch (args->event) { |
6c574029 | 634 | case NB_EV_VALIDATE: |
6c574029 RW |
635 | break; |
636 | ||
637 | case NB_EV_PREPARE: | |
638 | /* NOTHING */ | |
639 | break; | |
640 | ||
641 | case NB_EV_APPLY: | |
60ee8be1 | 642 | bs = nb_running_get_entry(args->dnode, NULL, true); |
ebf8b885 | 643 | bs->peer_profile.min_tx = |
644 | yang_dnode_get_uint32(args->dnode, NULL); | |
4e38f82a | 645 | bfd_session_apply(bs); |
6c574029 RW |
646 | break; |
647 | ||
648 | case NB_EV_ABORT: | |
649 | /* NOTHING */ | |
650 | break; | |
651 | } | |
652 | ||
653 | return NB_OK; | |
654 | } | |
655 | ||
656 | /* | |
657 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/required-receive-interval | |
658 | */ | |
659 | int bfdd_bfd_sessions_single_hop_required_receive_interval_modify( | |
60ee8be1 | 660 | struct nb_cb_modify_args *args) |
6c574029 | 661 | { |
6c574029 RW |
662 | struct bfd_session *bs; |
663 | ||
60ee8be1 | 664 | switch (args->event) { |
6c574029 | 665 | case NB_EV_VALIDATE: |
6c574029 RW |
666 | break; |
667 | ||
668 | case NB_EV_PREPARE: | |
669 | /* NOTHING */ | |
670 | break; | |
671 | ||
672 | case NB_EV_APPLY: | |
60ee8be1 | 673 | bs = nb_running_get_entry(args->dnode, NULL, true); |
ebf8b885 | 674 | bs->peer_profile.min_rx = |
675 | yang_dnode_get_uint32(args->dnode, NULL); | |
4e38f82a | 676 | bfd_session_apply(bs); |
6c574029 RW |
677 | break; |
678 | ||
679 | case NB_EV_ABORT: | |
680 | /* NOTHING */ | |
681 | break; | |
682 | } | |
683 | ||
684 | return NB_OK; | |
685 | } | |
686 | ||
687 | /* | |
688 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/administrative-down | |
689 | */ | |
690 | int bfdd_bfd_sessions_single_hop_administrative_down_modify( | |
60ee8be1 | 691 | struct nb_cb_modify_args *args) |
6c574029 | 692 | { |
60ee8be1 | 693 | bool shutdown = yang_dnode_get_bool(args->dnode, NULL); |
6c574029 RW |
694 | struct bfd_session *bs; |
695 | ||
60ee8be1 | 696 | switch (args->event) { |
6c574029 RW |
697 | case NB_EV_VALIDATE: |
698 | case NB_EV_PREPARE: | |
699 | return NB_OK; | |
700 | ||
701 | case NB_EV_APPLY: | |
702 | break; | |
703 | ||
704 | case NB_EV_ABORT: | |
705 | return NB_OK; | |
706 | } | |
707 | ||
60ee8be1 | 708 | bs = nb_running_get_entry(args->dnode, NULL, true); |
ccc9ada8 | 709 | bs->peer_profile.admin_shutdown = shutdown; |
4e38f82a | 710 | bfd_session_apply(bs); |
6c574029 RW |
711 | |
712 | return NB_OK; | |
713 | } | |
714 | ||
1a2e2fff RZ |
715 | /* |
716 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/passive-mode | |
717 | */ | |
718 | int bfdd_bfd_sessions_single_hop_passive_mode_modify( | |
719 | struct nb_cb_modify_args *args) | |
720 | { | |
721 | struct bfd_session *bs; | |
722 | bool passive; | |
723 | ||
724 | switch (args->event) { | |
725 | case NB_EV_VALIDATE: | |
726 | case NB_EV_PREPARE: | |
727 | return NB_OK; | |
728 | ||
729 | case NB_EV_APPLY: | |
730 | break; | |
731 | ||
732 | case NB_EV_ABORT: | |
733 | return NB_OK; | |
734 | } | |
735 | ||
736 | passive = yang_dnode_get_bool(args->dnode, NULL); | |
737 | ||
738 | bs = nb_running_get_entry(args->dnode, NULL, true); | |
739 | bs->peer_profile.passive = passive; | |
4e38f82a | 740 | bfd_session_apply(bs); |
1a2e2fff RZ |
741 | |
742 | return NB_OK; | |
743 | } | |
744 | ||
6c574029 RW |
745 | /* |
746 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/echo-mode | |
747 | */ | |
60ee8be1 RW |
748 | int bfdd_bfd_sessions_single_hop_echo_mode_modify( |
749 | struct nb_cb_modify_args *args) | |
6c574029 | 750 | { |
60ee8be1 | 751 | bool echo = yang_dnode_get_bool(args->dnode, NULL); |
6c574029 RW |
752 | struct bfd_session *bs; |
753 | ||
60ee8be1 | 754 | switch (args->event) { |
6c574029 RW |
755 | case NB_EV_VALIDATE: |
756 | case NB_EV_PREPARE: | |
757 | return NB_OK; | |
758 | ||
759 | case NB_EV_APPLY: | |
760 | break; | |
761 | ||
762 | case NB_EV_ABORT: | |
763 | return NB_OK; | |
764 | } | |
765 | ||
60ee8be1 | 766 | bs = nb_running_get_entry(args->dnode, NULL, true); |
ccc9ada8 | 767 | bs->peer_profile.echo_mode = echo; |
4e38f82a | 768 | bfd_session_apply(bs); |
6c574029 RW |
769 | |
770 | return NB_OK; | |
771 | } | |
772 | ||
773 | /* | |
774 | * XPath: | |
775 | * /frr-bfdd:bfdd/bfd/sessions/single-hop/desired-echo-transmission-interval | |
776 | */ | |
777 | int bfdd_bfd_sessions_single_hop_desired_echo_transmission_interval_modify( | |
60ee8be1 | 778 | struct nb_cb_modify_args *args) |
6c574029 | 779 | { |
6c574029 RW |
780 | struct bfd_session *bs; |
781 | ||
60ee8be1 | 782 | switch (args->event) { |
6c574029 | 783 | case NB_EV_VALIDATE: |
6c574029 RW |
784 | break; |
785 | ||
786 | case NB_EV_PREPARE: | |
787 | /* NOTHING */ | |
788 | break; | |
789 | ||
790 | case NB_EV_APPLY: | |
60ee8be1 | 791 | bs = nb_running_get_entry(args->dnode, NULL, true); |
ebf8b885 | 792 | bs->peer_profile.min_echo_tx = |
793 | yang_dnode_get_uint32(args->dnode, NULL); | |
4df3e31c IR |
794 | bfd_session_apply(bs); |
795 | break; | |
796 | ||
797 | case NB_EV_ABORT: | |
798 | /* NOTHING */ | |
799 | break; | |
800 | } | |
801 | ||
802 | return NB_OK; | |
803 | } | |
804 | ||
805 | /* | |
806 | * XPath: | |
807 | * /frr-bfdd:bfdd/bfd/sessions/single-hop/required-echo-receive-interval | |
808 | */ | |
809 | int bfdd_bfd_sessions_single_hop_required_echo_receive_interval_modify( | |
810 | struct nb_cb_modify_args *args) | |
811 | { | |
4df3e31c IR |
812 | struct bfd_session *bs; |
813 | ||
814 | switch (args->event) { | |
815 | case NB_EV_VALIDATE: | |
4df3e31c IR |
816 | break; |
817 | ||
818 | case NB_EV_PREPARE: | |
819 | /* NOTHING */ | |
820 | break; | |
821 | ||
822 | case NB_EV_APPLY: | |
823 | bs = nb_running_get_entry(args->dnode, NULL, true); | |
ebf8b885 | 824 | bs->peer_profile.min_echo_rx = |
825 | yang_dnode_get_uint32(args->dnode, NULL); | |
4e38f82a | 826 | bfd_session_apply(bs); |
6c574029 RW |
827 | break; |
828 | ||
829 | case NB_EV_ABORT: | |
830 | /* NOTHING */ | |
831 | break; | |
832 | } | |
833 | ||
834 | return NB_OK; | |
835 | } | |
836 | ||
837 | /* | |
838 | * XPath: /frr-bfdd:bfdd/bfd/sessions/multi-hop | |
839 | */ | |
60ee8be1 | 840 | int bfdd_bfd_sessions_multi_hop_create(struct nb_cb_create_args *args) |
6c574029 | 841 | { |
5e4d0fbc | 842 | return bfd_session_create(args, true); |
6c574029 RW |
843 | } |
844 | ||
60ee8be1 | 845 | int bfdd_bfd_sessions_multi_hop_destroy(struct nb_cb_destroy_args *args) |
6c574029 | 846 | { |
60ee8be1 | 847 | return bfd_session_destroy(args->event, args->dnode, true); |
6c574029 | 848 | } |
262e1d25 RZ |
849 | |
850 | /* | |
851 | * XPath: /frr-bfdd:bfdd/bfd/sessions/multi-hop/minimum-ttl | |
852 | */ | |
853 | int bfdd_bfd_sessions_multi_hop_minimum_ttl_modify( | |
854 | struct nb_cb_modify_args *args) | |
855 | { | |
856 | struct bfd_session *bs; | |
857 | ||
858 | switch (args->event) { | |
859 | case NB_EV_VALIDATE: | |
860 | case NB_EV_PREPARE: | |
861 | return NB_OK; | |
862 | ||
863 | case NB_EV_APPLY: | |
864 | break; | |
865 | ||
866 | case NB_EV_ABORT: | |
867 | return NB_OK; | |
868 | } | |
869 | ||
870 | bs = nb_running_get_entry(args->dnode, NULL, true); | |
871 | bs->peer_profile.minimum_ttl = yang_dnode_get_uint8(args->dnode, NULL); | |
872 | bfd_session_apply(bs); | |
873 | ||
874 | return NB_OK; | |
875 | } | |
876 | ||
877 | int bfdd_bfd_sessions_multi_hop_minimum_ttl_destroy( | |
878 | struct nb_cb_destroy_args *args) | |
879 | { | |
880 | struct bfd_session *bs; | |
881 | ||
882 | switch (args->event) { | |
883 | case NB_EV_VALIDATE: | |
884 | case NB_EV_PREPARE: | |
885 | return NB_OK; | |
886 | ||
887 | case NB_EV_APPLY: | |
888 | break; | |
889 | ||
890 | case NB_EV_ABORT: | |
891 | return NB_OK; | |
892 | } | |
893 | ||
894 | bs = nb_running_get_entry(args->dnode, NULL, true); | |
895 | bs->peer_profile.minimum_ttl = BFD_DEF_MHOP_TTL; | |
896 | bfd_session_apply(bs); | |
897 | ||
898 | return NB_OK; | |
899 | } |