]>
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; | |
336 | uint32_t min_tx; | |
337 | ||
338 | switch (args->event) { | |
339 | case NB_EV_VALIDATE: | |
340 | min_tx = yang_dnode_get_uint32(args->dnode, NULL); | |
341 | if (min_tx < 10000 || min_tx > 60000000) | |
342 | return NB_ERR_VALIDATION; | |
343 | break; | |
344 | ||
345 | case NB_EV_PREPARE: | |
346 | /* NOTHING */ | |
347 | break; | |
348 | ||
349 | case NB_EV_APPLY: | |
350 | min_tx = yang_dnode_get_uint32(args->dnode, NULL); | |
351 | bp = nb_running_get_entry(args->dnode, NULL, true); | |
352 | if (bp->min_tx == min_tx) | |
353 | return NB_OK; | |
354 | ||
355 | bp->min_tx = min_tx; | |
356 | bfd_profile_update(bp); | |
357 | break; | |
358 | ||
359 | case NB_EV_ABORT: | |
360 | /* NOTHING */ | |
361 | break; | |
362 | } | |
363 | ||
364 | return NB_OK; | |
365 | } | |
366 | ||
367 | /* | |
368 | * XPath: /frr-bfdd:bfdd/bfd/profile/required-receive-interval | |
369 | */ | |
370 | int bfdd_bfd_profile_required_receive_interval_modify( | |
371 | struct nb_cb_modify_args *args) | |
372 | { | |
373 | struct bfd_profile *bp; | |
374 | uint32_t min_rx; | |
375 | ||
376 | switch (args->event) { | |
377 | case NB_EV_VALIDATE: | |
378 | min_rx = yang_dnode_get_uint32(args->dnode, NULL); | |
379 | if (min_rx < 10000 || min_rx > 60000000) | |
380 | return NB_ERR_VALIDATION; | |
381 | break; | |
382 | ||
383 | case NB_EV_PREPARE: | |
384 | /* NOTHING */ | |
385 | break; | |
386 | ||
387 | case NB_EV_APPLY: | |
388 | min_rx = yang_dnode_get_uint32(args->dnode, NULL); | |
389 | bp = nb_running_get_entry(args->dnode, NULL, true); | |
390 | if (bp->min_rx == min_rx) | |
391 | return NB_OK; | |
392 | ||
393 | bp->min_rx = min_rx; | |
394 | bfd_profile_update(bp); | |
395 | break; | |
396 | ||
397 | case NB_EV_ABORT: | |
398 | /* NOTHING */ | |
399 | break; | |
400 | } | |
401 | ||
402 | return NB_OK; | |
403 | } | |
404 | ||
405 | /* | |
406 | * XPath: /frr-bfdd:bfdd/bfd/profile/administrative-down | |
407 | */ | |
408 | int bfdd_bfd_profile_administrative_down_modify(struct nb_cb_modify_args *args) | |
409 | { | |
410 | struct bfd_profile *bp; | |
411 | bool shutdown; | |
412 | ||
413 | if (args->event != NB_EV_APPLY) | |
414 | return NB_OK; | |
415 | ||
416 | shutdown = yang_dnode_get_bool(args->dnode, NULL); | |
417 | bp = nb_running_get_entry(args->dnode, NULL, true); | |
418 | if (bp->admin_shutdown == shutdown) | |
419 | return NB_OK; | |
420 | ||
421 | bp->admin_shutdown = shutdown; | |
422 | bfd_profile_update(bp); | |
423 | ||
424 | return NB_OK; | |
425 | } | |
426 | ||
1a2e2fff RZ |
427 | /* |
428 | * XPath: /frr-bfdd:bfdd/bfd/profile/passive-mode | |
429 | */ | |
430 | int bfdd_bfd_profile_passive_mode_modify(struct nb_cb_modify_args *args) | |
431 | { | |
432 | struct bfd_profile *bp; | |
433 | bool passive; | |
434 | ||
435 | if (args->event != NB_EV_APPLY) | |
436 | return NB_OK; | |
437 | ||
438 | passive = yang_dnode_get_bool(args->dnode, NULL); | |
439 | bp = nb_running_get_entry(args->dnode, NULL, true); | |
440 | if (bp->passive == passive) | |
441 | return NB_OK; | |
442 | ||
443 | bp->passive = passive; | |
444 | bfd_profile_update(bp); | |
445 | ||
446 | return NB_OK; | |
447 | } | |
448 | ||
262e1d25 RZ |
449 | /* |
450 | * XPath: /frr-bfdd:bfdd/bfd/profile/minimum-ttl | |
451 | */ | |
452 | int bfdd_bfd_profile_minimum_ttl_modify(struct nb_cb_modify_args *args) | |
453 | { | |
454 | struct bfd_profile *bp; | |
455 | uint8_t minimum_ttl; | |
456 | ||
457 | if (args->event != NB_EV_APPLY) | |
458 | return NB_OK; | |
459 | ||
460 | minimum_ttl = yang_dnode_get_uint8(args->dnode, NULL); | |
461 | bp = nb_running_get_entry(args->dnode, NULL, true); | |
462 | if (bp->minimum_ttl == minimum_ttl) | |
463 | return NB_OK; | |
464 | ||
465 | bp->minimum_ttl = minimum_ttl; | |
466 | bfd_profile_update(bp); | |
467 | ||
468 | return NB_OK; | |
469 | } | |
470 | ||
471 | int bfdd_bfd_profile_minimum_ttl_destroy(struct nb_cb_destroy_args *args) | |
472 | { | |
473 | struct bfd_profile *bp; | |
474 | ||
475 | if (args->event != NB_EV_APPLY) | |
476 | return NB_OK; | |
477 | ||
478 | bp = nb_running_get_entry(args->dnode, NULL, true); | |
479 | bp->minimum_ttl = BFD_DEF_MHOP_TTL; | |
480 | bfd_profile_update(bp); | |
481 | ||
482 | return NB_OK; | |
483 | } | |
484 | ||
ccc9ada8 RZ |
485 | /* |
486 | * XPath: /frr-bfdd:bfdd/bfd/profile/echo-mode | |
487 | */ | |
488 | int bfdd_bfd_profile_echo_mode_modify(struct nb_cb_modify_args *args) | |
489 | { | |
490 | struct bfd_profile *bp; | |
491 | bool echo; | |
492 | ||
493 | if (args->event != NB_EV_APPLY) | |
494 | return NB_OK; | |
495 | ||
496 | echo = yang_dnode_get_bool(args->dnode, NULL); | |
497 | bp = nb_running_get_entry(args->dnode, NULL, true); | |
498 | if (bp->echo_mode == echo) | |
499 | return NB_OK; | |
500 | ||
501 | bp->echo_mode = echo; | |
502 | bfd_profile_update(bp); | |
503 | ||
504 | return NB_OK; | |
505 | } | |
506 | ||
507 | /* | |
4df3e31c | 508 | * XPath: /frr-bfdd:bfdd/bfd/profile/desired-echo-transmission-interval |
ccc9ada8 RZ |
509 | */ |
510 | int bfdd_bfd_profile_desired_echo_transmission_interval_modify( | |
511 | struct nb_cb_modify_args *args) | |
4df3e31c IR |
512 | { |
513 | struct bfd_profile *bp; | |
514 | uint32_t min_tx; | |
515 | ||
516 | switch (args->event) { | |
517 | case NB_EV_VALIDATE: | |
518 | min_tx = yang_dnode_get_uint32(args->dnode, NULL); | |
519 | if (min_tx < 10000 || min_tx > 60000000) | |
520 | return NB_ERR_VALIDATION; | |
521 | break; | |
522 | ||
523 | case NB_EV_PREPARE: | |
524 | /* NOTHING */ | |
525 | break; | |
526 | ||
527 | case NB_EV_APPLY: | |
528 | min_tx = yang_dnode_get_uint32(args->dnode, NULL); | |
529 | bp = nb_running_get_entry(args->dnode, NULL, true); | |
530 | if (bp->min_echo_tx == min_tx) | |
531 | return NB_OK; | |
532 | ||
533 | bp->min_echo_tx = min_tx; | |
534 | bfd_profile_update(bp); | |
535 | break; | |
536 | ||
537 | case NB_EV_ABORT: | |
538 | /* NOTHING */ | |
539 | break; | |
540 | } | |
541 | ||
542 | return NB_OK; | |
543 | } | |
544 | ||
545 | /* | |
546 | * XPath: /frr-bfdd:bfdd/bfd/profile/required-echo-receive-interval | |
547 | */ | |
548 | int bfdd_bfd_profile_required_echo_receive_interval_modify( | |
549 | struct nb_cb_modify_args *args) | |
ccc9ada8 RZ |
550 | { |
551 | struct bfd_profile *bp; | |
552 | uint32_t min_rx; | |
553 | ||
554 | switch (args->event) { | |
555 | case NB_EV_VALIDATE: | |
556 | min_rx = yang_dnode_get_uint32(args->dnode, NULL); | |
4df3e31c IR |
557 | if (min_rx == 0) |
558 | return NB_OK; | |
ccc9ada8 RZ |
559 | if (min_rx < 10000 || min_rx > 60000000) |
560 | return NB_ERR_VALIDATION; | |
561 | break; | |
562 | ||
563 | case NB_EV_PREPARE: | |
564 | /* NOTHING */ | |
565 | break; | |
566 | ||
567 | case NB_EV_APPLY: | |
568 | min_rx = yang_dnode_get_uint32(args->dnode, NULL); | |
569 | bp = nb_running_get_entry(args->dnode, NULL, true); | |
570 | if (bp->min_echo_rx == min_rx) | |
571 | return NB_OK; | |
572 | ||
573 | bp->min_echo_rx = min_rx; | |
574 | bfd_profile_update(bp); | |
575 | break; | |
576 | ||
577 | case NB_EV_ABORT: | |
578 | /* NOTHING */ | |
579 | break; | |
580 | } | |
581 | ||
582 | return NB_OK; | |
583 | } | |
584 | ||
6c574029 RW |
585 | /* |
586 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop | |
587 | */ | |
60ee8be1 | 588 | int bfdd_bfd_sessions_single_hop_create(struct nb_cb_create_args *args) |
6c574029 | 589 | { |
5e4d0fbc | 590 | return bfd_session_create(args, false); |
6c574029 RW |
591 | } |
592 | ||
60ee8be1 | 593 | int bfdd_bfd_sessions_single_hop_destroy(struct nb_cb_destroy_args *args) |
6c574029 | 594 | { |
60ee8be1 | 595 | return bfd_session_destroy(args->event, args->dnode, false); |
6c574029 RW |
596 | } |
597 | ||
598 | /* | |
599 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/source-addr | |
600 | */ | |
60ee8be1 RW |
601 | int bfdd_bfd_sessions_single_hop_source_addr_modify( |
602 | struct nb_cb_modify_args *args) | |
6c574029 RW |
603 | { |
604 | return NB_OK; | |
605 | } | |
606 | ||
607 | int bfdd_bfd_sessions_single_hop_source_addr_destroy( | |
60ee8be1 | 608 | struct nb_cb_destroy_args *args) |
6c574029 RW |
609 | { |
610 | return NB_OK; | |
611 | } | |
612 | ||
ccc9ada8 RZ |
613 | /* |
614 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/profile | |
615 | */ | |
616 | int bfdd_bfd_sessions_single_hop_profile_modify(struct nb_cb_modify_args *args) | |
617 | { | |
618 | struct bfd_session *bs; | |
619 | ||
620 | if (args->event != NB_EV_APPLY) | |
621 | return NB_OK; | |
622 | ||
623 | bs = nb_running_get_entry(args->dnode, NULL, true); | |
624 | bfd_profile_apply(yang_dnode_get_string(args->dnode, NULL), bs); | |
625 | ||
626 | return NB_OK; | |
627 | } | |
628 | ||
629 | int bfdd_bfd_sessions_single_hop_profile_destroy( | |
630 | struct nb_cb_destroy_args *args) | |
631 | { | |
632 | struct bfd_session *bs; | |
633 | ||
634 | if (args->event != NB_EV_APPLY) | |
635 | return NB_OK; | |
636 | ||
637 | bs = nb_running_get_entry(args->dnode, NULL, true); | |
638 | bfd_profile_remove(bs); | |
639 | ||
640 | return NB_OK; | |
641 | } | |
642 | ||
6c574029 RW |
643 | /* |
644 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/detection-multiplier | |
645 | */ | |
646 | int bfdd_bfd_sessions_single_hop_detection_multiplier_modify( | |
60ee8be1 | 647 | struct nb_cb_modify_args *args) |
6c574029 | 648 | { |
60ee8be1 | 649 | uint8_t detection_multiplier = yang_dnode_get_uint8(args->dnode, NULL); |
6c574029 RW |
650 | struct bfd_session *bs; |
651 | ||
60ee8be1 | 652 | switch (args->event) { |
6c574029 RW |
653 | case NB_EV_VALIDATE: |
654 | break; | |
655 | ||
656 | case NB_EV_PREPARE: | |
657 | /* NOTHING */ | |
658 | break; | |
659 | ||
660 | case NB_EV_APPLY: | |
60ee8be1 | 661 | bs = nb_running_get_entry(args->dnode, NULL, true); |
ccc9ada8 | 662 | bs->peer_profile.detection_multiplier = detection_multiplier; |
4e38f82a | 663 | bfd_session_apply(bs); |
6c574029 RW |
664 | break; |
665 | ||
666 | case NB_EV_ABORT: | |
667 | /* NOTHING */ | |
668 | break; | |
669 | } | |
670 | ||
671 | return NB_OK; | |
672 | } | |
673 | ||
674 | /* | |
675 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/desired-transmission-interval | |
676 | */ | |
677 | int bfdd_bfd_sessions_single_hop_desired_transmission_interval_modify( | |
60ee8be1 | 678 | struct nb_cb_modify_args *args) |
6c574029 | 679 | { |
60ee8be1 | 680 | uint32_t tx_interval = yang_dnode_get_uint32(args->dnode, NULL); |
6c574029 RW |
681 | struct bfd_session *bs; |
682 | ||
60ee8be1 | 683 | switch (args->event) { |
6c574029 RW |
684 | case NB_EV_VALIDATE: |
685 | if (tx_interval < 10000 || tx_interval > 60000000) | |
686 | return NB_ERR_VALIDATION; | |
687 | break; | |
688 | ||
689 | case NB_EV_PREPARE: | |
690 | /* NOTHING */ | |
691 | break; | |
692 | ||
693 | case NB_EV_APPLY: | |
60ee8be1 | 694 | bs = nb_running_get_entry(args->dnode, NULL, true); |
6c574029 RW |
695 | if (tx_interval == bs->timers.desired_min_tx) |
696 | return NB_OK; | |
697 | ||
ccc9ada8 | 698 | bs->peer_profile.min_tx = tx_interval; |
4e38f82a | 699 | bfd_session_apply(bs); |
6c574029 RW |
700 | break; |
701 | ||
702 | case NB_EV_ABORT: | |
703 | /* NOTHING */ | |
704 | break; | |
705 | } | |
706 | ||
707 | return NB_OK; | |
708 | } | |
709 | ||
710 | /* | |
711 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/required-receive-interval | |
712 | */ | |
713 | int bfdd_bfd_sessions_single_hop_required_receive_interval_modify( | |
60ee8be1 | 714 | struct nb_cb_modify_args *args) |
6c574029 | 715 | { |
60ee8be1 | 716 | uint32_t rx_interval = yang_dnode_get_uint32(args->dnode, NULL); |
6c574029 RW |
717 | struct bfd_session *bs; |
718 | ||
60ee8be1 | 719 | switch (args->event) { |
6c574029 RW |
720 | case NB_EV_VALIDATE: |
721 | if (rx_interval < 10000 || rx_interval > 60000000) | |
722 | return NB_ERR_VALIDATION; | |
723 | break; | |
724 | ||
725 | case NB_EV_PREPARE: | |
726 | /* NOTHING */ | |
727 | break; | |
728 | ||
729 | case NB_EV_APPLY: | |
60ee8be1 | 730 | bs = nb_running_get_entry(args->dnode, NULL, true); |
6c574029 RW |
731 | if (rx_interval == bs->timers.required_min_rx) |
732 | return NB_OK; | |
733 | ||
ccc9ada8 | 734 | bs->peer_profile.min_rx = rx_interval; |
4e38f82a | 735 | bfd_session_apply(bs); |
6c574029 RW |
736 | break; |
737 | ||
738 | case NB_EV_ABORT: | |
739 | /* NOTHING */ | |
740 | break; | |
741 | } | |
742 | ||
743 | return NB_OK; | |
744 | } | |
745 | ||
746 | /* | |
747 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/administrative-down | |
748 | */ | |
749 | int bfdd_bfd_sessions_single_hop_administrative_down_modify( | |
60ee8be1 | 750 | struct nb_cb_modify_args *args) |
6c574029 | 751 | { |
60ee8be1 | 752 | bool shutdown = yang_dnode_get_bool(args->dnode, NULL); |
6c574029 RW |
753 | struct bfd_session *bs; |
754 | ||
60ee8be1 | 755 | switch (args->event) { |
6c574029 RW |
756 | case NB_EV_VALIDATE: |
757 | case NB_EV_PREPARE: | |
758 | return NB_OK; | |
759 | ||
760 | case NB_EV_APPLY: | |
761 | break; | |
762 | ||
763 | case NB_EV_ABORT: | |
764 | return NB_OK; | |
765 | } | |
766 | ||
60ee8be1 | 767 | bs = nb_running_get_entry(args->dnode, NULL, true); |
ccc9ada8 | 768 | bs->peer_profile.admin_shutdown = shutdown; |
4e38f82a | 769 | bfd_session_apply(bs); |
6c574029 RW |
770 | |
771 | return NB_OK; | |
772 | } | |
773 | ||
1a2e2fff RZ |
774 | /* |
775 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/passive-mode | |
776 | */ | |
777 | int bfdd_bfd_sessions_single_hop_passive_mode_modify( | |
778 | struct nb_cb_modify_args *args) | |
779 | { | |
780 | struct bfd_session *bs; | |
781 | bool passive; | |
782 | ||
783 | switch (args->event) { | |
784 | case NB_EV_VALIDATE: | |
785 | case NB_EV_PREPARE: | |
786 | return NB_OK; | |
787 | ||
788 | case NB_EV_APPLY: | |
789 | break; | |
790 | ||
791 | case NB_EV_ABORT: | |
792 | return NB_OK; | |
793 | } | |
794 | ||
795 | passive = yang_dnode_get_bool(args->dnode, NULL); | |
796 | ||
797 | bs = nb_running_get_entry(args->dnode, NULL, true); | |
798 | bs->peer_profile.passive = passive; | |
4e38f82a | 799 | bfd_session_apply(bs); |
1a2e2fff RZ |
800 | |
801 | return NB_OK; | |
802 | } | |
803 | ||
6c574029 RW |
804 | /* |
805 | * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/echo-mode | |
806 | */ | |
60ee8be1 RW |
807 | int bfdd_bfd_sessions_single_hop_echo_mode_modify( |
808 | struct nb_cb_modify_args *args) | |
6c574029 | 809 | { |
60ee8be1 | 810 | bool echo = yang_dnode_get_bool(args->dnode, NULL); |
6c574029 RW |
811 | struct bfd_session *bs; |
812 | ||
60ee8be1 | 813 | switch (args->event) { |
6c574029 RW |
814 | case NB_EV_VALIDATE: |
815 | case NB_EV_PREPARE: | |
816 | return NB_OK; | |
817 | ||
818 | case NB_EV_APPLY: | |
819 | break; | |
820 | ||
821 | case NB_EV_ABORT: | |
822 | return NB_OK; | |
823 | } | |
824 | ||
60ee8be1 | 825 | bs = nb_running_get_entry(args->dnode, NULL, true); |
ccc9ada8 | 826 | bs->peer_profile.echo_mode = echo; |
4e38f82a | 827 | bfd_session_apply(bs); |
6c574029 RW |
828 | |
829 | return NB_OK; | |
830 | } | |
831 | ||
832 | /* | |
833 | * XPath: | |
834 | * /frr-bfdd:bfdd/bfd/sessions/single-hop/desired-echo-transmission-interval | |
835 | */ | |
836 | int bfdd_bfd_sessions_single_hop_desired_echo_transmission_interval_modify( | |
60ee8be1 | 837 | struct nb_cb_modify_args *args) |
6c574029 | 838 | { |
60ee8be1 | 839 | uint32_t echo_interval = yang_dnode_get_uint32(args->dnode, NULL); |
6c574029 RW |
840 | struct bfd_session *bs; |
841 | ||
60ee8be1 | 842 | switch (args->event) { |
6c574029 RW |
843 | case NB_EV_VALIDATE: |
844 | if (echo_interval < 10000 || echo_interval > 60000000) | |
845 | return NB_ERR_VALIDATION; | |
846 | break; | |
847 | ||
848 | case NB_EV_PREPARE: | |
849 | /* NOTHING */ | |
850 | break; | |
851 | ||
852 | case NB_EV_APPLY: | |
60ee8be1 | 853 | bs = nb_running_get_entry(args->dnode, NULL, true); |
4df3e31c IR |
854 | if (echo_interval == bs->timers.desired_min_echo_tx) |
855 | return NB_OK; | |
856 | ||
857 | bs->peer_profile.min_echo_tx = echo_interval; | |
858 | bfd_session_apply(bs); | |
859 | break; | |
860 | ||
861 | case NB_EV_ABORT: | |
862 | /* NOTHING */ | |
863 | break; | |
864 | } | |
865 | ||
866 | return NB_OK; | |
867 | } | |
868 | ||
869 | /* | |
870 | * XPath: | |
871 | * /frr-bfdd:bfdd/bfd/sessions/single-hop/required-echo-receive-interval | |
872 | */ | |
873 | int bfdd_bfd_sessions_single_hop_required_echo_receive_interval_modify( | |
874 | struct nb_cb_modify_args *args) | |
875 | { | |
876 | uint32_t echo_interval = yang_dnode_get_uint32(args->dnode, NULL); | |
877 | struct bfd_session *bs; | |
878 | ||
879 | switch (args->event) { | |
880 | case NB_EV_VALIDATE: | |
881 | if (echo_interval == 0) | |
882 | return NB_OK; | |
883 | if (echo_interval < 10000 || echo_interval > 60000000) | |
884 | return NB_ERR_VALIDATION; | |
885 | break; | |
886 | ||
887 | case NB_EV_PREPARE: | |
888 | /* NOTHING */ | |
889 | break; | |
890 | ||
891 | case NB_EV_APPLY: | |
892 | bs = nb_running_get_entry(args->dnode, NULL, true); | |
893 | if (echo_interval == bs->timers.required_min_echo_rx) | |
6c574029 RW |
894 | return NB_OK; |
895 | ||
ccc9ada8 | 896 | bs->peer_profile.min_echo_rx = echo_interval; |
4e38f82a | 897 | bfd_session_apply(bs); |
6c574029 RW |
898 | break; |
899 | ||
900 | case NB_EV_ABORT: | |
901 | /* NOTHING */ | |
902 | break; | |
903 | } | |
904 | ||
905 | return NB_OK; | |
906 | } | |
907 | ||
908 | /* | |
909 | * XPath: /frr-bfdd:bfdd/bfd/sessions/multi-hop | |
910 | */ | |
60ee8be1 | 911 | int bfdd_bfd_sessions_multi_hop_create(struct nb_cb_create_args *args) |
6c574029 | 912 | { |
5e4d0fbc | 913 | return bfd_session_create(args, true); |
6c574029 RW |
914 | } |
915 | ||
60ee8be1 | 916 | int bfdd_bfd_sessions_multi_hop_destroy(struct nb_cb_destroy_args *args) |
6c574029 | 917 | { |
60ee8be1 | 918 | return bfd_session_destroy(args->event, args->dnode, true); |
6c574029 | 919 | } |
262e1d25 RZ |
920 | |
921 | /* | |
922 | * XPath: /frr-bfdd:bfdd/bfd/sessions/multi-hop/minimum-ttl | |
923 | */ | |
924 | int bfdd_bfd_sessions_multi_hop_minimum_ttl_modify( | |
925 | struct nb_cb_modify_args *args) | |
926 | { | |
927 | struct bfd_session *bs; | |
928 | ||
929 | switch (args->event) { | |
930 | case NB_EV_VALIDATE: | |
931 | case NB_EV_PREPARE: | |
932 | return NB_OK; | |
933 | ||
934 | case NB_EV_APPLY: | |
935 | break; | |
936 | ||
937 | case NB_EV_ABORT: | |
938 | return NB_OK; | |
939 | } | |
940 | ||
941 | bs = nb_running_get_entry(args->dnode, NULL, true); | |
942 | bs->peer_profile.minimum_ttl = yang_dnode_get_uint8(args->dnode, NULL); | |
943 | bfd_session_apply(bs); | |
944 | ||
945 | return NB_OK; | |
946 | } | |
947 | ||
948 | int bfdd_bfd_sessions_multi_hop_minimum_ttl_destroy( | |
949 | struct nb_cb_destroy_args *args) | |
950 | { | |
951 | struct bfd_session *bs; | |
952 | ||
953 | switch (args->event) { | |
954 | case NB_EV_VALIDATE: | |
955 | case NB_EV_PREPARE: | |
956 | return NB_OK; | |
957 | ||
958 | case NB_EV_APPLY: | |
959 | break; | |
960 | ||
961 | case NB_EV_ABORT: | |
962 | return NB_OK; | |
963 | } | |
964 | ||
965 | bs = nb_running_get_entry(args->dnode, NULL, true); | |
966 | bs->peer_profile.minimum_ttl = BFD_DEF_MHOP_TTL; | |
967 | bfd_session_apply(bs); | |
968 | ||
969 | return NB_OK; | |
970 | } |