]> git.proxmox.com Git - mirror_frr.git/blame - lib/filter_nb.c
projects / mirror_frr.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
lib: migrate prefix-list to use northbound
[mirror_frr.git] / lib / filter_nb.c
CommitLineData
4470143b
RZ		 1/*
2 * FRR filter 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#include "lib/prefix.h"
28
29#include "lib/filter.h"
30#include "lib/plist.h"
31#include "lib/plist_int.h"
32
33/*
34 * XPath: /frr-filter:lib/access-list-legacy
35 */
36static int lib_access_list_legacy_create(enum nb_event event,
37 const struct lyd_node *dnode,
38 union nb_resource *resource)
39{
40 struct access_list *acl;
41 const char *acl_name;
42
43 if (event != NB_EV_APPLY)
44 return NB_OK;
45
46 acl_name = yang_dnode_get_string(dnode, "./number");
47 acl = access_list_get(AFI_IP, acl_name);
48 nb_running_set_entry(dnode, acl);
49
50 return NB_OK;
51}
52
53static int lib_access_list_legacy_destroy(enum nb_event event,
54 const struct lyd_node *dnode)
55{
56 struct access_master *am;
57 struct access_list *acl;
58
59 if (event != NB_EV_APPLY)
60 return NB_OK;
61
62 acl = nb_running_unset_entry(dnode);
63 am = acl->master;
64 if (am->delete_hook)
65 am->delete_hook(acl);
66
67 access_list_delete(acl);
68
69 return NB_OK;
70}
71
72/*
73 * XPath: /frr-filter:lib/access-list-legacy/remark
74 */
75static int lib_access_list_legacy_remark_modify(enum nb_event event,
76 const struct lyd_node *dnode,
77 union nb_resource *resource)
78{
79 struct access_list *acl;
80 const char *remark;
81
82 if (event != NB_EV_APPLY)
83 return NB_OK;
84
85 acl = nb_running_get_entry(dnode, NULL, true);
86 if (acl->remark)
87 XFREE(MTYPE_TMP, acl->remark);
88
89 remark = yang_dnode_get_string(dnode, NULL);
90 acl->remark = XSTRDUP(MTYPE_TMP, remark);
91
92 return NB_OK;
93}
94
95static int lib_access_list_legacy_remark_destroy(enum nb_event event,
96 const struct lyd_node *dnode)
97{
98 struct access_list *acl;
99
100 if (event != NB_EV_APPLY)
101 return NB_OK;
102
103 acl = nb_running_get_entry(dnode, NULL, true);
104 if (acl->remark)
105 XFREE(MTYPE_TMP, acl->remark);
106
107 acl->remark = NULL;
108
109 return NB_OK;
110}
111
112/*
113 * XPath: /frr-filter:lib/access-list-legacy/entry
114 */
115static int lib_access_list_legacy_entry_create(enum nb_event event,
116 const struct lyd_node *dnode,
117 union nb_resource *resource)
118{
119 struct filter_cisco *fc;
120 struct access_list *acl;
121 struct filter *f;
122 uint32_t aclno;
123
124 /* TODO: validate `filter_lookup_cisco` returns NULL. */
125
126 if (event != NB_EV_APPLY)
127 return NB_OK;
128
129 aclno = yang_dnode_get_uint16(dnode, "../number");
130
131 f = filter_new();
132 f->cisco = 1;
133 f->seq = yang_dnode_get_uint32(dnode, "./sequence");
134 fc = &f->u.cfilter;
135 if ((aclno >= 1 && aclno <= 99) || (aclno >= 1300 && aclno <= 1999))
136 fc->extended = 0;
137 else
138 fc->extended = 1;
139
140 acl = nb_running_get_entry(dnode, NULL, true);
141 f->acl = acl;
142 access_list_filter_add(acl, f);
143 nb_running_set_entry(dnode, f);
144
145 return NB_OK;
146}
147
148static int lib_access_list_legacy_entry_destroy(enum nb_event event,
149 const struct lyd_node *dnode)
150{
151 struct access_list *acl;
152 struct filter *f;
153
154 if (event != NB_EV_APPLY)
155 return NB_OK;
156
157 f = nb_running_unset_entry(dnode);
158 acl = f->acl;
159 access_list_filter_delete(acl, f);
160
161 return NB_OK;
162}
163
164/*
165 * XPath: /frr-filter:lib/access-list-legacy/entry/action
166 */
167static int
168lib_access_list_legacy_entry_action_modify(enum nb_event event,
169 const struct lyd_node *dnode,
170 union nb_resource *resource)
171{
172 const char *filter_type;
173 struct filter *f;
174
175 if (event != NB_EV_APPLY)
176 return NB_OK;
177
178 f = nb_running_get_entry(dnode, NULL, true);
179 filter_type = yang_dnode_get_string(dnode, NULL);
180 if (strcmp(filter_type, "permit") == 0)
181 f->type = FILTER_PERMIT;
182 else
183 f->type = FILTER_DENY;
184
185 return NB_OK;
186}
187
188/*
189 * XPath: /frr-filter:lib/access-list-legacy/entry/host
190 */
191static int
192lib_access_list_legacy_entry_host_modify(enum nb_event event,
193 const struct lyd_node *dnode,
194 union nb_resource *resource)
195{
196 struct filter_cisco *fc;
197 struct filter *f;
198
199 if (event != NB_EV_APPLY)
200 return NB_OK;
201
202 f = nb_running_get_entry(dnode, NULL, true);
203 fc = &f->u.cfilter;
204 yang_dnode_get_ipv4(&fc->addr, dnode, NULL);
205 fc->addr_mask.s_addr = INADDR_ANY;
206
207 return NB_OK;
208}
209
210static int
211lib_access_list_legacy_entry_host_destroy(enum nb_event event,
212 const struct lyd_node *dnode)
213{
214 struct filter_cisco *fc;
215 struct filter *f;
216
217 if (event != NB_EV_APPLY)
218 return NB_OK;
219
220 f = nb_running_get_entry(dnode, NULL, true);
221 fc = &f->u.cfilter;
222 fc->addr.s_addr = INADDR_ANY;
223 fc->addr_mask.s_addr = INADDR_NONE;
224
225 return NB_OK;
226}
227
228/*
229 * XPath: /frr-filter:lib/access-list-legacy/entry/network
230 */
231static int
232lib_access_list_legacy_entry_network_modify(enum nb_event event,
233 const struct lyd_node *dnode,
234 union nb_resource *resource)
235{
236 struct filter_cisco *fc;
237 struct filter *f;
238 struct prefix p;
239
240 if (event != NB_EV_APPLY)
241 return NB_OK;
242
243 f = nb_running_get_entry(dnode, NULL, true);
244 fc = &f->u.cfilter;
245 yang_dnode_get_prefix(&p, dnode, NULL);
246 fc->addr.s_addr = ipv4_network_addr(p.u.prefix4.s_addr, p.prefixlen);
247 masklen2ip(p.prefixlen, &fc->addr_mask);
248
249 return NB_OK;
250}
251
252static int
253lib_access_list_legacy_entry_network_destroy(enum nb_event event,
254 const struct lyd_node *dnode)
255{
256 struct filter_cisco *fc;
257 struct filter *f;
258
259 if (event != NB_EV_APPLY)
260 return NB_OK;
261
262 f = nb_running_get_entry(dnode, NULL, true);
263 fc = &f->u.cfilter;
264 fc->addr.s_addr = INADDR_ANY;
265 fc->addr_mask.s_addr = INADDR_NONE;
266
267 return NB_OK;
268}
269
270/*
271 * XPath: /frr-filter:lib/access-list-legacy/entry/any
272 */
273static int lib_access_list_legacy_entry_any_create(enum nb_event event,
274 const struct lyd_node *dnode,
275 union nb_resource *resource)
276{
277 struct filter_cisco *fc;
278 struct filter *f;
279
280 if (event != NB_EV_APPLY)
281 return NB_OK;
282
283 f = nb_running_get_entry(dnode, NULL, true);
284 fc = &f->u.cfilter;
285 fc->addr.s_addr = INADDR_ANY;
286 fc->addr_mask.s_addr = INADDR_NONE;
287
288 return NB_OK;
289}
290
291static int
292lib_access_list_legacy_entry_any_destroy(enum nb_event event,
293 const struct lyd_node *dnode)
294{
295 struct filter_cisco *fc;
296 struct filter *f;
297
298 if (event != NB_EV_APPLY)
299 return NB_OK;
300
301 f = nb_running_get_entry(dnode, NULL, true);
302 fc = &f->u.cfilter;
303 fc->addr.s_addr = INADDR_ANY;
304 fc->addr_mask.s_addr = INADDR_NONE;
305
306 return NB_OK;
307}
308
309/*
310 * XPath: /frr-filter:lib/access-list-legacy/entry/destination-host
311 */
312static int lib_access_list_legacy_entry_destination_host_modify(
313 enum nb_event event, const struct lyd_node *dnode,
314 union nb_resource *resource)
315{
316 struct filter_cisco *fc;
317 struct filter *f;
318
319 if (event != NB_EV_APPLY)
320 return NB_OK;
321
322 f = nb_running_get_entry(dnode, NULL, true);
323 fc = &f->u.cfilter;
324 yang_dnode_get_ipv4(&fc->mask, dnode, NULL);
325 fc->mask_mask.s_addr = INADDR_ANY;
326
327 return NB_OK;
328}
329
330static int lib_access_list_legacy_entry_destination_host_destroy(
331 enum nb_event event, const struct lyd_node *dnode)
332{
333 struct filter_cisco *fc;
334 struct filter *f;
335
336 if (event != NB_EV_APPLY)
337 return NB_OK;
338
339 f = nb_running_get_entry(dnode, NULL, true);
340 fc = &f->u.cfilter;
341 fc->mask.s_addr = INADDR_ANY;
342 fc->mask_mask.s_addr = INADDR_NONE;
343
344 return NB_OK;
345}
346
347/*
348 * XPath: /frr-filter:lib/access-list-legacy/entry/destination-network
349 */
350static int lib_access_list_legacy_entry_destination_network_modify(
351 enum nb_event event, const struct lyd_node *dnode,
352 union nb_resource *resource)
353{
354 struct filter_cisco *fc;
355 struct filter *f;
356 struct prefix p;
357
358 if (event != NB_EV_APPLY)
359 return NB_OK;
360
361 f = nb_running_get_entry(dnode, NULL, true);
362 fc = &f->u.cfilter;
363 yang_dnode_get_prefix(&p, dnode, NULL);
364 fc->addr.s_addr = ipv4_network_addr(p.u.prefix4.s_addr, p.prefixlen);
365 masklen2ip(p.prefixlen, &fc->addr_mask);
366
367 return NB_OK;
368}
369
370static int lib_access_list_legacy_entry_destination_network_destroy(
371 enum nb_event event, const struct lyd_node *dnode)
372{
373 struct filter_cisco *fc;
374 struct filter *f;
375
376 if (event != NB_EV_APPLY)
377 return NB_OK;
378
379 f = nb_running_get_entry(dnode, NULL, true);
380 fc = &f->u.cfilter;
381 fc->mask.s_addr = INADDR_ANY;
382 fc->mask_mask.s_addr = INADDR_NONE;
383
384 return NB_OK;
385}
386
387/*
388 * XPath: /frr-filter:lib/access-list-legacy/entry/destination-any
389 */
390static int lib_access_list_legacy_entry_destination_any_create(
391 enum nb_event event, const struct lyd_node *dnode,
392 union nb_resource *resource)
393{
394 struct filter_cisco *fc;
395 struct filter *f;
396
397 if (event != NB_EV_APPLY)
398 return NB_OK;
399
400 f = nb_running_get_entry(dnode, NULL, true);
401 fc = &f->u.cfilter;
402 fc->mask.s_addr = INADDR_ANY;
403 fc->mask_mask.s_addr = INADDR_NONE;
404
405 return NB_OK;
406}
407
408static int lib_access_list_legacy_entry_destination_any_destroy(
409 enum nb_event event, const struct lyd_node *dnode)
410{
411 struct filter_cisco *fc;
412 struct filter *f;
413
414 if (event != NB_EV_APPLY)
415 return NB_OK;
416
417 f = nb_running_get_entry(dnode, NULL, true);
418 fc = &f->u.cfilter;
419 fc->mask.s_addr = INADDR_ANY;
420 fc->mask_mask.s_addr = INADDR_NONE;
421
422 return NB_OK;
423}
424
425/*
426 * XPath: /frr-filter:lib/access-list
427 */
428static int lib_access_list_create(enum nb_event event,
429 const struct lyd_node *dnode,
430 union nb_resource *resource)
431{
432 struct access_list *acl;
433 const char *acl_name;
434 int type;
435
436 if (event != NB_EV_APPLY)
437 return NB_OK;
438
439 type = yang_dnode_get_enum(dnode, "./type");
440 acl_name = yang_dnode_get_string(dnode, "./name");
441
442 switch (type) {
443 case 0: /* ipv4 */
444 acl = access_list_get(AFI_IP, acl_name);
445 break;
446 case 1: /* ipv6 */
447 acl = access_list_get(AFI_IP6, acl_name);
448 break;
449 case 2: /* mac */
450 acl = access_list_get(AFI_L2VPN, acl_name);
451 break;
452 }
453
454 nb_running_set_entry(dnode, acl);
455
456 return NB_OK;
457}
458
459static int lib_access_list_destroy(enum nb_event event,
460 const struct lyd_node *dnode)
461{
462 struct access_master *am;
463 struct access_list *acl;
464
465 if (event != NB_EV_APPLY)
466 return NB_OK;
467
468 acl = nb_running_unset_entry(dnode);
469 am = acl->master;
470 if (am->delete_hook)
471 am->delete_hook(acl);
472
473 access_list_delete(acl);
474
475 return NB_OK;
476}
477
478/*
479 * XPath: /frr-filter:lib/access-list/remark
480 */
481static int lib_access_list_remark_modify(enum nb_event event,
482 const struct lyd_node *dnode,
483 union nb_resource *resource)
484{
485 return lib_access_list_legacy_remark_modify(event, dnode, resource);
486}
487
488static int lib_access_list_remark_destroy(enum nb_event event,
489 const struct lyd_node *dnode)
490{
491 return lib_access_list_legacy_remark_destroy(event, dnode);
492}
493
494/*
495 * XPath: /frr-filter:lib/access-list/entry
496 */
497static int lib_access_list_entry_create(enum nb_event event,
498 const struct lyd_node *dnode,
499 union nb_resource *resource)
500{
501 struct access_list *acl;
502 struct filter *f;
503
504 /* TODO: validate `filter_lookup_zebra` returns NULL. */
505
506 if (event != NB_EV_APPLY)
507 return NB_OK;
508
509 f = filter_new();
510 f->seq = yang_dnode_get_uint32(dnode, "./sequence");
511
512 acl = nb_running_get_entry(dnode, NULL, true);
513 f->acl = acl;
514 access_list_filter_add(acl, f);
515 nb_running_set_entry(dnode, f);
516
517 return NB_OK;
518}
519
520static int lib_access_list_entry_destroy(enum nb_event event,
521 const struct lyd_node *dnode)
522{
523 struct access_list *acl;
524 struct filter *f;
525
526 if (event != NB_EV_APPLY)
527 return NB_OK;
528
529 f = nb_running_unset_entry(dnode);
530 acl = f->acl;
531 access_list_filter_delete(acl, f);
532
533 return NB_OK;
534}
535
536/*
537 * XPath: /frr-filter:lib/access-list/entry/action
538 */
539static int lib_access_list_entry_action_modify(enum nb_event event,
540 const struct lyd_node *dnode,
541 union nb_resource *resource)
542{
543 return lib_access_list_legacy_entry_action_modify(event, dnode,
544 resource);
545}
546
547/*
548 * XPath: /frr-filter:lib/access-list/entry/ipv4-prefix
549 */
550static int
551lib_access_list_entry_ipv4_prefix_modify(enum nb_event event,
552 const struct lyd_node *dnode,
553 union nb_resource *resource)
554{
555 struct filter_zebra *fz;
556 struct filter *f;
557
558 if (event != NB_EV_APPLY)
559 return NB_OK;
560
561 f = nb_running_get_entry(dnode, NULL, true);
562 fz = &f->u.zfilter;
563 yang_dnode_get_prefix(&fz->prefix, dnode, NULL);
564
565 return NB_OK;
566}
567
568static int
569lib_access_list_entry_ipv4_prefix_destroy(enum nb_event event,
570 const struct lyd_node *dnode)
571{
572 struct filter_zebra *fz;
573 struct filter *f;
574
575 if (event != NB_EV_APPLY)
576 return NB_OK;
577
578 f = nb_running_get_entry(dnode, NULL, true);
579 fz = &f->u.zfilter;
580 memset(&fz->prefix, 0, sizeof(fz->prefix));
581
582 return NB_OK;
583}
584
585/*
586 * XPath: /frr-filter:lib/access-list/entry/ipv4-exact-match
587 */
588static int
589lib_access_list_entry_ipv4_exact_match_modify(enum nb_event event,
590 const struct lyd_node *dnode,
591 union nb_resource *resource)
592{
593 struct filter_zebra *fz;
594 struct filter *f;
595
596 if (event != NB_EV_APPLY)
597 return NB_OK;
598
599 f = nb_running_get_entry(dnode, NULL, true);
600 fz = &f->u.zfilter;
601 fz->exact = yang_dnode_get_bool(dnode, NULL);
602
603 return NB_OK;
604}
605
606static int
607lib_access_list_entry_ipv4_exact_match_destroy(enum nb_event event,
608 const struct lyd_node *dnode)
609{
610 struct filter_zebra *fz;
611 struct filter *f;
612
613 if (event != NB_EV_APPLY)
614 return NB_OK;
615
616 f = nb_running_get_entry(dnode, NULL, true);
617 fz = &f->u.zfilter;
618 fz->exact = 0;
619
620 return NB_OK;
621}
622
623/*
624 * XPath: /frr-filter:lib/access-list/entry/ipv6-prefix
625 */
626static int
627lib_access_list_entry_ipv6_prefix_modify(enum nb_event event,
628 const struct lyd_node *dnode,
629 union nb_resource *resource)
630{
631 return lib_access_list_entry_ipv4_prefix_modify(event, dnode, resource);
632}
633
634static int
635lib_access_list_entry_ipv6_prefix_destroy(enum nb_event event,
636 const struct lyd_node *dnode)
637{
638 return lib_access_list_entry_ipv4_prefix_destroy(event, dnode);
639}
640
641/*
642 * XPath: /frr-filter:lib/access-list/entry/ipv6-exact-match
643 */
644static int
645lib_access_list_entry_ipv6_exact_match_modify(enum nb_event event,
646 const struct lyd_node *dnode,
647 union nb_resource *resource)
648{
649 return lib_access_list_entry_ipv4_exact_match_modify(event, dnode,
650 resource);
651}
652
653static int
654lib_access_list_entry_ipv6_exact_match_destroy(enum nb_event event,
655 const struct lyd_node *dnode)
656{
657 return lib_access_list_entry_ipv4_exact_match_destroy(event, dnode);
658}
659
660/*
661 * XPath: /frr-filter:lib/access-list/entry/mac
662 */
663static int lib_access_list_entry_mac_modify(enum nb_event event,
664 const struct lyd_node *dnode,
665 union nb_resource *resource)
666{
667 return lib_access_list_entry_ipv4_prefix_modify(event, dnode, resource);
668}
669
670static int lib_access_list_entry_mac_destroy(enum nb_event event,
671 const struct lyd_node *dnode)
672{
673 return lib_access_list_entry_ipv4_prefix_destroy(event, dnode);
674}
675
676/*
677 * XPath: /frr-filter:lib/access-list/entry/any
678 */
679static int lib_access_list_entry_any_create(enum nb_event event,
680 const struct lyd_node *dnode,
681 union nb_resource *resource)
682{
683 struct filter_zebra *fz;
684 struct filter *f;
685 int type;
686
687 if (event != NB_EV_APPLY)
688 return NB_OK;
689
690 f = nb_running_get_entry(dnode, NULL, true);
691 fz = &f->u.zfilter;
692 memset(&fz->prefix, 0, sizeof(fz->prefix));
693
694 type = yang_dnode_get_enum(dnode, "../../type");
695 switch (type) {
696 case 0: /* ipv4 */
697 fz->prefix.family = AF_INET;
698 break;
699 case 1: /* ipv6 */
700 fz->prefix.family = AF_INET6;
701 break;
702 case 2: /* mac */
703 fz->prefix.family = AF_ETHERNET;
704 break;
705 }
706
707 return NB_OK;
708}
709
710static int lib_access_list_entry_any_destroy(enum nb_event event,
711 const struct lyd_node *dnode)
712{
713 struct filter_zebra *fz;
714 struct filter *f;
715
716 if (event != NB_EV_APPLY)
717 return NB_OK;
718
719 f = nb_running_get_entry(dnode, NULL, true);
720 fz = &f->u.zfilter;
721 fz->prefix.family = 0;
722
723 return NB_OK;
724}
725
726/*
727 * XPath: /frr-filter:lib/prefix-list
728 */
729static int lib_prefix_list_create(enum nb_event event,
730 const struct lyd_node *dnode,
731 union nb_resource *resource)
732{
733 struct prefix_list *pl;
734 const char *name;
735 int type;
736
737 /* TODO: validate prefix_entry_dup_check() passes. */
738
739 if (event != NB_EV_APPLY)
740 return NB_OK;
741
742 type = yang_dnode_get_enum(dnode, "./type");
743 name = yang_dnode_get_string(dnode, "./name");
744 switch (type) {
745 case 0: /* ipv4 */
746 pl = prefix_list_get(AFI_IP, 0, name);
747 break;
748 case 1: /* ipv6 */
749 pl = prefix_list_get(AFI_IP6, 0, name);
750 break;
751 }
752
753 nb_running_set_entry(dnode, pl);
754
755 return NB_OK;
756}
757
758static int lib_prefix_list_destroy(enum nb_event event,
759 const struct lyd_node *dnode)
760{
761 struct prefix_list *pl;
762
763 if (event != NB_EV_APPLY)
764 return NB_OK;
765
766 pl = nb_running_unset_entry(dnode);
767 prefix_list_delete(pl);
768
769 return NB_OK;
770}
771
772/*
773 * XPath: /frr-filter:lib/prefix-list/description
774 */
775static int lib_prefix_list_description_modify(enum nb_event event,
776 const struct lyd_node *dnode,
777 union nb_resource *resource)
778{
779 struct prefix_list *pl;
780 const char *remark;
781
782 if (event != NB_EV_APPLY)
783 return NB_OK;
784
785 pl = nb_running_get_entry(dnode, NULL, true);
786 if (pl->desc)
787 XFREE(MTYPE_TMP, pl->desc);
788
789 remark = yang_dnode_get_string(dnode, NULL);
790 pl->desc = XSTRDUP(MTYPE_TMP, remark);
791
792 return NB_OK;
793}
794
795static int lib_prefix_list_description_destroy(enum nb_event event,
796 const struct lyd_node *dnode)
797{
798 struct prefix_list *pl;
799
800 if (event != NB_EV_APPLY)
801 return NB_OK;
802
803 pl = nb_running_get_entry(dnode, NULL, true);
804 if (pl->desc)
805 XFREE(MTYPE_TMP, pl->desc);
806
807 pl->desc = NULL;
808
809 return NB_OK;
810}
811
812/*
813 * XPath: /frr-filter:lib/prefix-list/entry
814 */
815static int lib_prefix_list_entry_create(enum nb_event event,
816 const struct lyd_node *dnode,
817 union nb_resource *resource)
818{
819 struct prefix_list_entry *ple;
820 struct prefix_list *pl;
821 struct prefix p;
822
823 if (event != NB_EV_APPLY)
824 return NB_OK;
825
826 memset(&p, 0, sizeof(p));
827
828 pl = nb_running_get_entry(dnode, NULL, true);
829 ple = prefix_list_entry_new();
830 ple->pl = pl;
831 ple->any = 1;
832 ple->seq = yang_dnode_get_int64(dnode, "./sequence");
833
834 return NB_OK;
835}
836
837static int lib_prefix_list_entry_destroy(enum nb_event event,
838 const struct lyd_node *dnode)
839{
840 struct prefix_list_entry *ple;
841
842 if (event != NB_EV_APPLY)
843 return NB_OK;
844
845 ple = nb_running_unset_entry(dnode);
846 prefix_list_entry_delete(ple->pl, ple, 1);
847
848 return NB_OK;
849}
850
851/*
852 * XPath: /frr-filter:lib/prefix-list/entry/action
853 */
854static int lib_prefix_list_entry_action_modify(enum nb_event event,
855 const struct lyd_node *dnode,
856 union nb_resource *resource)
857{
858 struct prefix_list_entry *ple;
859 const char *action_str;
860
861 if (event != NB_EV_APPLY)
862 return NB_OK;
863
864 ple = nb_running_get_entry(dnode, NULL, true);
865 action_str = yang_dnode_get_string(dnode, "./action");
866 if (strcmp(action_str, "permit") == 0)
867 ple->type = PREFIX_PERMIT;
868 else
869 ple->type = PREFIX_DENY;
870
871 return NB_OK;
872}
873
874/*
875 * XPath: /frr-filter:lib/prefix-list/entry/ipv4-prefix
876 */
877static int
878lib_prefix_list_entry_ipv4_prefix_modify(enum nb_event event,
879 const struct lyd_node *dnode,
880 union nb_resource *resource)
881{
882 struct prefix_list_entry *ple;
883
884 if (event != NB_EV_APPLY)
885 return NB_OK;
886
887 ple = nb_running_get_entry(dnode, NULL, true);
888 yang_dnode_get_prefix(&ple->prefix, dnode, NULL);
889
890 return NB_OK;
891}
892
893static int
894lib_prefix_list_entry_ipv4_prefix_destroy(enum nb_event event,
895 const struct lyd_node *dnode)
896{
897 struct prefix_list_entry *ple;
898
899 if (event != NB_EV_APPLY)
900 return NB_OK;
901
902 ple = nb_running_get_entry(dnode, NULL, true);
903 memset(&ple->prefix, 0, sizeof(ple->prefix));
904 ple->any = 1;
905
906 return NB_OK;
907}
908
909/*
910 * XPath: /frr-filter:lib/prefix-list/entry/ipv4-prefix-length-greater-or-equal
911 */
912static int lib_prefix_list_entry_ipv4_prefix_length_greater_or_equal_modify(
913 enum nb_event event, const struct lyd_node *dnode,
914 union nb_resource *resource)
915{
916 struct prefix_list_entry *ple;
917
918 if (event != NB_EV_APPLY)
919 return NB_OK;
920
921 ple = nb_running_get_entry(dnode, NULL, true);
922 ple->ge = yang_dnode_get_uint8(dnode, NULL);
923
924 return NB_OK;
925}
926
927static int lib_prefix_list_entry_ipv4_prefix_length_greater_or_equal_destroy(
928 enum nb_event event, const struct lyd_node *dnode)
929{
930 struct prefix_list_entry *ple;
931
932 if (event != NB_EV_APPLY)
933 return NB_OK;
934
935 ple = nb_running_get_entry(dnode, NULL, true);
936 ple->ge = 0;
937
938 return NB_OK;
939}
940
941/*
942 * XPath: /frr-filter:lib/prefix-list/entry/ipv4-prefix-length-lesser-or-equal
943 */
944static int lib_prefix_list_entry_ipv4_prefix_length_lesser_or_equal_modify(
945 enum nb_event event, const struct lyd_node *dnode,
946 union nb_resource *resource)
947{
948 struct prefix_list_entry *ple;
949
950 if (event != NB_EV_APPLY)
951 return NB_OK;
952
953 ple = nb_running_get_entry(dnode, NULL, true);
954 ple->le = yang_dnode_get_uint8(dnode, NULL);
955
956 return NB_OK;
957}
958
959static int lib_prefix_list_entry_ipv4_prefix_length_lesser_or_equal_destroy(
960 enum nb_event event, const struct lyd_node *dnode)
961{
962 struct prefix_list_entry *ple;
963
964 if (event != NB_EV_APPLY)
965 return NB_OK;
966
967 ple = nb_running_get_entry(dnode, NULL, true);
968 ple->le = 0;
969
970 return NB_OK;
971}
972
973/*
974 * XPath: /frr-filter:lib/prefix-list/entry/ipv6-prefix
975 */
976static int
977lib_prefix_list_entry_ipv6_prefix_modify(enum nb_event event,
978 const struct lyd_node *dnode,
979 union nb_resource *resource)
980{
981 return lib_prefix_list_entry_ipv4_prefix_modify(event, dnode, resource);
982}
983
984static int
985lib_prefix_list_entry_ipv6_prefix_destroy(enum nb_event event,
986 const struct lyd_node *dnode)
987{
988 return lib_prefix_list_entry_ipv4_prefix_destroy(event, dnode);
989}
990
991/*
992 * XPath: /frr-filter:lib/prefix-list/entry/ipv6-prefix-length-greater-or-equal
993 */
994static int lib_prefix_list_entry_ipv6_prefix_length_greater_or_equal_modify(
995 enum nb_event event, const struct lyd_node *dnode,
996 union nb_resource *resource)
997{
998 return lib_prefix_list_entry_ipv4_prefix_length_greater_or_equal_modify(
999 event, dnode, resource);
1000}
1001
1002static int lib_prefix_list_entry_ipv6_prefix_length_greater_or_equal_destroy(
1003 enum nb_event event, const struct lyd_node *dnode)
1004{
1005 return lib_prefix_list_entry_ipv4_prefix_length_greater_or_equal_destroy(
1006 event, dnode);
1007}
1008
1009/*
1010 * XPath: /frr-filter:lib/prefix-list/entry/ipv6-prefix-length-lesser-or-equal
1011 */
1012static int lib_prefix_list_entry_ipv6_prefix_length_lesser_or_equal_modify(
1013 enum nb_event event, const struct lyd_node *dnode,
1014 union nb_resource *resource)
1015{
1016 return lib_prefix_list_entry_ipv4_prefix_length_lesser_or_equal_modify(
1017 event, dnode, resource);
1018}
1019
1020static int lib_prefix_list_entry_ipv6_prefix_length_lesser_or_equal_destroy(
1021 enum nb_event event, const struct lyd_node *dnode)
1022{
1023 return lib_prefix_list_entry_ipv4_prefix_length_lesser_or_equal_destroy(
1024 event, dnode);
1025}
1026
1027/*
1028 * XPath: /frr-filter:lib/prefix-list/entry/any
1029 */
1030static int lib_prefix_list_entry_any_create(enum nb_event event,
1031 const struct lyd_node *dnode,
1032 union nb_resource *resource)
1033{
1034 struct prefix_list_entry *ple;
1035
1036 if (event != NB_EV_APPLY)
1037 return NB_OK;
1038
1039 ple = nb_running_get_entry(dnode, NULL, true);
1040 memset(&ple->prefix, 0, sizeof(ple->prefix));
1041 ple->any = 1;
1042
1043 return NB_OK;
1044}
1045
1046static int lib_prefix_list_entry_any_destroy(enum nb_event event,
1047 const struct lyd_node *dnode)
1048{
1049 struct prefix_list_entry *ple;
1050
1051 if (event != NB_EV_APPLY)
1052 return NB_OK;
1053
1054 ple = nb_running_get_entry(dnode, NULL, true);
1055 memset(&ple->prefix, 0, sizeof(ple->prefix));
1056 ple->any = 1;
1057
1058 return NB_OK;
1059}
1060
1061/* clang-format off */
1062const struct frr_yang_module_info frr_filter_info = {
1063 .name = "frr-filter",
1064 .nodes = {
1065 {
1066 .xpath = "/frr-filter:lib/access-list-legacy",
1067 .cbs = {
1068 .create = lib_access_list_legacy_create,
1069 .destroy = lib_access_list_legacy_destroy,
1070 }
1071 },
1072 {
1073 .xpath = "/frr-filter:lib/access-list-legacy/remark",
1074 .cbs = {
1075 .modify = lib_access_list_legacy_remark_modify,
1076 .destroy = lib_access_list_legacy_remark_destroy,
1077 }
1078 },
1079 {
1080 .xpath = "/frr-filter:lib/access-list-legacy/entry",
1081 .cbs = {
1082 .create = lib_access_list_legacy_entry_create,
1083 .destroy = lib_access_list_legacy_entry_destroy,
1084 }
1085 },
1086 {
1087 .xpath = "/frr-filter:lib/access-list-legacy/entry/action",
1088 .cbs = {
1089 .modify = lib_access_list_legacy_entry_action_modify,
1090 }
1091 },
1092 {
1093 .xpath = "/frr-filter:lib/access-list-legacy/entry/host",
1094 .cbs = {
1095 .modify = lib_access_list_legacy_entry_host_modify,
1096 .destroy = lib_access_list_legacy_entry_host_destroy,
1097 }
1098 },
1099 {
1100 .xpath = "/frr-filter:lib/access-list-legacy/entry/network",
1101 .cbs = {
1102 .modify = lib_access_list_legacy_entry_network_modify,
1103 .destroy = lib_access_list_legacy_entry_network_destroy,
1104 }
1105 },
1106 {
1107 .xpath = "/frr-filter:lib/access-list-legacy/entry/any",
1108 .cbs = {
1109 .create = lib_access_list_legacy_entry_any_create,
1110 .destroy = lib_access_list_legacy_entry_any_destroy,
1111 }
1112 },
1113 {
1114 .xpath = "/frr-filter:lib/access-list-legacy/entry/destination-host",
1115 .cbs = {
1116 .modify = lib_access_list_legacy_entry_destination_host_modify,
1117 .destroy = lib_access_list_legacy_entry_destination_host_destroy,
1118 }
1119 },
1120 {
1121 .xpath = "/frr-filter:lib/access-list-legacy/entry/destination-network",
1122 .cbs = {
1123 .modify = lib_access_list_legacy_entry_destination_network_modify,
1124 .destroy = lib_access_list_legacy_entry_destination_network_destroy,
1125 }
1126 },
1127 {
1128 .xpath = "/frr-filter:lib/access-list-legacy/entry/destination-any",
1129 .cbs = {
1130 .create = lib_access_list_legacy_entry_destination_any_create,
1131 .destroy = lib_access_list_legacy_entry_destination_any_destroy,
1132 }
1133 },
1134 {
1135 .xpath = "/frr-filter:lib/access-list",
1136 .cbs = {
1137 .create = lib_access_list_create,
1138 .destroy = lib_access_list_destroy,
1139 }
1140 },
1141 {
1142 .xpath = "/frr-filter:lib/access-list/remark",
1143 .cbs = {
1144 .modify = lib_access_list_remark_modify,
1145 .destroy = lib_access_list_remark_destroy,
1146 }
1147 },
1148 {
1149 .xpath = "/frr-filter:lib/access-list/entry",
1150 .cbs = {
1151 .create = lib_access_list_entry_create,
1152 .destroy = lib_access_list_entry_destroy,
1153 }
1154 },
1155 {
1156 .xpath = "/frr-filter:lib/access-list/entry/action",
1157 .cbs = {
1158 .modify = lib_access_list_entry_action_modify,
1159 }
1160 },
1161 {
1162 .xpath = "/frr-filter:lib/access-list/entry/ipv4-prefix",
1163 .cbs = {
1164 .modify = lib_access_list_entry_ipv4_prefix_modify,
1165 .destroy = lib_access_list_entry_ipv4_prefix_destroy,
1166 }
1167 },
1168 {
1169 .xpath = "/frr-filter:lib/access-list/entry/ipv4-exact-match",
1170 .cbs = {
1171 .modify = lib_access_list_entry_ipv4_exact_match_modify,
1172 .destroy = lib_access_list_entry_ipv4_exact_match_destroy,
1173 }
1174 },
1175 {
1176 .xpath = "/frr-filter:lib/access-list/entry/ipv6-prefix",
1177 .cbs = {
1178 .modify = lib_access_list_entry_ipv6_prefix_modify,
1179 .destroy = lib_access_list_entry_ipv6_prefix_destroy,
1180 }
1181 },
1182 {
1183 .xpath = "/frr-filter:lib/access-list/entry/ipv6-exact-match",
1184 .cbs = {
1185 .modify = lib_access_list_entry_ipv6_exact_match_modify,
1186 .destroy = lib_access_list_entry_ipv6_exact_match_destroy,
1187 }
1188 },
1189 {
1190 .xpath = "/frr-filter:lib/access-list/entry/mac",
1191 .cbs = {
1192 .modify = lib_access_list_entry_mac_modify,
1193 .destroy = lib_access_list_entry_mac_destroy,
1194 }
1195 },
1196 {
1197 .xpath = "/frr-filter:lib/access-list/entry/any",
1198 .cbs = {
1199 .create = lib_access_list_entry_any_create,
1200 .destroy = lib_access_list_entry_any_destroy,
1201 }
1202 },
1203 {
1204 .xpath = "/frr-filter:lib/prefix-list",
1205 .cbs = {
1206 .create = lib_prefix_list_create,
1207 .destroy = lib_prefix_list_destroy,
1208 }
1209 },
1210 {
1211 .xpath = "/frr-filter:lib/prefix-list/description",
1212 .cbs = {
1213 .modify = lib_prefix_list_description_modify,
1214 .destroy = lib_prefix_list_description_destroy,
1215 }
1216 },
1217 {
1218 .xpath = "/frr-filter:lib/prefix-list/entry",
1219 .cbs = {
1220 .create = lib_prefix_list_entry_create,
1221 .destroy = lib_prefix_list_entry_destroy,
1222 }
1223 },
1224 {
1225 .xpath = "/frr-filter:lib/prefix-list/entry/action",
1226 .cbs = {
1227 .modify = lib_prefix_list_entry_action_modify,
1228 }
1229 },
1230 {
1231 .xpath = "/frr-filter:lib/prefix-list/entry/ipv4-prefix",
1232 .cbs = {
1233 .modify = lib_prefix_list_entry_ipv4_prefix_modify,
1234 .destroy = lib_prefix_list_entry_ipv4_prefix_destroy,
1235 }
1236 },
1237 {
1238 .xpath = "/frr-filter:lib/prefix-list/entry/ipv4-prefix-length-greater-or-equal",
1239 .cbs = {
1240 .modify = lib_prefix_list_entry_ipv4_prefix_length_greater_or_equal_modify,
1241 .destroy = lib_prefix_list_entry_ipv4_prefix_length_greater_or_equal_destroy,
1242 }
1243 },
1244 {
1245 .xpath = "/frr-filter:lib/prefix-list/entry/ipv4-prefix-length-lesser-or-equal",
1246 .cbs = {
1247 .modify = lib_prefix_list_entry_ipv4_prefix_length_lesser_or_equal_modify,
1248 .destroy = lib_prefix_list_entry_ipv4_prefix_length_lesser_or_equal_destroy,
1249 }
1250 },
1251 {
1252 .xpath = "/frr-filter:lib/prefix-list/entry/ipv6-prefix",
1253 .cbs = {
1254 .modify = lib_prefix_list_entry_ipv6_prefix_modify,
1255 .destroy = lib_prefix_list_entry_ipv6_prefix_destroy,
1256 }
1257 },
1258 {
1259 .xpath = "/frr-filter:lib/prefix-list/entry/ipv6-prefix-length-greater-or-equal",
1260 .cbs = {
1261 .modify = lib_prefix_list_entry_ipv6_prefix_length_greater_or_equal_modify,
1262 .destroy = lib_prefix_list_entry_ipv6_prefix_length_greater_or_equal_destroy,
1263 }
1264 },
1265 {
1266 .xpath = "/frr-filter:lib/prefix-list/entry/ipv6-prefix-length-lesser-or-equal",
1267 .cbs = {
1268 .modify = lib_prefix_list_entry_ipv6_prefix_length_lesser_or_equal_modify,
1269 .destroy = lib_prefix_list_entry_ipv6_prefix_length_lesser_or_equal_destroy,
1270 }
1271 },
1272 {
1273 .xpath = "/frr-filter:lib/prefix-list/entry/any",
1274 .cbs = {
1275 .create = lib_prefix_list_entry_any_create,
1276 .destroy = lib_prefix_list_entry_any_destroy,
1277 }
1278 },
1279 {
1280 .xpath = NULL,
1281 },
1282 }
1283};
FRRouting mirror