Annotation of embedaddon/quagga/bgpd/bgp_filter.c, revision 1.1.1.1
1.1 misho 1: /* AS path filter list.
2: Copyright (C) 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 it
7: under the terms of the GNU General Public License as published by the
8: Free Software Foundation; either version 2, or (at your option) any
9: 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
17: along with GNU Zebra; see the file COPYING. If not, write to the Free
18: Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19: 02111-1307, USA. */
20:
21: #include <zebra.h>
22:
23: #include "command.h"
24: #include "log.h"
25: #include "memory.h"
26: #include "buffer.h"
27:
28: #include "bgpd/bgpd.h"
29: #include "bgpd/bgp_aspath.h"
30: #include "bgpd/bgp_regex.h"
31: #include "bgpd/bgp_filter.h"
32:
33: /* List of AS filter list. */
34: struct as_list_list
35: {
36: struct as_list *head;
37: struct as_list *tail;
38: };
39:
40: /* AS path filter master. */
41: struct as_list_master
42: {
43: /* List of access_list which name is number. */
44: struct as_list_list num;
45:
46: /* List of access_list which name is string. */
47: struct as_list_list str;
48:
49: /* Hook function which is executed when new access_list is added. */
50: void (*add_hook) (void);
51:
52: /* Hook function which is executed when access_list is deleted. */
53: void (*delete_hook) (void);
54: };
55:
56: /* Element of AS path filter. */
57: struct as_filter
58: {
59: struct as_filter *next;
60: struct as_filter *prev;
61:
62: enum as_filter_type type;
63:
64: regex_t *reg;
65: char *reg_str;
66: };
67:
68: enum as_list_type
69: {
70: ACCESS_TYPE_STRING,
71: ACCESS_TYPE_NUMBER
72: };
73:
74: /* AS path filter list. */
75: struct as_list
76: {
77: char *name;
78:
79: enum as_list_type type;
80:
81: struct as_list *next;
82: struct as_list *prev;
83:
84: struct as_filter *head;
85: struct as_filter *tail;
86: };
87:
88: /* ip as-path access-list 10 permit AS1. */
89:
90: static struct as_list_master as_list_master =
91: {
92: {NULL, NULL},
93: {NULL, NULL},
94: NULL,
95: NULL
96: };
97:
98: /* Allocate new AS filter. */
99: static struct as_filter *
100: as_filter_new (void)
101: {
102: return XCALLOC (MTYPE_AS_FILTER, sizeof (struct as_filter));
103: }
104:
105: /* Free allocated AS filter. */
106: static void
107: as_filter_free (struct as_filter *asfilter)
108: {
109: if (asfilter->reg)
110: bgp_regex_free (asfilter->reg);
111: if (asfilter->reg_str)
112: XFREE (MTYPE_AS_FILTER_STR, asfilter->reg_str);
113: XFREE (MTYPE_AS_FILTER, asfilter);
114: }
115:
116: /* Make new AS filter. */
117: static struct as_filter *
118: as_filter_make (regex_t *reg, const char *reg_str, enum as_filter_type type)
119: {
120: struct as_filter *asfilter;
121:
122: asfilter = as_filter_new ();
123: asfilter->reg = reg;
124: asfilter->type = type;
125: asfilter->reg_str = XSTRDUP (MTYPE_AS_FILTER_STR, reg_str);
126:
127: return asfilter;
128: }
129:
130: static struct as_filter *
131: as_filter_lookup (struct as_list *aslist, const char *reg_str,
132: enum as_filter_type type)
133: {
134: struct as_filter *asfilter;
135:
136: for (asfilter = aslist->head; asfilter; asfilter = asfilter->next)
137: if (strcmp (reg_str, asfilter->reg_str) == 0)
138: return asfilter;
139: return NULL;
140: }
141:
142: static void
143: as_list_filter_add (struct as_list *aslist, struct as_filter *asfilter)
144: {
145: asfilter->next = NULL;
146: asfilter->prev = aslist->tail;
147:
148: if (aslist->tail)
149: aslist->tail->next = asfilter;
150: else
151: aslist->head = asfilter;
152: aslist->tail = asfilter;
153: }
154:
155: /* Lookup as_list from list of as_list by name. */
156: struct as_list *
157: as_list_lookup (const char *name)
158: {
159: struct as_list *aslist;
160:
161: if (name == NULL)
162: return NULL;
163:
164: for (aslist = as_list_master.num.head; aslist; aslist = aslist->next)
165: if (strcmp (aslist->name, name) == 0)
166: return aslist;
167:
168: for (aslist = as_list_master.str.head; aslist; aslist = aslist->next)
169: if (strcmp (aslist->name, name) == 0)
170: return aslist;
171:
172: return NULL;
173: }
174:
175: static struct as_list *
176: as_list_new (void)
177: {
178: return XCALLOC (MTYPE_AS_LIST, sizeof (struct as_list));
179: }
180:
181: static void
182: as_list_free (struct as_list *aslist)
183: {
184: if (aslist->name)
185: {
186: free (aslist->name);
187: aslist->name = NULL;
188: }
189: XFREE (MTYPE_AS_LIST, aslist);
190: }
191:
192: /* Insert new AS list to list of as_list. Each as_list is sorted by
193: the name. */
194: static struct as_list *
195: as_list_insert (const char *name)
196: {
197: size_t i;
198: long number;
199: struct as_list *aslist;
200: struct as_list *point;
201: struct as_list_list *list;
202:
203: /* Allocate new access_list and copy given name. */
204: aslist = as_list_new ();
205: aslist->name = strdup (name);
206: assert (aslist->name);
207:
208: /* If name is made by all digit character. We treat it as
209: number. */
210: for (number = 0, i = 0; i < strlen (name); i++)
211: {
212: if (isdigit ((int) name[i]))
213: number = (number * 10) + (name[i] - '0');
214: else
215: break;
216: }
217:
218: /* In case of name is all digit character */
219: if (i == strlen (name))
220: {
221: aslist->type = ACCESS_TYPE_NUMBER;
222:
223: /* Set access_list to number list. */
224: list = &as_list_master.num;
225:
226: for (point = list->head; point; point = point->next)
227: if (atol (point->name) >= number)
228: break;
229: }
230: else
231: {
232: aslist->type = ACCESS_TYPE_STRING;
233:
234: /* Set access_list to string list. */
235: list = &as_list_master.str;
236:
237: /* Set point to insertion point. */
238: for (point = list->head; point; point = point->next)
239: if (strcmp (point->name, name) >= 0)
240: break;
241: }
242:
243: /* In case of this is the first element of master. */
244: if (list->head == NULL)
245: {
246: list->head = list->tail = aslist;
247: return aslist;
248: }
249:
250: /* In case of insertion is made at the tail of access_list. */
251: if (point == NULL)
252: {
253: aslist->prev = list->tail;
254: list->tail->next = aslist;
255: list->tail = aslist;
256: return aslist;
257: }
258:
259: /* In case of insertion is made at the head of access_list. */
260: if (point == list->head)
261: {
262: aslist->next = list->head;
263: list->head->prev = aslist;
264: list->head = aslist;
265: return aslist;
266: }
267:
268: /* Insertion is made at middle of the access_list. */
269: aslist->next = point;
270: aslist->prev = point->prev;
271:
272: if (point->prev)
273: point->prev->next = aslist;
274: point->prev = aslist;
275:
276: return aslist;
277: }
278:
279: static struct as_list *
280: as_list_get (const char *name)
281: {
282: struct as_list *aslist;
283:
284: aslist = as_list_lookup (name);
285: if (aslist == NULL)
286: {
287: aslist = as_list_insert (name);
288:
289: /* Run hook function. */
290: if (as_list_master.add_hook)
291: (*as_list_master.add_hook) ();
292: }
293:
294: return aslist;
295: }
296:
297: static const char *
298: filter_type_str (enum as_filter_type type)
299: {
300: switch (type)
301: {
302: case AS_FILTER_PERMIT:
303: return "permit";
304: case AS_FILTER_DENY:
305: return "deny";
306: default:
307: return "";
308: }
309: }
310:
311: static void
312: as_list_delete (struct as_list *aslist)
313: {
314: struct as_list_list *list;
315: struct as_filter *filter, *next;
316:
317: for (filter = aslist->head; filter; filter = next)
318: {
319: next = filter->next;
320: as_filter_free (filter);
321: }
322:
323: if (aslist->type == ACCESS_TYPE_NUMBER)
324: list = &as_list_master.num;
325: else
326: list = &as_list_master.str;
327:
328: if (aslist->next)
329: aslist->next->prev = aslist->prev;
330: else
331: list->tail = aslist->prev;
332:
333: if (aslist->prev)
334: aslist->prev->next = aslist->next;
335: else
336: list->head = aslist->next;
337:
338: as_list_free (aslist);
339: }
340:
341: static int
342: as_list_empty (struct as_list *aslist)
343: {
344: if (aslist->head == NULL && aslist->tail == NULL)
345: return 1;
346: else
347: return 0;
348: }
349:
350: static void
351: as_list_filter_delete (struct as_list *aslist, struct as_filter *asfilter)
352: {
353: if (asfilter->next)
354: asfilter->next->prev = asfilter->prev;
355: else
356: aslist->tail = asfilter->prev;
357:
358: if (asfilter->prev)
359: asfilter->prev->next = asfilter->next;
360: else
361: aslist->head = asfilter->next;
362:
363: as_filter_free (asfilter);
364:
365: /* If access_list becomes empty delete it from access_master. */
366: if (as_list_empty (aslist))
367: as_list_delete (aslist);
368:
369: /* Run hook function. */
370: if (as_list_master.delete_hook)
371: (*as_list_master.delete_hook) ();
372: }
373:
374: static int
375: as_filter_match (struct as_filter *asfilter, struct aspath *aspath)
376: {
377: if (bgp_regexec (asfilter->reg, aspath) != REG_NOMATCH)
378: return 1;
379: return 0;
380: }
381:
382: /* Apply AS path filter to AS. */
383: enum as_filter_type
384: as_list_apply (struct as_list *aslist, void *object)
385: {
386: struct as_filter *asfilter;
387: struct aspath *aspath;
388:
389: aspath = (struct aspath *) object;
390:
391: if (aslist == NULL)
392: return AS_FILTER_DENY;
393:
394: for (asfilter = aslist->head; asfilter; asfilter = asfilter->next)
395: {
396: if (as_filter_match (asfilter, aspath))
397: return asfilter->type;
398: }
399: return AS_FILTER_DENY;
400: }
401:
402: /* Add hook function. */
403: void
404: as_list_add_hook (void (*func) (void))
405: {
406: as_list_master.add_hook = func;
407: }
408:
409: /* Delete hook function. */
410: void
411: as_list_delete_hook (void (*func) (void))
412: {
413: as_list_master.delete_hook = func;
414: }
415:
416: static int
417: as_list_dup_check (struct as_list *aslist, struct as_filter *new)
418: {
419: struct as_filter *asfilter;
420:
421: for (asfilter = aslist->head; asfilter; asfilter = asfilter->next)
422: {
423: if (asfilter->type == new->type
424: && strcmp (asfilter->reg_str, new->reg_str) == 0)
425: return 1;
426: }
427: return 0;
428: }
429:
430: DEFUN (ip_as_path, ip_as_path_cmd,
431: "ip as-path access-list WORD (deny|permit) .LINE",
432: IP_STR
433: "BGP autonomous system path filter\n"
434: "Specify an access list name\n"
435: "Regular expression access list name\n"
436: "Specify packets to reject\n"
437: "Specify packets to forward\n"
438: "A regular-expression to match the BGP AS paths\n")
439: {
440: enum as_filter_type type;
441: struct as_filter *asfilter;
442: struct as_list *aslist;
443: regex_t *regex;
444: char *regstr;
445:
446: /* Check the filter type. */
447: if (strncmp (argv[1], "p", 1) == 0)
448: type = AS_FILTER_PERMIT;
449: else if (strncmp (argv[1], "d", 1) == 0)
450: type = AS_FILTER_DENY;
451: else
452: {
453: vty_out (vty, "filter type must be [permit|deny]%s", VTY_NEWLINE);
454: return CMD_WARNING;
455: }
456:
457: /* Check AS path regex. */
458: regstr = argv_concat(argv, argc, 2);
459:
460: regex = bgp_regcomp (regstr);
461: if (!regex)
462: {
463: XFREE (MTYPE_TMP, regstr);
464: vty_out (vty, "can't compile regexp %s%s", argv[0],
465: VTY_NEWLINE);
466: return CMD_WARNING;
467: }
468:
469: asfilter = as_filter_make (regex, regstr, type);
470:
471: XFREE (MTYPE_TMP, regstr);
472:
473: /* Install new filter to the access_list. */
474: aslist = as_list_get (argv[0]);
475:
476: /* Duplicate insertion check. */;
477: if (as_list_dup_check (aslist, asfilter))
478: as_filter_free (asfilter);
479: else
480: as_list_filter_add (aslist, asfilter);
481:
482: return CMD_SUCCESS;
483: }
484:
485: DEFUN (no_ip_as_path,
486: no_ip_as_path_cmd,
487: "no ip as-path access-list WORD (deny|permit) .LINE",
488: NO_STR
489: IP_STR
490: "BGP autonomous system path filter\n"
491: "Specify an access list name\n"
492: "Regular expression access list name\n"
493: "Specify packets to reject\n"
494: "Specify packets to forward\n"
495: "A regular-expression to match the BGP AS paths\n")
496: {
497: enum as_filter_type type;
498: struct as_filter *asfilter;
499: struct as_list *aslist;
500: char *regstr;
501: regex_t *regex;
502:
503: /* Lookup AS list from AS path list. */
504: aslist = as_list_lookup (argv[0]);
505: if (aslist == NULL)
506: {
507: vty_out (vty, "ip as-path access-list %s doesn't exist%s", argv[0],
508: VTY_NEWLINE);
509: return CMD_WARNING;
510: }
511:
512: /* Check the filter type. */
513: if (strncmp (argv[1], "p", 1) == 0)
514: type = AS_FILTER_PERMIT;
515: else if (strncmp (argv[1], "d", 1) == 0)
516: type = AS_FILTER_DENY;
517: else
518: {
519: vty_out (vty, "filter type must be [permit|deny]%s", VTY_NEWLINE);
520: return CMD_WARNING;
521: }
522:
523: /* Compile AS path. */
524: regstr = argv_concat(argv, argc, 2);
525:
526: regex = bgp_regcomp (regstr);
527: if (!regex)
528: {
529: XFREE (MTYPE_TMP, regstr);
530: vty_out (vty, "can't compile regexp %s%s", argv[0],
531: VTY_NEWLINE);
532: return CMD_WARNING;
533: }
534:
535: /* Lookup asfilter. */
536: asfilter = as_filter_lookup (aslist, regstr, type);
537:
538: XFREE (MTYPE_TMP, regstr);
539: bgp_regex_free (regex);
540:
541: if (asfilter == NULL)
542: {
543: vty_out (vty, "%s", VTY_NEWLINE);
544: return CMD_WARNING;
545: }
546:
547: as_list_filter_delete (aslist, asfilter);
548:
549: return CMD_SUCCESS;
550: }
551:
552: DEFUN (no_ip_as_path_all,
553: no_ip_as_path_all_cmd,
554: "no ip as-path access-list WORD",
555: NO_STR
556: IP_STR
557: "BGP autonomous system path filter\n"
558: "Specify an access list name\n"
559: "Regular expression access list name\n")
560: {
561: struct as_list *aslist;
562:
563: aslist = as_list_lookup (argv[0]);
564: if (aslist == NULL)
565: {
566: vty_out (vty, "ip as-path access-list %s doesn't exist%s", argv[0],
567: VTY_NEWLINE);
568: return CMD_WARNING;
569: }
570:
571: as_list_delete (aslist);
572:
573: /* Run hook function. */
574: if (as_list_master.delete_hook)
575: (*as_list_master.delete_hook) ();
576:
577: return CMD_SUCCESS;
578: }
579:
580: static void
581: as_list_show (struct vty *vty, struct as_list *aslist)
582: {
583: struct as_filter *asfilter;
584:
585: vty_out (vty, "AS path access list %s%s", aslist->name, VTY_NEWLINE);
586:
587: for (asfilter = aslist->head; asfilter; asfilter = asfilter->next)
588: {
589: vty_out (vty, " %s %s%s", filter_type_str (asfilter->type),
590: asfilter->reg_str, VTY_NEWLINE);
591: }
592: }
593:
594: static void
595: as_list_show_all (struct vty *vty)
596: {
597: struct as_list *aslist;
598: struct as_filter *asfilter;
599:
600: for (aslist = as_list_master.num.head; aslist; aslist = aslist->next)
601: {
602: vty_out (vty, "AS path access list %s%s", aslist->name, VTY_NEWLINE);
603:
604: for (asfilter = aslist->head; asfilter; asfilter = asfilter->next)
605: {
606: vty_out (vty, " %s %s%s", filter_type_str (asfilter->type),
607: asfilter->reg_str, VTY_NEWLINE);
608: }
609: }
610:
611: for (aslist = as_list_master.str.head; aslist; aslist = aslist->next)
612: {
613: vty_out (vty, "AS path access list %s%s", aslist->name, VTY_NEWLINE);
614:
615: for (asfilter = aslist->head; asfilter; asfilter = asfilter->next)
616: {
617: vty_out (vty, " %s %s%s", filter_type_str (asfilter->type),
618: asfilter->reg_str, VTY_NEWLINE);
619: }
620: }
621: }
622:
623: DEFUN (show_ip_as_path_access_list,
624: show_ip_as_path_access_list_cmd,
625: "show ip as-path-access-list WORD",
626: SHOW_STR
627: IP_STR
628: "List AS path access lists\n"
629: "AS path access list name\n")
630: {
631: struct as_list *aslist;
632:
633: aslist = as_list_lookup (argv[0]);
634: if (aslist)
635: as_list_show (vty, aslist);
636:
637: return CMD_SUCCESS;
638: }
639:
640: DEFUN (show_ip_as_path_access_list_all,
641: show_ip_as_path_access_list_all_cmd,
642: "show ip as-path-access-list",
643: SHOW_STR
644: IP_STR
645: "List AS path access lists\n")
646: {
647: as_list_show_all (vty);
648: return CMD_SUCCESS;
649: }
650:
651: static int
652: config_write_as_list (struct vty *vty)
653: {
654: struct as_list *aslist;
655: struct as_filter *asfilter;
656: int write = 0;
657:
658: for (aslist = as_list_master.num.head; aslist; aslist = aslist->next)
659: for (asfilter = aslist->head; asfilter; asfilter = asfilter->next)
660: {
661: vty_out (vty, "ip as-path access-list %s %s %s%s",
662: aslist->name, filter_type_str (asfilter->type),
663: asfilter->reg_str,
664: VTY_NEWLINE);
665: write++;
666: }
667:
668: for (aslist = as_list_master.str.head; aslist; aslist = aslist->next)
669: for (asfilter = aslist->head; asfilter; asfilter = asfilter->next)
670: {
671: vty_out (vty, "ip as-path access-list %s %s %s%s",
672: aslist->name, filter_type_str (asfilter->type),
673: asfilter->reg_str,
674: VTY_NEWLINE);
675: write++;
676: }
677: return write;
678: }
679:
680: static struct cmd_node as_list_node =
681: {
682: AS_LIST_NODE,
683: "",
684: 1
685: };
686:
687: /* Register functions. */
688: void
689: bgp_filter_init (void)
690: {
691: install_node (&as_list_node, config_write_as_list);
692:
693: install_element (CONFIG_NODE, &ip_as_path_cmd);
694: install_element (CONFIG_NODE, &no_ip_as_path_cmd);
695: install_element (CONFIG_NODE, &no_ip_as_path_all_cmd);
696:
697: install_element (VIEW_NODE, &show_ip_as_path_access_list_cmd);
698: install_element (VIEW_NODE, &show_ip_as_path_access_list_all_cmd);
699: install_element (ENABLE_NODE, &show_ip_as_path_access_list_cmd);
700: install_element (ENABLE_NODE, &show_ip_as_path_access_list_all_cmd);
701: }
702:
703: void
704: bgp_filter_reset (void)
705: {
706: struct as_list *aslist;
707: struct as_list *next;
708:
709: for (aslist = as_list_master.num.head; aslist; aslist = next)
710: {
711: next = aslist->next;
712: as_list_delete (aslist);
713: }
714:
715: for (aslist = as_list_master.str.head; aslist; aslist = next)
716: {
717: next = aslist->next;
718: as_list_delete (aslist);
719: }
720:
721: assert (as_list_master.num.head == NULL);
722: assert (as_list_master.num.tail == NULL);
723:
724: assert (as_list_master.str.head == NULL);
725: assert (as_list_master.str.tail == NULL);
726: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bgp_filter.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / bgpd