]> git.proxmox.com Git - mirror_frr.git/blob - lib/distribute.c
Merge pull request #13278 from FRRouting/mergify/bp/stable/8.5/pr-13269
[mirror_frr.git] / lib / distribute.c
1 /* Distribute list functions
2 * Copyright (C) 1998, 1999 Kunihiro Ishiguro
3 *
4 * This file is part of GNU Zebra.
5 *
6 * GNU Zebra is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published
8 * by the Free Software Foundation; either version 2, or (at your
9 * option) any later version.
10 *
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <zebra.h>
22
23 #include "hash.h"
24 #include "if.h"
25 #include "filter.h"
26 #include "command.h"
27 #include "distribute.h"
28 #include "memory.h"
29
30 DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE_CTX, "Distribute ctx");
31 DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE, "Distribute list");
32 DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE_IFNAME, "Dist-list ifname");
33 DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE_NAME, "Dist-list name");
34
35 static struct list *dist_ctx_list;
36
37 static struct distribute *distribute_new(void)
38 {
39 return XCALLOC(MTYPE_DISTRIBUTE, sizeof(struct distribute));
40 }
41
42 /* Free distribute object. */
43 static void distribute_free(struct distribute *dist)
44 {
45 int i = 0;
46
47 XFREE(MTYPE_DISTRIBUTE_IFNAME, dist->ifname);
48
49 for (i = 0; i < DISTRIBUTE_MAX; i++) {
50 XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[i]);
51 }
52
53 for (i = 0; i < DISTRIBUTE_MAX; i++) {
54 XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[i]);
55 }
56
57 XFREE(MTYPE_DISTRIBUTE, dist);
58 }
59
60 static void distribute_free_if_empty(struct distribute_ctx *ctx,
61 struct distribute *dist)
62 {
63 int i;
64
65 for (i = 0; i < DISTRIBUTE_MAX; i++)
66 if (dist->list[i] != NULL || dist->prefix[i] != NULL)
67 return;
68
69 hash_release(ctx->disthash, dist);
70 distribute_free(dist);
71 }
72
73 /* Lookup interface's distribute list. */
74 struct distribute *distribute_lookup(struct distribute_ctx *ctx,
75 const char *ifname)
76 {
77 struct distribute key;
78 struct distribute *dist;
79
80 /* temporary reference */
81 key.ifname = (ifname) ? XSTRDUP(MTYPE_DISTRIBUTE_IFNAME, ifname) : NULL;
82
83 dist = hash_lookup(ctx->disthash, &key);
84
85 XFREE(MTYPE_DISTRIBUTE_IFNAME, key.ifname);
86
87 return dist;
88 }
89
90 void distribute_list_add_hook(struct distribute_ctx *ctx,
91 void (*func)(struct distribute_ctx *ctx,
92 struct distribute *))
93 {
94 ctx->distribute_add_hook = func;
95 }
96
97 void distribute_list_delete_hook(struct distribute_ctx *ctx,
98 void (*func)(struct distribute_ctx *ctx,
99 struct distribute *))
100 {
101 ctx->distribute_delete_hook = func;
102 }
103
104 static void *distribute_hash_alloc(struct distribute *arg)
105 {
106 struct distribute *dist;
107
108 dist = distribute_new();
109 if (arg->ifname)
110 dist->ifname = XSTRDUP(MTYPE_DISTRIBUTE_IFNAME, arg->ifname);
111 else
112 dist->ifname = NULL;
113 return dist;
114 }
115
116 /* Make new distribute list and push into hash. */
117 static struct distribute *distribute_get(struct distribute_ctx *ctx,
118 const char *ifname)
119 {
120 struct distribute key;
121 struct distribute *ret;
122
123 /* temporary reference */
124 key.ifname = (ifname) ? XSTRDUP(MTYPE_DISTRIBUTE_IFNAME, ifname) : NULL;
125
126 ret = hash_get(ctx->disthash, &key,
127 (void *(*)(void *))distribute_hash_alloc);
128
129 XFREE(MTYPE_DISTRIBUTE_IFNAME, key.ifname);
130
131 return ret;
132 }
133
134 static unsigned int distribute_hash_make(const void *arg)
135 {
136 const struct distribute *dist = arg;
137
138 return dist->ifname ? string_hash_make(dist->ifname) : 0;
139 }
140
141 /* If two distribute-list have same value then return 1 else return
142 0. This function is used by hash package. */
143 static bool distribute_cmp(const struct distribute *dist1,
144 const struct distribute *dist2)
145 {
146 if (dist1->ifname && dist2->ifname)
147 if (strcmp(dist1->ifname, dist2->ifname) == 0)
148 return true;
149 if (!dist1->ifname && !dist2->ifname)
150 return true;
151 return false;
152 }
153
154 /* Set access-list name to the distribute list. */
155 static void distribute_list_set(struct distribute_ctx *ctx,
156 const char *ifname, enum distribute_type type,
157 const char *alist_name)
158 {
159 struct distribute *dist;
160
161 dist = distribute_get(ctx, ifname);
162
163 XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[type]);
164 dist->list[type] = XSTRDUP(MTYPE_DISTRIBUTE_NAME, alist_name);
165
166 /* Apply this distribute-list to the interface. */
167 (ctx->distribute_add_hook)(ctx, dist);
168 }
169
170 /* Unset distribute-list. If matched distribute-list exist then
171 return 1. */
172 static int distribute_list_unset(struct distribute_ctx *ctx,
173 const char *ifname,
174 enum distribute_type type,
175 const char *alist_name)
176 {
177 struct distribute *dist;
178
179 dist = distribute_lookup(ctx, ifname);
180 if (!dist)
181 return 0;
182
183 if (!dist->list[type])
184 return 0;
185 if (strcmp(dist->list[type], alist_name) != 0)
186 return 0;
187
188 XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[type]);
189
190 /* Apply this distribute-list to the interface. */
191 (ctx->distribute_delete_hook)(ctx, dist);
192
193 /* If all dist are NULL, then free distribute list. */
194 distribute_free_if_empty(ctx, dist);
195 return 1;
196 }
197
198 /* Set access-list name to the distribute list. */
199 static void distribute_list_prefix_set(struct distribute_ctx *ctx,
200 const char *ifname,
201 enum distribute_type type,
202 const char *plist_name)
203 {
204 struct distribute *dist;
205
206 dist = distribute_get(ctx, ifname);
207
208 XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[type]);
209 dist->prefix[type] = XSTRDUP(MTYPE_DISTRIBUTE_NAME, plist_name);
210
211 /* Apply this distribute-list to the interface. */
212 (ctx->distribute_add_hook)(ctx, dist);
213 }
214
215 /* Unset distribute-list. If matched distribute-list exist then
216 return 1. */
217 static int distribute_list_prefix_unset(struct distribute_ctx *ctx,
218 const char *ifname,
219 enum distribute_type type,
220 const char *plist_name)
221 {
222 struct distribute *dist;
223
224 dist = distribute_lookup(ctx, ifname);
225 if (!dist)
226 return 0;
227
228 if (!dist->prefix[type])
229 return 0;
230 if (strcmp(dist->prefix[type], plist_name) != 0)
231 return 0;
232
233 XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[type]);
234
235 /* Apply this distribute-list to the interface. */
236 (ctx->distribute_delete_hook)(ctx, dist);
237
238 /* If all dist are NULL, then free distribute list. */
239 distribute_free_if_empty(ctx, dist);
240 return 1;
241 }
242
243 static enum distribute_type distribute_direction(const char *dir, bool v4)
244 {
245 if (dir[0] == 'i') {
246 if (v4)
247 return DISTRIBUTE_V4_IN;
248 else
249 return DISTRIBUTE_V6_IN;
250 } else if (dir[0] == 'o') {
251 if (v4)
252 return DISTRIBUTE_V4_OUT;
253 else
254 return DISTRIBUTE_V6_OUT;
255 }
256
257 assert(!"Expecting in or out only, fix your code");
258
259 __builtin_unreachable();
260 }
261
262 int distribute_list_parser(bool prefix, bool v4, const char *dir,
263 const char *list, const char *ifname)
264 {
265 enum distribute_type type = distribute_direction(dir, v4);
266 struct distribute_ctx *ctx = listnode_head(dist_ctx_list);
267
268 void (*distfn)(struct distribute_ctx *, const char *,
269 enum distribute_type, const char *) =
270 prefix ? &distribute_list_prefix_set : &distribute_list_set;
271
272 distfn(ctx, ifname, type, list);
273
274 return CMD_SUCCESS;
275 }
276
277 int distribute_list_no_parser(struct vty *vty, bool prefix, bool v4,
278 const char *dir, const char *list,
279 const char *ifname)
280 {
281 enum distribute_type type = distribute_direction(dir, v4);
282 struct distribute_ctx *ctx = listnode_head(dist_ctx_list);
283 int ret;
284
285 int (*distfn)(struct distribute_ctx *, const char *,
286 enum distribute_type, const char *) =
287 prefix ? &distribute_list_prefix_unset : &distribute_list_unset;
288
289
290 ret = distfn(ctx, ifname, type, list);
291 if (!ret) {
292 vty_out(vty, "distribute list doesn't exist\n");
293 return CMD_WARNING_CONFIG_FAILED;
294 }
295
296 return CMD_SUCCESS;
297 }
298
299 static int distribute_print(struct vty *vty, char *tab[], int is_prefix,
300 enum distribute_type type, int has_print)
301 {
302 if (tab[type]) {
303 vty_out(vty, "%s %s%s", has_print ? "," : "",
304 is_prefix ? "(prefix-list) " : "", tab[type]);
305 return 1;
306 }
307 return has_print;
308 }
309
310 int config_show_distribute(struct vty *vty, struct distribute_ctx *dist_ctxt)
311 {
312 unsigned int i;
313 int has_print = 0;
314 struct hash_bucket *mp;
315 struct distribute *dist;
316
317 /* Output filter configuration. */
318 dist = distribute_lookup(dist_ctxt, NULL);
319 vty_out(vty, " Outgoing update filter list for all interface is");
320 has_print = 0;
321 if (dist) {
322 has_print = distribute_print(vty, dist->list, 0,
323 DISTRIBUTE_V4_OUT, has_print);
324 has_print = distribute_print(vty, dist->prefix, 1,
325 DISTRIBUTE_V4_OUT, has_print);
326 has_print = distribute_print(vty, dist->list, 0,
327 DISTRIBUTE_V6_OUT, has_print);
328 has_print = distribute_print(vty, dist->prefix, 1,
329 DISTRIBUTE_V6_OUT, has_print);
330 }
331 if (has_print)
332 vty_out(vty, "\n");
333 else
334 vty_out(vty, " not set\n");
335
336 for (i = 0; i < dist_ctxt->disthash->size; i++)
337 for (mp = dist_ctxt->disthash->index[i]; mp; mp = mp->next) {
338 dist = mp->data;
339 if (dist->ifname) {
340 vty_out(vty, " %s filtered by",
341 dist->ifname);
342 has_print = 0;
343 has_print = distribute_print(vty, dist->list, 0,
344 DISTRIBUTE_V4_OUT,
345 has_print);
346 has_print = distribute_print(
347 vty, dist->prefix, 1, DISTRIBUTE_V4_OUT,
348 has_print);
349 has_print = distribute_print(vty, dist->list, 0,
350 DISTRIBUTE_V6_OUT,
351 has_print);
352 has_print = distribute_print(
353 vty, dist->prefix, 1, DISTRIBUTE_V6_OUT,
354 has_print);
355 if (has_print)
356 vty_out(vty, "\n");
357 else
358 vty_out(vty, " nothing\n");
359 }
360 }
361
362
363 /* Input filter configuration. */
364 dist = distribute_lookup(dist_ctxt, NULL);
365 vty_out(vty, " Incoming update filter list for all interface is");
366 has_print = 0;
367 if (dist) {
368 has_print = distribute_print(vty, dist->list, 0,
369 DISTRIBUTE_V4_IN, has_print);
370 has_print = distribute_print(vty, dist->prefix, 1,
371 DISTRIBUTE_V4_IN, has_print);
372 has_print = distribute_print(vty, dist->list, 0,
373 DISTRIBUTE_V6_IN, has_print);
374 has_print = distribute_print(vty, dist->prefix, 1,
375 DISTRIBUTE_V6_IN, has_print);
376 }
377 if (has_print)
378 vty_out(vty, "\n");
379 else
380 vty_out(vty, " not set\n");
381
382 for (i = 0; i < dist_ctxt->disthash->size; i++)
383 for (mp = dist_ctxt->disthash->index[i]; mp; mp = mp->next) {
384 dist = mp->data;
385 if (dist->ifname) {
386 vty_out(vty, " %s filtered by",
387 dist->ifname);
388 has_print = 0;
389 has_print = distribute_print(vty, dist->list, 0,
390 DISTRIBUTE_V4_IN,
391 has_print);
392 has_print = distribute_print(
393 vty, dist->prefix, 1, DISTRIBUTE_V4_IN,
394 has_print);
395 has_print = distribute_print(vty, dist->list, 0,
396 DISTRIBUTE_V6_IN,
397 has_print);
398 has_print = distribute_print(
399 vty, dist->prefix, 1, DISTRIBUTE_V6_IN,
400 has_print);
401 if (has_print)
402 vty_out(vty, "\n");
403 else
404 vty_out(vty, " nothing\n");
405 }
406 }
407 return 0;
408 }
409
410 /* Configuration write function. */
411 int config_write_distribute(struct vty *vty,
412 struct distribute_ctx *dist_ctxt)
413 {
414 unsigned int i;
415 int j;
416 int output, v6;
417 struct hash_bucket *mp;
418 int write = 0;
419
420 for (i = 0; i < dist_ctxt->disthash->size; i++)
421 for (mp = dist_ctxt->disthash->index[i]; mp; mp = mp->next) {
422 struct distribute *dist;
423
424 dist = mp->data;
425
426 for (j = 0; j < DISTRIBUTE_MAX; j++)
427 if (dist->list[j]) {
428 output = j == DISTRIBUTE_V4_OUT
429 || j == DISTRIBUTE_V6_OUT;
430 v6 = j == DISTRIBUTE_V6_IN
431 || j == DISTRIBUTE_V6_OUT;
432 vty_out(vty,
433 " %sdistribute-list %s %s %s\n",
434 v6 ? "ipv6 " : "",
435 dist->list[j],
436 output ? "out" : "in",
437 dist->ifname ? dist->ifname
438 : "");
439 write++;
440 }
441
442 for (j = 0; j < DISTRIBUTE_MAX; j++)
443 if (dist->prefix[j]) {
444 output = j == DISTRIBUTE_V4_OUT
445 || j == DISTRIBUTE_V6_OUT;
446 v6 = j == DISTRIBUTE_V6_IN
447 || j == DISTRIBUTE_V6_OUT;
448 vty_out(vty,
449 " %sdistribute-list prefix %s %s %s\n",
450 v6 ? "ipv6 " : "",
451 dist->prefix[j],
452 output ? "out" : "in",
453 dist->ifname ? dist->ifname
454 : "");
455 write++;
456 }
457 }
458 return write;
459 }
460
461 void distribute_list_delete(struct distribute_ctx **ctx)
462 {
463 if ((*ctx)->disthash) {
464 hash_clean((*ctx)->disthash, (void (*)(void *))distribute_free);
465 }
466 if (!dist_ctx_list)
467 dist_ctx_list = list_new();
468 listnode_delete(dist_ctx_list, *ctx);
469 if (list_isempty(dist_ctx_list))
470 list_delete(&dist_ctx_list);
471 XFREE(MTYPE_DISTRIBUTE_CTX, (*ctx));
472 }
473
474 /* Initialize distribute list container */
475 struct distribute_ctx *distribute_list_ctx_create(struct vrf *vrf)
476 {
477 struct distribute_ctx *ctx;
478
479 ctx = XCALLOC(MTYPE_DISTRIBUTE_CTX, sizeof(struct distribute_ctx));
480 ctx->vrf = vrf;
481 ctx->disthash = hash_create(
482 distribute_hash_make,
483 (bool (*)(const void *, const void *))distribute_cmp, NULL);
484 if (!dist_ctx_list)
485 dist_ctx_list = list_new();
486 listnode_add(dist_ctx_list, ctx);
487 return ctx;
488 }