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
distribute_new(void)37 static struct distribute *distribute_new(void)
38 {
39 return XCALLOC(MTYPE_DISTRIBUTE, sizeof(struct distribute));
40 }
41
42 /* Free distribute object. */
distribute_free(struct distribute * dist)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
distribute_free_if_empty(struct distribute_ctx * ctx,struct distribute * dist)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. */
distribute_lookup(struct distribute_ctx * ctx,const char * ifname)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
distribute_list_add_hook(struct distribute_ctx * ctx,void (* func)(struct distribute_ctx * ctx,struct distribute *))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
distribute_list_delete_hook(struct distribute_ctx * ctx,void (* func)(struct distribute_ctx * ctx,struct distribute *))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
distribute_hash_alloc(struct distribute * arg)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. */
distribute_get(struct distribute_ctx * ctx,const char * ifname)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
distribute_hash_make(const void * arg)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. */
distribute_cmp(const struct distribute * dist1,const struct distribute * dist2)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. */
distribute_list_set(struct distribute_ctx * ctx,const char * ifname,enum distribute_type type,const char * alist_name)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. */
distribute_list_unset(struct distribute_ctx * ctx,const char * ifname,enum distribute_type type,const char * alist_name)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. */
distribute_list_prefix_set(struct distribute_ctx * ctx,const char * ifname,enum distribute_type type,const char * plist_name)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. */
distribute_list_prefix_unset(struct distribute_ctx * ctx,const char * ifname,enum distribute_type type,const char * plist_name)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 DEFUN (distribute_list,
244 distribute_list_cmd,
245 "distribute-list [prefix] WORD <in|out> [WORD]",
246 "Filter networks in routing updates\n"
247 "Specify a prefix\n"
248 "Access-list name\n"
249 "Filter incoming routing updates\n"
250 "Filter outgoing routing updates\n"
251 "Interface name\n")
252 {
253 int prefix = (argv[1]->type == WORD_TKN) ? 1 : 0;
254 /* Check of distribute list type. */
255 enum distribute_type type = argv[2 + prefix]->arg[0] == 'i'
256 ? DISTRIBUTE_V4_IN
257 : DISTRIBUTE_V4_OUT;
258
259 /* Set appropriate function call */
260 void (*distfn)(struct distribute_ctx *, const char *,
261 enum distribute_type, const char *) =
262 prefix ? &distribute_list_prefix_set : &distribute_list_set;
263 struct distribute_ctx *ctx =
264 (struct distribute_ctx *)listnode_head(dist_ctx_list);
265
266 /* if interface is present, get name */
267 const char *ifname = NULL;
268 if (argv[argc - 1]->type == VARIABLE_TKN)
269 ifname = argv[argc - 1]->arg;
270
271 /* Get interface name corresponding distribute list. */
272 distfn(ctx, ifname, type, argv[1 + prefix]->arg);
273
274 return CMD_SUCCESS;
275 }
276
277 DEFUN (ipv6_distribute_list,
278 ipv6_distribute_list_cmd,
279 "ipv6 distribute-list [prefix] WORD <in|out> [WORD]",
280 "IPv6\n"
281 "Filter networks in routing updates\n"
282 "Specify a prefix\n"
283 "Access-list name\n"
284 "Filter incoming routing updates\n"
285 "Filter outgoing routing updates\n"
286 "Interface name\n")
287 {
288 int prefix = (argv[2]->type == WORD_TKN) ? 1 : 0;
289 /* Check of distribute list type. */
290 enum distribute_type type = argv[3 + prefix]->arg[0] == 'i'
291 ? DISTRIBUTE_V6_IN
292 : DISTRIBUTE_V6_OUT;
293
294 /* Set appropriate function call */
295 void (*distfn)(struct distribute_ctx *, const char *,
296 enum distribute_type, const char *) =
297 prefix ? &distribute_list_prefix_set : &distribute_list_set;
298 struct distribute_ctx *ctx = listnode_head(dist_ctx_list);
299
300 /* if interface is present, get name */
301 const char *ifname = NULL;
302 if (argv[argc - 1]->type == VARIABLE_TKN)
303 ifname = argv[argc - 1]->arg;
304
305 /* Get interface name corresponding distribute list. */
306 distfn(ctx, ifname, type, argv[2 + prefix]->arg);
307
308 return CMD_SUCCESS;
309 }
310
311 DEFUN (no_distribute_list,
312 no_distribute_list_cmd,
313 "no distribute-list [prefix] WORD <in|out> [WORD]",
314 NO_STR
315 "Filter networks in routing updates\n"
316 "Specify a prefix\n"
317 "Access-list name\n"
318 "Filter incoming routing updates\n"
319 "Filter outgoing routing updates\n"
320 "Interface name\n")
321 {
322 int prefix = (argv[2]->type == WORD_TKN) ? 1 : 0;
323 int idx_alname = 2 + prefix;
324 int idx_disttype = idx_alname + 1;
325 enum distribute_type type =
326 argv[idx_disttype]->arg[0] == 'i' ?
327 DISTRIBUTE_V4_IN : DISTRIBUTE_V4_OUT;
328
329 /* Set appropriate function call */
330 int (*distfn)(struct distribute_ctx *, const char *,
331 enum distribute_type, const char *) =
332 prefix ? &distribute_list_prefix_unset : &distribute_list_unset;
333 struct distribute_ctx *ctx = listnode_head(dist_ctx_list);
334
335 /* if interface is present, get name */
336 const char *ifname = NULL;
337 if (argv[argc - 1]->type == VARIABLE_TKN)
338 ifname = argv[argc - 1]->arg;
339 /* Get interface name corresponding distribute list. */
340 int ret = distfn(ctx, ifname, type, argv[2 + prefix]->arg);
341
342 if (!ret) {
343 vty_out(vty, "distribute list doesn't exist\n");
344 return CMD_WARNING_CONFIG_FAILED;
345 }
346 return CMD_SUCCESS;
347 }
348
349 DEFUN (no_ipv6_distribute_list,
350 no_ipv6_distribute_list_cmd,
351 "no ipv6 distribute-list [prefix] WORD <in|out> [WORD]",
352 NO_STR
353 "IPv6\n"
354 "Filter networks in routing updates\n"
355 "Specify a prefix\n"
356 "Access-list name\n"
357 "Filter incoming routing updates\n"
358 "Filter outgoing routing updates\n"
359 "Interface name\n")
360 {
361 int prefix = (argv[3]->type == WORD_TKN) ? 1 : 0;
362 int idx_alname = 3 + prefix;
363 int idx_disttype = idx_alname + 1;
364
365 enum distribute_type type =
366 argv[idx_disttype]->arg[0] == 'i' ?
367 DISTRIBUTE_V6_IN : DISTRIBUTE_V6_OUT;
368 struct distribute_ctx *ctx = listnode_head(dist_ctx_list);
369
370 /* Set appropriate function call */
371 int (*distfn)(struct distribute_ctx *, const char *,
372 enum distribute_type, const char *) =
373 prefix ? &distribute_list_prefix_unset : &distribute_list_unset;
374
375 /* if interface is present, get name */
376 const char *ifname = NULL;
377
378 if (argv[argc - 1]->type == VARIABLE_TKN)
379 ifname = argv[argc - 1]->arg;
380 /* Get interface name corresponding distribute list. */
381 int ret = distfn(ctx, ifname, type, argv[3 + prefix]->arg);
382
383 if (!ret) {
384 vty_out(vty, "distribute list doesn't exist\n");
385 return CMD_WARNING_CONFIG_FAILED;
386 }
387 return CMD_SUCCESS;
388 }
389
distribute_print(struct vty * vty,char * tab[],int is_prefix,enum distribute_type type,int has_print)390 static int distribute_print(struct vty *vty, char *tab[], int is_prefix,
391 enum distribute_type type, int has_print)
392 {
393 if (tab[type]) {
394 vty_out(vty, "%s %s%s", has_print ? "," : "",
395 is_prefix ? "(prefix-list) " : "", tab[type]);
396 return 1;
397 }
398 return has_print;
399 }
400
config_show_distribute(struct vty * vty,struct distribute_ctx * dist_ctxt)401 int config_show_distribute(struct vty *vty, struct distribute_ctx *dist_ctxt)
402 {
403 unsigned int i;
404 int has_print = 0;
405 struct hash_bucket *mp;
406 struct distribute *dist;
407
408 /* Output filter configuration. */
409 dist = distribute_lookup(dist_ctxt, NULL);
410 vty_out(vty, " Outgoing update filter list for all interface is");
411 has_print = 0;
412 if (dist) {
413 has_print = distribute_print(vty, dist->list, 0,
414 DISTRIBUTE_V4_OUT, has_print);
415 has_print = distribute_print(vty, dist->prefix, 1,
416 DISTRIBUTE_V4_OUT, has_print);
417 has_print = distribute_print(vty, dist->list, 0,
418 DISTRIBUTE_V6_OUT, has_print);
419 has_print = distribute_print(vty, dist->prefix, 1,
420 DISTRIBUTE_V6_OUT, has_print);
421 }
422 if (has_print)
423 vty_out(vty, "\n");
424 else
425 vty_out(vty, " not set\n");
426
427 for (i = 0; i < dist_ctxt->disthash->size; i++)
428 for (mp = dist_ctxt->disthash->index[i]; mp; mp = mp->next) {
429 dist = mp->data;
430 if (dist->ifname) {
431 vty_out(vty, " %s filtered by",
432 dist->ifname);
433 has_print = 0;
434 has_print = distribute_print(vty, dist->list, 0,
435 DISTRIBUTE_V4_OUT,
436 has_print);
437 has_print = distribute_print(
438 vty, dist->prefix, 1, DISTRIBUTE_V4_OUT,
439 has_print);
440 has_print = distribute_print(vty, dist->list, 0,
441 DISTRIBUTE_V6_OUT,
442 has_print);
443 has_print = distribute_print(
444 vty, dist->prefix, 1, DISTRIBUTE_V6_OUT,
445 has_print);
446 if (has_print)
447 vty_out(vty, "\n");
448 else
449 vty_out(vty, " nothing\n");
450 }
451 }
452
453
454 /* Input filter configuration. */
455 dist = distribute_lookup(dist_ctxt, NULL);
456 vty_out(vty, " Incoming update filter list for all interface is");
457 has_print = 0;
458 if (dist) {
459 has_print = distribute_print(vty, dist->list, 0,
460 DISTRIBUTE_V4_IN, has_print);
461 has_print = distribute_print(vty, dist->prefix, 1,
462 DISTRIBUTE_V4_IN, has_print);
463 has_print = distribute_print(vty, dist->list, 0,
464 DISTRIBUTE_V6_IN, has_print);
465 has_print = distribute_print(vty, dist->prefix, 1,
466 DISTRIBUTE_V6_IN, has_print);
467 }
468 if (has_print)
469 vty_out(vty, "\n");
470 else
471 vty_out(vty, " not set\n");
472
473 for (i = 0; i < dist_ctxt->disthash->size; i++)
474 for (mp = dist_ctxt->disthash->index[i]; mp; mp = mp->next) {
475 dist = mp->data;
476 if (dist->ifname) {
477 vty_out(vty, " %s filtered by",
478 dist->ifname);
479 has_print = 0;
480 has_print = distribute_print(vty, dist->list, 0,
481 DISTRIBUTE_V4_IN,
482 has_print);
483 has_print = distribute_print(
484 vty, dist->prefix, 1, DISTRIBUTE_V4_IN,
485 has_print);
486 has_print = distribute_print(vty, dist->list, 0,
487 DISTRIBUTE_V6_IN,
488 has_print);
489 has_print = distribute_print(
490 vty, dist->prefix, 1, DISTRIBUTE_V6_IN,
491 has_print);
492 if (has_print)
493 vty_out(vty, "\n");
494 else
495 vty_out(vty, " nothing\n");
496 }
497 }
498 return 0;
499 }
500
501 /* Configuration write function. */
config_write_distribute(struct vty * vty,struct distribute_ctx * dist_ctxt)502 int config_write_distribute(struct vty *vty,
503 struct distribute_ctx *dist_ctxt)
504 {
505 unsigned int i;
506 int j;
507 int output, v6;
508 struct hash_bucket *mp;
509 int write = 0;
510
511 for (i = 0; i < dist_ctxt->disthash->size; i++)
512 for (mp = dist_ctxt->disthash->index[i]; mp; mp = mp->next) {
513 struct distribute *dist;
514
515 dist = mp->data;
516
517 for (j = 0; j < DISTRIBUTE_MAX; j++)
518 if (dist->list[j]) {
519 output = j == DISTRIBUTE_V4_OUT
520 || j == DISTRIBUTE_V6_OUT;
521 v6 = j == DISTRIBUTE_V6_IN
522 || j == DISTRIBUTE_V6_OUT;
523 vty_out(vty,
524 " %sdistribute-list %s %s %s\n",
525 v6 ? "ipv6 " : "",
526 dist->list[j],
527 output ? "out" : "in",
528 dist->ifname ? dist->ifname
529 : "");
530 write++;
531 }
532
533 for (j = 0; j < DISTRIBUTE_MAX; j++)
534 if (dist->prefix[j]) {
535 output = j == DISTRIBUTE_V4_OUT
536 || j == DISTRIBUTE_V6_OUT;
537 v6 = j == DISTRIBUTE_V6_IN
538 || j == DISTRIBUTE_V6_OUT;
539 vty_out(vty,
540 " %sdistribute-list prefix %s %s %s\n",
541 v6 ? "ipv6 " : "",
542 dist->prefix[j],
543 output ? "out" : "in",
544 dist->ifname ? dist->ifname
545 : "");
546 write++;
547 }
548 }
549 return write;
550 }
551
distribute_list_delete(struct distribute_ctx ** ctx)552 void distribute_list_delete(struct distribute_ctx **ctx)
553 {
554 if ((*ctx)->disthash) {
555 hash_clean((*ctx)->disthash, (void (*)(void *))distribute_free);
556 }
557 if (!dist_ctx_list)
558 dist_ctx_list = list_new();
559 listnode_delete(dist_ctx_list, *ctx);
560 if (list_isempty(dist_ctx_list))
561 list_delete(&dist_ctx_list);
562 XFREE(MTYPE_DISTRIBUTE_CTX, (*ctx));
563 }
564
565 /* Initialize distribute list container */
distribute_list_ctx_create(struct vrf * vrf)566 struct distribute_ctx *distribute_list_ctx_create(struct vrf *vrf)
567 {
568 struct distribute_ctx *ctx;
569
570 ctx = XCALLOC(MTYPE_DISTRIBUTE_CTX, sizeof(struct distribute_ctx));
571 ctx->vrf = vrf;
572 ctx->disthash = hash_create(
573 distribute_hash_make,
574 (bool (*)(const void *, const void *))distribute_cmp, NULL);
575 if (!dist_ctx_list)
576 dist_ctx_list = list_new();
577 listnode_add(dist_ctx_list, ctx);
578 return ctx;
579 }
580
581 /* Initialize distribute list vty commands */
distribute_list_init(int node)582 void distribute_list_init(int node)
583 {
584 /* vtysh command-extraction doesn't grok install_element(node, ) */
585 if (node == RIP_NODE) {
586 install_element(RIP_NODE, &distribute_list_cmd);
587 install_element(RIP_NODE, &no_distribute_list_cmd);
588 } else if (node == RIPNG_NODE) {
589 install_element(RIPNG_NODE, &distribute_list_cmd);
590 install_element(RIPNG_NODE, &no_distribute_list_cmd);
591 /* install v6 */
592 install_element(RIPNG_NODE, &ipv6_distribute_list_cmd);
593 install_element(RIPNG_NODE, &no_ipv6_distribute_list_cmd);
594 }
595
596 /* TODO: install v4 syntax command for v6 only protocols. */
597 /* if (node == RIPNG_NODE) {
598 * install_element (node, &ipv6_as_v4_distribute_list_all_cmd);
599 * install_element (node, &no_ipv6_as_v4_distribute_list_all_cmd);
600 * install_element (node, &ipv6_as_v4_distribute_list_cmd);
601 * install_element (node, &no_ipv6_as_v4_distribute_list_cmd);
602 * install_element (node, &ipv6_as_v4_distribute_list_prefix_all_cmd);
603 * install_element (node,
604 &no_ipv6_as_v4_distribute_list_prefix_all_cmd);
605 * install_element (node, &ipv6_as_v4_distribute_list_prefix_cmd);
606 * install_element (node, &no_ipv6_as_v4_distribute_list_prefix_cmd);
607 }*/
608 }
609