Annotation of embedaddon/quagga/bgpd/bgp_filter.c, revision 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