mirror of
https://gitlab.nic.cz/labs/bird.git
synced 2024-11-13 22:58:42 +00:00
17f91f9e6e
Changes in internal API: * Every route attribute must be defined as struct ea_class somewhere. * Registration of route attributes known at startup must be done by ea_register_init() from protocol build functions. * Every attribute has now its symbol registered in a global symbol table defined as SYM_ATTRIBUTE * All attribute ID's are dynamically allocated. * Attribute value custom formatting hook is defined in the ea_class. * Attribute names are the same for display and filters, always prefixed by protocol name. Also added some unit testing code for filters with route attributes.
1626 lines
40 KiB
Plaintext
1626 lines
40 KiB
Plaintext
/*
|
|
* This is unit testing configuration file for testing filters
|
|
*
|
|
* FIXME: add all examples from docs here.
|
|
*/
|
|
|
|
router id 62.168.0.1;
|
|
|
|
/* We have to setup any protocol */
|
|
protocol device { }
|
|
|
|
/* Setting some custom attributes, enough to force BIRD to reallocate the attribute idmap */
|
|
attribute int test_ca_int1;
|
|
attribute int test_ca_int2;
|
|
attribute int test_ca_int3;
|
|
attribute int test_ca_int4;
|
|
attribute int test_ca_int5;
|
|
attribute int test_ca_int6;
|
|
attribute int test_ca_int7;
|
|
attribute int test_ca_int8;
|
|
attribute int test_ca_int9;
|
|
attribute int test_ca_int10;
|
|
|
|
attribute ip test_ca_ip1;
|
|
attribute ip test_ca_ip2;
|
|
attribute ip test_ca_ip3;
|
|
attribute ip test_ca_ip4;
|
|
attribute ip test_ca_ip5;
|
|
attribute ip test_ca_ip6;
|
|
attribute ip test_ca_ip7;
|
|
attribute ip test_ca_ip8;
|
|
attribute ip test_ca_ip9;
|
|
attribute ip test_ca_ip10;
|
|
|
|
attribute quad test_ca_quad1;
|
|
attribute quad test_ca_quad2;
|
|
attribute quad test_ca_quad3;
|
|
attribute quad test_ca_quad4;
|
|
attribute quad test_ca_quad5;
|
|
attribute quad test_ca_quad6;
|
|
attribute quad test_ca_quad7;
|
|
attribute quad test_ca_quad8;
|
|
attribute quad test_ca_quad9;
|
|
attribute quad test_ca_quad10;
|
|
|
|
attribute bgppath test_ca_bgppath1;
|
|
attribute bgppath test_ca_bgppath2;
|
|
attribute bgppath test_ca_bgppath3;
|
|
attribute bgppath test_ca_bgppath4;
|
|
attribute bgppath test_ca_bgppath5;
|
|
attribute bgppath test_ca_bgppath6;
|
|
attribute bgppath test_ca_bgppath7;
|
|
attribute bgppath test_ca_bgppath8;
|
|
attribute bgppath test_ca_bgppath9;
|
|
attribute bgppath test_ca_bgppath10;
|
|
|
|
attribute clist test_ca_clist1;
|
|
attribute clist test_ca_clist2;
|
|
attribute clist test_ca_clist3;
|
|
attribute clist test_ca_clist4;
|
|
attribute clist test_ca_clist5;
|
|
attribute clist test_ca_clist6;
|
|
attribute clist test_ca_clist7;
|
|
attribute clist test_ca_clist8;
|
|
attribute clist test_ca_clist9;
|
|
attribute clist test_ca_clist10;
|
|
|
|
attribute eclist test_ca_eclist1;
|
|
attribute eclist test_ca_eclist2;
|
|
attribute eclist test_ca_eclist3;
|
|
attribute eclist test_ca_eclist4;
|
|
attribute eclist test_ca_eclist5;
|
|
attribute eclist test_ca_eclist6;
|
|
attribute eclist test_ca_eclist7;
|
|
attribute eclist test_ca_eclist8;
|
|
attribute eclist test_ca_eclist9;
|
|
attribute eclist test_ca_eclist10;
|
|
|
|
attribute lclist test_ca_lclist1;
|
|
attribute lclist test_ca_lclist2;
|
|
attribute lclist test_ca_lclist3;
|
|
attribute lclist test_ca_lclist4;
|
|
attribute lclist test_ca_lclist5;
|
|
attribute lclist test_ca_lclist6;
|
|
attribute lclist test_ca_lclist7;
|
|
attribute lclist test_ca_lclist8;
|
|
attribute lclist test_ca_lclist9;
|
|
attribute lclist test_ca_lclist10;
|
|
|
|
attribute lclist test_ca_lclist_max1;
|
|
attribute lclist test_ca_lclist_max2;
|
|
attribute lclist test_ca_lclist_max3;
|
|
attribute lclist test_ca_lclist_max4;
|
|
attribute lclist test_ca_lclist_max5;
|
|
attribute lclist test_ca_lclist_max6;
|
|
attribute lclist test_ca_lclist_max7;
|
|
attribute lclist test_ca_lclist_max8;
|
|
attribute lclist test_ca_lclist_max9;
|
|
attribute lclist test_ca_lclist_max10;
|
|
attribute lclist test_ca_lclist_max11;
|
|
attribute lclist test_ca_lclist_max12;
|
|
attribute lclist test_ca_lclist_max13;
|
|
attribute lclist test_ca_lclist_max14;
|
|
attribute lclist test_ca_lclist_max15;
|
|
attribute lclist test_ca_lclist_max16;
|
|
attribute lclist test_ca_lclist_max17;
|
|
attribute lclist test_ca_lclist_max18;
|
|
attribute lclist test_ca_lclist_max19;
|
|
attribute lclist test_ca_lclist_max20;
|
|
attribute lclist test_ca_lclist_max21;
|
|
|
|
|
|
/* Uncomment this to get an error */
|
|
#attribute int bgp_path;
|
|
|
|
/*
|
|
* Common definitions and functions
|
|
* --------------------------------
|
|
*/
|
|
|
|
define one = 1;
|
|
define ten = 10;
|
|
|
|
function onef(int a)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
function twof(int a)
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
function oneg(int a)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
bt_test_same(onef, onef, 1);
|
|
bt_test_same(onef, oneg, 1);
|
|
bt_test_same(onef, twof, 0);
|
|
|
|
/*
|
|
* Testing boolean expressions
|
|
* ---------------------------
|
|
*/
|
|
|
|
function t_bool()
|
|
bool b;
|
|
{
|
|
b = true;
|
|
bt_assert(b);
|
|
bt_assert(!!b);
|
|
|
|
bt_assert(format(true) = "TRUE");
|
|
bt_assert(format(false) = "FALSE");
|
|
|
|
if ( b = true ) then
|
|
bt_assert(b);
|
|
else
|
|
bt_assert(false);
|
|
|
|
bt_assert(true && true);
|
|
bt_assert(true || false);
|
|
bt_assert(! false && ! false && true);
|
|
bt_assert(1 < 2 && 1 != 3);
|
|
bt_assert(true && true && ! false);
|
|
# bt_assert(true || 1+"a");
|
|
# bt_assert(!(false && 1+"a"));
|
|
bt_assert(!(true && false));
|
|
}
|
|
|
|
bt_test_suite(t_bool, "Testing boolean expressions");
|
|
|
|
|
|
|
|
/*
|
|
* Testing integers
|
|
* ----------------
|
|
*/
|
|
|
|
define four = 4;
|
|
define xyzzy = (120+10);
|
|
define '1a-a1' = (xyzzy-100);
|
|
|
|
function t_int()
|
|
int i;
|
|
{
|
|
bt_assert(xyzzy = 130);
|
|
bt_assert('1a-a1' = 30);
|
|
|
|
i = four;
|
|
i = 12*100 + 60/2 + i;
|
|
i = (i + 0);
|
|
bt_assert(i = 1234);
|
|
|
|
bt_assert(format(i) = "1234");
|
|
|
|
i = 4200000000;
|
|
bt_assert(i = 4200000000);
|
|
bt_assert(i > 4100000000);
|
|
bt_assert(!(i > 4250000000));
|
|
|
|
bt_assert(1 = 1);
|
|
bt_assert(!(1 != 1));
|
|
|
|
bt_assert(1 != 2);
|
|
bt_assert(1 <= 2);
|
|
|
|
bt_assert(1 != "a");
|
|
bt_assert(1 != (0,1));
|
|
|
|
bt_assert(!(i = 4));
|
|
bt_assert(1 <= 1);
|
|
bt_assert(!(1234 < 1234));
|
|
|
|
bt_assert(10 - 5 = 5);
|
|
bt_assert(4294967295 + 1 = 0);
|
|
bt_assert(6*9=54);
|
|
bt_assert(984/41 = 24);
|
|
bt_assert(123/45 = 2);
|
|
bt_assert(0xfee1a | 0xbeef = 0xffeff);
|
|
bt_assert(0xfee1a & 0xbeef = 0xae0a);
|
|
}
|
|
|
|
bt_test_suite(t_int, "Testing integers");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing sets of integers
|
|
* ------------------------
|
|
*/
|
|
|
|
define is1 = [ one, (2+1), (6-one), 8, 11, 15, 17, 19];
|
|
define is2 = [(17+2), 17, 15, 11, 8, 5, 3, 2];
|
|
define is3 = [5, 17, 2, 11, 8, 15, 3, 19];
|
|
|
|
function t_int_set()
|
|
int set is;
|
|
{
|
|
bt_assert(1 ~ [1,2,3]);
|
|
bt_assert(5 ~ [1..20]);
|
|
bt_assert(2 ~ [ 1, 2, 3 ]);
|
|
bt_assert(5 ~ [ 4 .. 7 ]);
|
|
bt_assert(1 !~ [ 2, 3, 4 ]);
|
|
bt_assert(999 !~ [ 666, 333 ]);
|
|
|
|
is = [ 2, 3, 4, 7..11 ];
|
|
bt_assert(10 ~ is);
|
|
bt_assert(5 !~ is);
|
|
|
|
bt_assert(1 ~ is1);
|
|
bt_assert(3 ~ is1);
|
|
bt_assert(5 ~ is1);
|
|
bt_assert((one+2) ~ is1);
|
|
bt_assert(2 ~ is2);
|
|
bt_assert(2 ~ is3);
|
|
bt_assert(4 !~ is1);
|
|
bt_assert(4 !~ is2);
|
|
bt_assert(4 !~ is3);
|
|
bt_assert(10 !~ is1);
|
|
bt_assert(10 !~ is2);
|
|
bt_assert(10 !~ is3);
|
|
bt_assert(15 ~ is1);
|
|
bt_assert(15 ~ is2);
|
|
bt_assert(15 ~ is3);
|
|
bt_assert(18 !~ is1);
|
|
bt_assert(18 !~ is2);
|
|
bt_assert(18 !~ is3);
|
|
bt_assert(19 ~ is1);
|
|
bt_assert(19 ~ is2);
|
|
bt_assert(19 ~ is3);
|
|
bt_assert(20 !~ is1);
|
|
bt_assert(20 !~ is2);
|
|
bt_assert(20 !~ is3);
|
|
|
|
bt_assert([1,2] != [1,3]);
|
|
bt_assert([1,4..10,20] = [1,4..10,20]);
|
|
|
|
bt_assert(format([ 1, 2, 1, 1, 1, 3, 4, 1, 1, 1, 5 ]) = "[1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 5]");
|
|
}
|
|
|
|
bt_test_suite(t_int_set, "Testing sets of integers");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing string matching
|
|
* -----------------------
|
|
*/
|
|
|
|
function t_string()
|
|
string st;
|
|
{
|
|
st = "Hello";
|
|
bt_assert(format(st) = "Hello");
|
|
bt_assert(st ~ "Hell*");
|
|
bt_assert(st ~ "?ello");
|
|
bt_assert(st ~ "Hello");
|
|
bt_assert(st ~ "Hell?");
|
|
bt_assert(st !~ "ell*");
|
|
}
|
|
|
|
bt_test_suite(t_string, "Testing string matching");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing pairs
|
|
* -------------
|
|
*/
|
|
|
|
function 'mkpair-a'(int a)
|
|
{
|
|
return (1, a);
|
|
}
|
|
|
|
function t_pair()
|
|
pair pp;
|
|
{
|
|
pp = (1, 2);
|
|
bt_assert(format(pp) = "(1,2)");
|
|
bt_assert((1,2) = pp);
|
|
bt_assert((1,1+1) = pp);
|
|
bt_assert('mkpair-a'(2) = pp);
|
|
bt_assert((1,2) = (1,1+1));
|
|
bt_assert(((1,2) < (2,2)));
|
|
bt_assert(!((1,1) > (1,1)));
|
|
}
|
|
|
|
bt_test_suite(t_pair, "Testing pairs");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing sets of pairs
|
|
* ---------------------
|
|
*/
|
|
|
|
function t_pair_set()
|
|
pair pp;
|
|
pair set ps;
|
|
{
|
|
pp = (1, 2);
|
|
ps = [(1,(one+one)), (3,4)..(4,8), (5,*), (6,3..6)];
|
|
bt_assert(format(ps) = "[(1,2), (3,4)..(4,8), (5,0)..(5,65535), (6,3)..(6,6)]");
|
|
bt_assert(pp ~ ps);
|
|
bt_assert((3,5) ~ ps);
|
|
bt_assert((4,1) ~ ps);
|
|
bt_assert((5,4) ~ ps);
|
|
bt_assert((5,65535) ~ ps);
|
|
bt_assert((6,4) ~ ps);
|
|
bt_assert((3, 10000) ~ ps);
|
|
bt_assert((3,3) !~ ps);
|
|
bt_assert((4,9) !~ ps);
|
|
bt_assert((4,65535) !~ ps);
|
|
bt_assert((6,2) !~ ps);
|
|
bt_assert((6,6+one) !~ ps);
|
|
bt_assert(((one+6),2) !~ ps);
|
|
bt_assert((1,1) !~ ps);
|
|
|
|
ps = [(20..150, 200..300), (50100..50200, 1000..50000), (*, 5+5)];
|
|
bt_assert((100,200) ~ ps);
|
|
bt_assert((150,300) ~ ps);
|
|
bt_assert((50180,1200) ~ ps);
|
|
bt_assert((50110,49000) ~ ps);
|
|
bt_assert((0,10) ~ ps);
|
|
bt_assert((64000,10) ~ ps);
|
|
bt_assert((20,199) !~ ps);
|
|
bt_assert((151,250) !~ ps);
|
|
bt_assert((50050,2000) !~ ps);
|
|
bt_assert((50150,50050) !~ ps);
|
|
bt_assert((10,9) !~ ps);
|
|
bt_assert((65535,11) !~ ps);
|
|
}
|
|
|
|
bt_test_suite(t_pair_set, "Testing sets of pairs");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing quads
|
|
* -------------
|
|
*/
|
|
|
|
function t_quad()
|
|
quad qq;
|
|
{
|
|
qq = 1.2.3.4;
|
|
bt_assert(format(qq) = "1.2.3.4");
|
|
bt_assert(qq = 1.2.3.4);
|
|
bt_assert(qq != 4.3.2.1);
|
|
}
|
|
|
|
bt_test_suite(t_quad, "Testing quads");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing sets of quads
|
|
* ---------------------
|
|
*/
|
|
|
|
function t_quad_set()
|
|
quad qq;
|
|
{
|
|
qq = 1.2.3.4;
|
|
bt_assert(qq ~ [1.2.3.4, 5.6.7.8]);
|
|
bt_assert(qq !~ [1.2.1.1, 1.2.3.5]);
|
|
}
|
|
|
|
bt_test_suite(t_quad_set, "Testing sets of quads");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing ip address
|
|
* ------------------
|
|
*/
|
|
|
|
define onetwo = 1.2.3.4;
|
|
|
|
function t_ip()
|
|
ip p;
|
|
{
|
|
p = 127.1.2.3;
|
|
bt_assert(p.is_v4);
|
|
bt_assert(p.mask(8) = 127.0.0.0);
|
|
bt_assert(1.2.3.4 = 1.2.3.4);
|
|
bt_assert(1.2.3.4 = onetwo);
|
|
bt_assert(format(p) = "127.1.2.3");
|
|
|
|
p = ::fffe:6:c0c:936d:88c7:35d3;
|
|
bt_assert(!p.is_v4);
|
|
bt_assert(format(p) = "::fffe:6:c0c:936d:88c7:35d3");
|
|
|
|
p = 1234:5678::;
|
|
bt_assert(!p.is_v4);
|
|
bt_assert(p.mask(24) = 1234:5600::);
|
|
|
|
p = 1:2:3:4:5:6:7:8;
|
|
bt_assert(!p.is_v4);
|
|
bt_assert(format(p) = "1:2:3:4:5:6:7:8");
|
|
bt_assert(p.mask(64) = 1:2:3:4::);
|
|
|
|
p = 10:20:30:40:50:60:70:80;
|
|
bt_assert(!p.is_v4);
|
|
bt_assert(format(p) = "10:20:30:40:50:60:70:80");
|
|
bt_assert(p.mask(64) = 10:20:30:40::);
|
|
|
|
p = 1090:20a0:30b0:40c0:50d0:60e0:70f0:8000;
|
|
bt_assert(!p.is_v4);
|
|
bt_assert(format(p) = "1090:20a0:30b0:40c0:50d0:60e0:70f0:8000");
|
|
bt_assert(p.mask(64) = 1090:20a0:30b0:40c0::);
|
|
|
|
p = ::fffe:6:c0c:936d:88c7:35d3;
|
|
bt_assert(!p.is_v4);
|
|
bt_assert(format(p) = "::fffe:6:c0c:936d:88c7:35d3");
|
|
bt_assert(p.mask(64) = 0:0:fffe:6::);
|
|
}
|
|
|
|
bt_test_suite(t_ip, "Testing ip address");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing sets of ip address
|
|
* --------------------------
|
|
*/
|
|
|
|
define ip1222 = 1.2.2.2;
|
|
|
|
function t_ip_set()
|
|
ip set ips;
|
|
{
|
|
ips = [ 1.1.1.0 .. 1.1.1.255, ip1222];
|
|
bt_assert(format(ips) = "[1.1.1.0..1.1.1.255, 1.2.2.2]");
|
|
bt_assert(1.1.1.0 ~ ips);
|
|
bt_assert(1.1.1.100 ~ ips);
|
|
bt_assert(1.2.2.2 ~ ips);
|
|
bt_assert(1.1.0.255 !~ ips);
|
|
bt_assert(1.1.2.0 !~ ips);
|
|
bt_assert(1.2.2.3 !~ ips);
|
|
bt_assert(192.168.1.1 !~ ips);
|
|
|
|
bt_assert(1.2.3.4 !~ [ 1.2.3.3, 1.2.3.5 ]);
|
|
bt_assert(1.2.3.4 ~ [ 1.2.3.3..1.2.3.5 ]);
|
|
}
|
|
|
|
bt_test_suite(t_ip_set, "Testing sets of ip address");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing enums
|
|
* -------------
|
|
*/
|
|
|
|
function t_enum()
|
|
{
|
|
bt_assert(format(RTS_STATIC) = "(enum 31)1");
|
|
bt_assert(format(NET_IP4) = "(enum 3b)1");
|
|
bt_assert(format(NET_VPN6) = "(enum 3b)4");
|
|
|
|
bt_assert(RTS_STATIC ~ [RTS_STATIC, RTS_DEVICE]);
|
|
bt_assert(RTS_BGP !~ [RTS_STATIC, RTS_DEVICE]);
|
|
}
|
|
|
|
bt_test_suite(t_enum, "Testing enums");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing prefixes
|
|
* ----------------
|
|
*/
|
|
|
|
define netdoc = 2001:db8::/32;
|
|
|
|
function t_prefix()
|
|
prefix px;
|
|
{
|
|
px = 1.2.0.0/18;
|
|
bt_assert(format(px) = "1.2.0.0/18");
|
|
bt_assert(192.168.0.0/16 ~ 192.168.0.0/16);
|
|
bt_assert(192.168.0.0/17 ~ 192.168.0.0/16);
|
|
bt_assert(192.168.254.0/24 ~ 192.168.0.0/16);
|
|
bt_assert(netdoc ~ 2001::/16);
|
|
bt_assert(192.168.0.0/15 !~ 192.168.0.0/16);
|
|
bt_assert(192.160.0.0/17 !~ 192.168.0.0/16);
|
|
bt_assert(px !~ netdoc);
|
|
|
|
bt_assert(1.2.3.4 ~ 1.0.0.0/8);
|
|
bt_assert(1.0.0.0/8 ~ 1.0.0.0/8);
|
|
}
|
|
|
|
bt_test_suite(t_prefix, "Testing prefixes");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing prefix sets
|
|
* -------------------
|
|
*/
|
|
|
|
define net10 = 10.0.0.0/8;
|
|
define pxs2 = [ 10.0.0.0/16{8,12}, 20.0.0.0/16{24,28} ];
|
|
|
|
function test_pxset(prefix set pxs)
|
|
{
|
|
bt_assert(net10 ~ pxs);
|
|
bt_assert(10.0.0.0/10 ~ pxs);
|
|
bt_assert(10.0.0.0/12 ~ pxs);
|
|
bt_assert(20.0.0.0/24 ~ pxs);
|
|
bt_assert(20.0.40.0/24 ~ pxs);
|
|
bt_assert(20.0.0.0/26 ~ pxs);
|
|
bt_assert(20.0.100.0/26 ~ pxs);
|
|
bt_assert(20.0.0.0/28 ~ pxs);
|
|
bt_assert(20.0.255.0/28 ~ pxs);
|
|
|
|
bt_assert(10.0.0.0/7 !~ pxs);
|
|
bt_assert(10.0.0.0/13 !~ pxs);
|
|
bt_assert(10.0.0.0/16 !~ pxs);
|
|
bt_assert(20.0.0.0/16 !~ pxs);
|
|
bt_assert(20.0.0.0/23 !~ pxs);
|
|
bt_assert(20.0.0.0/29 !~ pxs);
|
|
bt_assert(11.0.0.0/10 !~ pxs);
|
|
bt_assert(20.1.0.0/26 !~ pxs);
|
|
|
|
bt_assert(1.0.0.0/8 ~ [ 1.0.0.0/8+ ]);
|
|
bt_assert(1.0.0.0/9 !~ [ 1.0.0.0/8- ]);
|
|
bt_assert(1.2.0.0/17 !~ [ 1.0.0.0/8{ 15 , 16 } ]);
|
|
|
|
bt_assert([ 10.0.0.0/8{ 15 , 17 } ] = [ 10.0.0.0/8{ 15 , 17 } ]);
|
|
}
|
|
|
|
function t_prefix_set()
|
|
prefix set pxs;
|
|
{
|
|
pxs = [ 1.2.0.0/16, 1.4.0.0/16+, 44.66.88.64/30{24,28}, 12.34.56.0/24{8,16} ];
|
|
bt_assert(format(pxs) = "[1.2.0.0/16{0.1.0.0}, 1.4.0.0/16{0.1.255.255}, 12.34.0.0/16{1.255.0.0}, 44.66.88.64/28{0.0.1.240}]");
|
|
|
|
bt_assert(1.2.0.0/16 ~ pxs);
|
|
bt_assert(1.4.0.0/16 ~ pxs);
|
|
bt_assert(1.4.0.0/18 ~ pxs);
|
|
bt_assert(1.4.0.0/32 ~ pxs);
|
|
bt_assert(1.1.0.0/16 !~ pxs);
|
|
bt_assert(1.3.0.0/16 !~ pxs);
|
|
bt_assert(1.2.0.0/15 !~ pxs);
|
|
bt_assert(1.2.0.0/17 !~ pxs);
|
|
bt_assert(1.2.0.0/32 !~ pxs);
|
|
bt_assert(1.4.0.0/15 !~ pxs);
|
|
|
|
test_pxset(pxs2);
|
|
test_pxset([ 10.0.0.0/16{8,12}, 20.0.0.0/16{24,28} ]);
|
|
|
|
bt_assert(1.2.0.0/16 ~ [ 1.0.0.0/8{ 15 , 17 } ]);
|
|
bt_assert([ 10.0.0.0/8{ 15 , 17 } ] != [ 11.0.0.0/8{ 15 , 17 } ]);
|
|
|
|
/* Formatting of prefix sets, some cases are a bit strange */
|
|
bt_assert(format([ 0.0.0.0/0 ]) = "[0.0.0.0/0]");
|
|
bt_assert(format([ 10.10.0.0/32 ]) = "[10.10.0.0/32{0.0.0.1}]");
|
|
bt_assert(format([ 10.10.0.0/17 ]) = "[10.10.0.0/17{0.0.128.0}]");
|
|
bt_assert(format([ 10.10.0.0/17{17,19} ]) = "[10.10.0.0/17{0.0.224.0}]"); # 224 = 128+64+32
|
|
bt_assert(format([ 10.10.128.0/17{18,19} ]) = "[10.10.128.0/18{0.0.96.0}, 10.10.192.0/18{0.0.96.0}]"); # 96 = 64+32
|
|
bt_assert(format([ 10.10.64.0/18- ]) = "[0.0.0.0/0, 0.0.0.0/1{128.0.0.0}, 0.0.0.0/2{64.0.0.0}, 0.0.0.0/3{32.0.0.0}, 10.10.0.0/16{255.255.0.0}, 10.10.0.0/17{0.0.128.0}, 10.10.64.0/18{0.0.64.0}]");
|
|
bt_assert(format([ 10.10.64.0/18+ ]) = "[10.10.64.0/18{0.0.96.0}, 10.10.64.0/20{0.0.31.255}, 10.10.80.0/20{0.0.31.255}, 10.10.96.0/20{0.0.31.255}, 10.10.112.0/20{0.0.31.255}]");
|
|
|
|
bt_assert(format([ 10.10.160.0/19 ]) = "[10.10.160.0/19{0.0.32.0}]");
|
|
bt_assert(format([ 10.10.160.0/19{19,22} ]) = "[10.10.160.0/19{0.0.32.0}, 10.10.160.0/20{0.0.28.0}, 10.10.176.0/20{0.0.28.0}]"); # 28 = 16+8+4
|
|
bt_assert(format([ 10.10.160.0/19+ ]) = "[10.10.160.0/19{0.0.32.0}, 10.10.160.0/20{0.0.31.255}, 10.10.176.0/20{0.0.31.255}]");
|
|
|
|
bt_assert(format([ ::/0 ]) = "[::/0]");
|
|
bt_assert(format([ 11:22:33:44:55:66:77:88/128 ]) = "[11:22:33:44:55:66:77:88/128{::1}]");
|
|
bt_assert(format([ 11:22:33:44::/64 ]) = "[11:22:33:44::/64{0:0:0:1::}]");
|
|
bt_assert(format([ 11:22:33:44::/64+ ]) = "[11:22:33:44::/64{::1:ffff:ffff:ffff:ffff}]");
|
|
|
|
bt_assert(format([ 11:22:33:44::/65 ]) = "[11:22:33:44::/65{::8000:0:0:0}]");
|
|
bt_assert(format([ 11:22:33:44::/65{65,67} ]) = "[11:22:33:44::/65{::e000:0:0:0}]"); # e = 8+4+2
|
|
bt_assert(format([ 11:22:33:44:8000::/65{66,67} ]) = "[11:22:33:44:8000::/66{::6000:0:0:0}, 11:22:33:44:c000::/66{::6000:0:0:0}]"); # 6 = 4+2
|
|
bt_assert(format([ 11:22:33:44:4000::/66- ]) = "[::/0, ::/1{8000::}, ::/2{4000::}, ::/3{2000::}, 11:22:33:44::/64{ffff:ffff:ffff:ffff::}, 11:22:33:44::/65{::8000:0:0:0}, 11:22:33:44:4000::/66{::4000:0:0:0}]");
|
|
bt_assert(format([ 11:22:33:44:4000::/66+ ]) = "[11:22:33:44:4000::/66{::6000:0:0:0}, 11:22:33:44:4000::/68{::1fff:ffff:ffff:ffff}, 11:22:33:44:5000::/68{::1fff:ffff:ffff:ffff}, 11:22:33:44:6000::/68{::1fff:ffff:ffff:ffff}, 11:22:33:44:7000::/68{::1fff:ffff:ffff:ffff}]");
|
|
bt_assert(format([ 11:22:33:44:c000::/67 ]) = "[11:22:33:44:c000::/67{::2000:0:0:0}]");
|
|
bt_assert(format([ 11:22:33:44:c000::/67{67,71} ]) = "[11:22:33:44:c000::/67{::2000:0:0:0}, 11:22:33:44:c000::/68{::1e00:0:0:0}, 11:22:33:44:d000::/68{::1e00:0:0:0}]");
|
|
bt_assert(format([ 11:22:33:44:c000::/67+ ]) = "[11:22:33:44:c000::/67{::2000:0:0:0}, 11:22:33:44:c000::/68{::1fff:ffff:ffff:ffff}, 11:22:33:44:d000::/68{::1fff:ffff:ffff:ffff}]");
|
|
}
|
|
|
|
bt_test_suite(t_prefix_set, "Testing prefix sets");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing Prefix IPv6
|
|
* -------------------
|
|
*/
|
|
|
|
function t_prefix6()
|
|
prefix px;
|
|
{
|
|
px = 1020::/18;
|
|
bt_assert(format(px) = "1020::/18");
|
|
bt_assert(1020:3040:5060:: ~ 1020:3040:5000::/40);
|
|
bt_assert(1020:3040::/32 ~ 1020:3040::/32);
|
|
bt_assert(1020:3040::/33 ~ 1020:3040::/32);
|
|
bt_assert(1020:3040:5060::/48 ~ 1020:3040::/32);
|
|
bt_assert(1020:3040::/31 !~ 1020:3040::/32);
|
|
bt_assert(1020:3041::/33 !~ 1020:3040::/32);
|
|
}
|
|
|
|
bt_test_suite(t_prefix6, "Testing prefix IPv6");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing prefix IPv6 sets
|
|
* ------------------------
|
|
*/
|
|
|
|
function t_prefix6_set()
|
|
prefix set pxs;
|
|
{
|
|
bt_assert(1180::/16 ~ [ 1100::/8{15, 17} ]);
|
|
bt_assert(12::34 = 12::34);
|
|
bt_assert(12::34 ~ [ 12::33..12::35 ]);
|
|
bt_assert(1020::34 ~ 1000::/8);
|
|
bt_assert(1000::/8 ~ 1000::/8);
|
|
bt_assert(1000::/8 ~ [ 1000::/8+ ]);
|
|
bt_assert(12::34 !~ [ 12::33, 12::35 ]);
|
|
bt_assert(1000::/9 !~ [ 1000::/8- ]);
|
|
bt_assert(1000::/17 !~ [ 1000::/8{15, 16} ]);
|
|
|
|
pxs = [ 1102::/16, 1104::/16+];
|
|
bt_assert(1102::/16 ~ pxs);
|
|
bt_assert(1104::/16 ~ pxs);
|
|
bt_assert(1104::/18 ~ pxs);
|
|
bt_assert(1104::/32 ~ pxs);
|
|
bt_assert(1101::/16 !~ pxs);
|
|
bt_assert(1103::/16 !~ pxs);
|
|
bt_assert(1102::/15 !~ pxs);
|
|
bt_assert(1102::/17 !~ pxs);
|
|
bt_assert(1102::/32 !~ pxs);
|
|
bt_assert(1104::/15 !~ pxs);
|
|
|
|
pxs = ([ 1000::/16{8,12}, 2000::/16{24,28} ]);
|
|
bt_assert(format(pxs) = "[1000::/12{1f0::}, 2000::/16{0:1f0::}]");
|
|
bt_assert(1000::/8 ~ pxs);
|
|
bt_assert(1000::/10 ~ pxs);
|
|
bt_assert(1000::/12 ~ pxs);
|
|
bt_assert(2000::/24 ~ pxs);
|
|
bt_assert(2000:4000::/24 ~ pxs);
|
|
bt_assert(2000::/26 ~ pxs);
|
|
bt_assert(2000:8000::/26 ~ pxs);
|
|
bt_assert(2000::/28 ~ pxs);
|
|
bt_assert(2000:FFF0::/28 ~ pxs);
|
|
bt_assert(1000::/7 !~ pxs);
|
|
bt_assert(1000::/13 !~ pxs);
|
|
bt_assert(1000::/16 !~ pxs);
|
|
bt_assert(2000::/16 !~ pxs);
|
|
bt_assert(2000::/23 !~ pxs);
|
|
bt_assert(2000::/29 !~ pxs);
|
|
bt_assert(1100::/10 !~ pxs);
|
|
bt_assert(2010::/26 !~ pxs);
|
|
|
|
pxs = [ 52E0::/13{13,128} ];
|
|
bt_assert(52E7:BE81:379B:E6FD:541F:B0D0::/93 ~ pxs);
|
|
|
|
pxs = [ 41D8:8718::/30{0,30}, 413A:99A8:6C00::/38{38,128} ];
|
|
bt_assert(4180::/9 ~ pxs);
|
|
}
|
|
|
|
bt_test_suite(t_prefix6_set, "Testing prefix IPv6 sets");
|
|
|
|
|
|
|
|
|
|
function t_flowspec()
|
|
prefix p;
|
|
{
|
|
p = flow4 { dst 10.0.0.0/8; };
|
|
bt_assert(p !~ [ 10.0.0.0/8 ] );
|
|
|
|
bt_assert(format(flow4 { dst 10.0.0.0/8; proto = 23; }) = "flow4 { dst 10.0.0.0/8; proto 23; }");
|
|
bt_assert(format(flow6 { dst ::1/128; src ::2/127; }) = "flow6 { dst ::1/128; src ::2/127; }");
|
|
bt_assert(format(flow6 { next header false 42; }) = "flow6 { next header false 42; }");
|
|
bt_assert(format(flow6 { port 80; }) = "flow6 { port 80; }");
|
|
bt_assert(format(flow6 { dport > 24 && < 30 || 40..50,60..70,80 && >= 90; }) = "flow6 { dport > 24 && < 30 || 40..50,60..70,80 && >= 90; }");
|
|
bt_assert(format(flow6 { sport 0..0x400; }) = "flow6 { sport 0..1024; }");
|
|
bt_assert(format(flow6 { icmp type 80; }) = "flow6 { icmp type 80; }");
|
|
bt_assert(format(flow6 { icmp code 90; }) = "flow6 { icmp code 90; }");
|
|
bt_assert(format(flow6 { tcp flags 0x03/0x0f; }) = "flow6 { tcp flags 0x3/0x3 && 0x0/0xc; }");
|
|
bt_assert(format(flow6 { length 0..65535; }) = "flow6 { length 0..65535; }");
|
|
bt_assert(format(flow6 { dscp = 63; }) = "flow6 { dscp 63; }");
|
|
bt_assert(format(flow6 { fragment is_fragment || !first_fragment; }) = "flow6 { fragment is_fragment || !first_fragment; }");
|
|
bt_assert(format(flow6 { label 1000..2000; }) = "flow6 { label 1000..2000; }");
|
|
bt_assert(format(flow6 { }) = "flow6 { }");
|
|
}
|
|
|
|
bt_test_suite(t_flowspec, "Testing flowspec routes");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing Paths
|
|
* -------------
|
|
*/
|
|
|
|
function mkpath(int a; int b)
|
|
{
|
|
return [= a b 3 2 1 =];
|
|
}
|
|
|
|
define set35 = [3 .. 5];
|
|
|
|
function t_path()
|
|
bgpmask pm1;
|
|
bgppath p2;
|
|
int set set12;
|
|
{
|
|
pm1 = [= 4 3 2 1 =];
|
|
set12 = [1, 2];
|
|
|
|
bt_assert(format(pm1) = "[= 4 3 2 1 =]");
|
|
|
|
bt_assert(+empty+ = +empty+);
|
|
bt_assert(10 !~ +empty+);
|
|
|
|
p2 = prepend( + empty +, 1 );
|
|
p2 = prepend( p2, 2 );
|
|
p2 = prepend( p2, 3 );
|
|
p2 = prepend( p2, 4 );
|
|
|
|
bt_assert(format(p2) = "(path 4 3 2 1)");
|
|
bt_assert(p2.len = 4);
|
|
bt_assert(p2 ~ pm1);
|
|
bt_assert(3 ~ p2);
|
|
bt_assert(p2 ~ [2, 10..20]);
|
|
bt_assert(p2 ~ [4, 10..20]);
|
|
|
|
p2 = prepend(p2, 5);
|
|
bt_assert(p2 !~ pm1);
|
|
bt_assert(10 !~ p2);
|
|
bt_assert(p2 !~ [8, ten..(2*ten)]);
|
|
bt_assert(p2 ~ [= * 4 3 * 1 =]);
|
|
bt_assert(p2 ~ [= (3+2) (2*2) 3 2 1 =]);
|
|
bt_assert(p2 ~ [= 5 [2, 4, 6] 3 [1..2] 1 =]);
|
|
bt_assert(p2 ~ [= 5 set35 3 set12 set12 =]);
|
|
bt_assert(p2 ~ mkpath(5, 4));
|
|
|
|
bt_assert(p2.len = 5);
|
|
bt_assert(p2.first = 5);
|
|
bt_assert(p2.last = 1);
|
|
|
|
bt_assert(p2.len = 5);
|
|
bt_assert(delete(p2, 3) = prepend(prepend(prepend(prepend(+empty+, 1), 2), 4), 5));
|
|
bt_assert(filter(p2, [1..3]) = prepend(prepend(prepend(+empty+, 1), 2), 3));
|
|
|
|
p2 = prepend( + empty +, 5 );
|
|
p2 = prepend( p2, 4 );
|
|
p2 = prepend( p2, 3 );
|
|
p2 = prepend( p2, 3 );
|
|
p2 = prepend( p2, 2 );
|
|
p2 = prepend( p2, 1 );
|
|
|
|
bt_assert(p2 !~ [= 1 2 3 4 5 =]);
|
|
bt_assert(p2 ~ [= 1 2 * 4 5 =]);
|
|
bt_assert(p2 ~ [= 1 2 * 3 4 5 =]);
|
|
bt_assert(p2 ~ [= 1 2 3+ 4 5 =]);
|
|
bt_assert(p2 ~ [= 1 2 3+ 4+ 5 =]);
|
|
bt_assert(p2 !~ [= 1 2 3+ 5+ 4 5 =]);
|
|
bt_assert(p2 !~ [= 1 2 3 3 5+ 4 5 =]);
|
|
bt_assert(delete(p2, 3) = prepend(prepend(prepend(prepend(+empty+, 5), 4), 2), 1));
|
|
bt_assert(delete(p2, [4..5]) = prepend(prepend(prepend(prepend(+empty+, 3), 3), 2), 1));
|
|
|
|
bt_assert(format([= 1 2+ 3 =]) = "[= 1 2 + 3 =]");
|
|
}
|
|
|
|
bt_test_suite(t_path, "Testing paths");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing Community List
|
|
* ----------------------
|
|
*/
|
|
|
|
define p23 = (2, 3);
|
|
|
|
function t_clist()
|
|
clist l;
|
|
clist l2;
|
|
clist r;
|
|
{
|
|
bt_assert((10, 20).asn = 10);
|
|
bt_assert((10, 20).data = 20);
|
|
bt_assert(p23.asn = 2);
|
|
bt_assert(p23.data = 3);
|
|
|
|
l = - empty -;
|
|
bt_assert(l !~ [(*,*)]);
|
|
bt_assert((l ~ [(*,*)]) != (l !~ [(*,*)]));
|
|
|
|
bt_assert(-empty- = -empty-);
|
|
|
|
l = add( l, (one,2) );
|
|
bt_assert(l ~ [(*,*)]);
|
|
l = add( l, (2,one+2) );
|
|
bt_assert(format(l) = "(clist (1,2) (2,3))");
|
|
|
|
bt_assert((2,3) ~ l);
|
|
bt_assert(l ~ [(1,*)]);
|
|
bt_assert(l ~ [p23]);
|
|
bt_assert(l ~ [(2,2..3)]);
|
|
bt_assert(l ~ [(1,1..2)]);
|
|
bt_assert(l ~ [(1,1)..(1,2)]);
|
|
|
|
l = add(l, (2,5));
|
|
l = add(l, (5,one));
|
|
l = add(l, (6,one));
|
|
l = add(l, (one,one));
|
|
l = delete(l, [(5,1),(6,one),(one,1)]);
|
|
l = delete(l, [(5,one),(6,one)]);
|
|
l = filter(l, [(1,*)]);
|
|
bt_assert(l = add(-empty-, (1,2)));
|
|
|
|
bt_assert((2,3) !~ l);
|
|
bt_assert(l !~ [(2,*)]);
|
|
bt_assert(l !~ [(one,3..6)]);
|
|
bt_assert(l ~ [(*,*)]);
|
|
|
|
l = add(l, (3,one));
|
|
l = add(l, (one+one+one,one+one));
|
|
l = add(l, (3,3));
|
|
l = add(l, (3,4));
|
|
l = add(l, (3,5));
|
|
l2 = filter(l, [(3,*)]);
|
|
l = delete(l, [(3,2..4)]);
|
|
bt_assert(l = add(add(add(-empty-, (1,2)), (3,1)), (3,5)));
|
|
bt_assert(l.len = 3);
|
|
|
|
l = add(l, (3,2));
|
|
l = add(l, (4,5));
|
|
bt_assert(l = add(add(add(add(add(-empty-, (1,2)), (3,1)), (3,5)), (3,2)), (4,5)));
|
|
|
|
bt_assert(l.len = 5);
|
|
bt_assert(l ~ [(*,2)]);
|
|
bt_assert(l ~ [(*,5)]);
|
|
bt_assert(l ~ [(*, one)]);
|
|
bt_assert(l !~ [(*,3)]);
|
|
bt_assert(l !~ [(*,(one+6))]);
|
|
bt_assert(l !~ [(*, (one+one+one))]);
|
|
|
|
l = delete(l, [(*,(one+onef(3)))]);
|
|
l = delete(l, [(*,(4+one))]);
|
|
bt_assert(l = add(-empty-, (3,1)));
|
|
|
|
l = delete(l, [(*,(onef(5)))]);
|
|
bt_assert(l = -empty-);
|
|
|
|
l2 = add(l2, (3,6));
|
|
l = filter(l2, [(3,1..4)]);
|
|
l2 = filter(l2, [(3,3..6)]);
|
|
|
|
# clist A (10,20,30)
|
|
bt_assert(l = add(add(add(add(-empty-, (3,1)), (3,2)), (3,3)), (3,4)));
|
|
bt_assert(format(l) = "(clist (3,1) (3,2) (3,3) (3,4))");
|
|
|
|
# clist B (30,40,50)
|
|
bt_assert(l2 = add(add(add(add(-empty-, (3,3)), (3,4)), (3,5)), (3,6)));
|
|
bt_assert(format(l2) = "(clist (3,3) (3,4) (3,5) (3,6))");
|
|
|
|
# clist A union B
|
|
r = add(l, l2);
|
|
bt_assert(r = add(add(add(add(add(add(-empty-, (3,1)), (3,2)), (3,3)), (3,4)), (3,5)), (3,6)));
|
|
bt_assert(format(r) = "(clist (3,1) (3,2) (3,3) (3,4) (3,5) (3,6))");
|
|
|
|
# clist A isect B
|
|
r = filter(l, l2);
|
|
bt_assert(r = add(add(-empty-, (3,3)), (3,4)));
|
|
bt_assert(format(r) = "(clist (3,3) (3,4))");
|
|
|
|
# clist A \ B
|
|
r = delete(l, l2);
|
|
bt_assert(r = add(add(-empty-, (3,1)), (3,2)));
|
|
bt_assert(format(r) = "(clist (3,1) (3,2))");
|
|
|
|
# clist in c set
|
|
r = filter(l, [(3,1), (*,2)]);
|
|
bt_assert(r = add(add(-empty-, (3,1)), (3,2)));
|
|
bt_assert(format(r) = "(clist (3,1) (3,2))");
|
|
|
|
# minimim & maximum element
|
|
r = add(add(add(add(add(-empty-, (2,1)), (1,3)), (2,2)), (3,1)), (2,3));
|
|
bt_assert(format(r) = "(clist (2,1) (1,3) (2,2) (3,1) (2,3))");
|
|
bt_assert(r.min = (1,3));
|
|
bt_assert(r.max = (3,1));
|
|
}
|
|
|
|
bt_test_suite(t_clist, "Testing lists of communities");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing Extended Communities
|
|
* ----------------------------
|
|
*/
|
|
|
|
function t_ec()
|
|
ec cc;
|
|
{
|
|
cc = (rt, 12345, 200000);
|
|
bt_assert(format(cc) = "(rt, 12345, 200000)");
|
|
|
|
bt_assert(cc = (rt, 12345, 200000));
|
|
bt_assert(cc < (rt, 12345, 200010));
|
|
bt_assert(cc != (rt, 12346, 200000));
|
|
bt_assert(cc != (ro, 12345, 200000));
|
|
bt_assert(!(cc > (rt, 12345, 200010)));
|
|
|
|
bt_assert(format((ro, 100000, 20000)) = "(ro, 100000, 20000)");
|
|
}
|
|
|
|
bt_test_suite(t_ec, "Testing extended communities");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing Extended Community List
|
|
* -------------------------------
|
|
*/
|
|
|
|
function t_eclist()
|
|
eclist el;
|
|
eclist el2;
|
|
eclist r;
|
|
{
|
|
el = -- empty --;
|
|
el = add(el, (rt, 10, 20));
|
|
el = add(el, (ro, 10.20.30.40, 100));
|
|
el = add(el, (ro, 11.21.31.41.mask(16), 200));
|
|
|
|
bt_assert(--empty-- = --empty--);
|
|
bt_assert(((rt, 10, 20)) !~ --empty--);
|
|
|
|
bt_assert(format(el) = "(eclist (rt, 10, 20) (ro, 10.20.30.40, 100) (ro, 11.21.0.0, 200))");
|
|
bt_assert(el.len = 3);
|
|
el = delete(el, (rt, 10, 20));
|
|
el = delete(el, (rt, 10, 30));
|
|
bt_assert(el = add(add(--empty--, (ro, 10.20.30.40, 100)), (ro, 11.21.0.0, 200)));
|
|
el = add(el, (unknown 2, ten, 1));
|
|
el = add(el, (unknown 5, ten, 1));
|
|
el = add(el, (rt, ten, one+one));
|
|
el = add(el, (rt, 10, 3));
|
|
el = add(el, (rt, 10, 4));
|
|
el = add(el, (rt, 10, 5));
|
|
el = add(el, (generic, 0x2000a, 3*ten));
|
|
el = delete(el, [(rt, 10, 2..ten)]);
|
|
bt_assert(el = add(add(add(add(add(--empty--, (ro, 10.20.30.40, 100)), (ro, 11.21.0.0, 200)), (rt, 10, 1)), (unknown 5, 10, 1)), (rt, 10, 30)));
|
|
|
|
el = filter(el, [(rt, 10, *)]);
|
|
bt_assert(el = add(add(--empty--, (rt, 10, 1)), (rt, 10, 30)));
|
|
bt_assert((rt, 10, 1) ~ el);
|
|
bt_assert(el ~ [(rt, 10, ten..40)]);
|
|
bt_assert((rt, 10, 20) !~ el);
|
|
bt_assert((ro, 10.20.30.40, 100) !~ el);
|
|
bt_assert(el !~ [(rt, 10, 35..40)]);
|
|
bt_assert(el !~ [(ro, 10, *)]);
|
|
|
|
el = add(el, (rt, 10, 40));
|
|
el2 = filter(el, [(rt, 10, 20..40)] );
|
|
el2 = add(el2, (rt, 10, 50));
|
|
|
|
# eclist A (1,30,40)
|
|
bt_assert(el = add(add(add(--empty--, (rt, 10, 1)), (rt, 10, 30)), (rt, 10, 40)));
|
|
bt_assert(format(el) = "(eclist (rt, 10, 1) (rt, 10, 30) (rt, 10, 40))");
|
|
|
|
# eclist B (30,40,50)
|
|
bt_assert(el2 = add(add(add(--empty--, (rt, 10, 30)), (rt, 10, 40)), (rt, 10, 50)));
|
|
bt_assert(format(el2) = "(eclist (rt, 10, 30) (rt, 10, 40) (rt, 10, 50))");
|
|
|
|
# eclist A union B
|
|
r = add(el2, el);
|
|
bt_assert(r = add(add(add(add(--empty--, (rt, 10, 30)), (rt, 10, 40)), (rt, 10, 50)), (rt, 10, 1)));
|
|
bt_assert(format(r) = "(eclist (rt, 10, 30) (rt, 10, 40) (rt, 10, 50) (rt, 10, 1))");
|
|
|
|
# eclist A isect B
|
|
r = filter(el, el2);
|
|
bt_assert(r = add(add(--empty--, (rt, 10, 30)), (rt, 10, 40)));
|
|
bt_assert(format(r) = "(eclist (rt, 10, 30) (rt, 10, 40))");
|
|
|
|
# eclist A \ B
|
|
r = delete(el, el2);
|
|
bt_assert(r = add(--empty--, (rt, 10, 1)));
|
|
bt_assert(format(r) = "(eclist (rt, 10, 1))");
|
|
|
|
# eclist in ec set
|
|
r = filter(el, [(rt, 10, 1), (rt, 10, 25..30), (ro, 10, 40)]);
|
|
bt_assert(r = add(add(--empty--, (rt, 10, 1)), (rt, 10, 30)));
|
|
bt_assert(format(r) = "(eclist (rt, 10, 1) (rt, 10, 30))");
|
|
|
|
# minimim & maximum element
|
|
r = add(add(add(add(add(--empty--, (rt, 2, 1)), (rt, 1, 3)), (rt, 2, 2)), (rt, 3, 1)), (rt, 2, 3));
|
|
bt_assert(format(r) = "(eclist (rt, 2, 1) (rt, 1, 3) (rt, 2, 2) (rt, 3, 1) (rt, 2, 3))");
|
|
bt_assert(r.min = (rt, 1, 3));
|
|
bt_assert(r.max = (rt, 3, 1));
|
|
}
|
|
|
|
bt_test_suite(t_eclist, "Testing lists of extended communities");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing sets of Extended Communities
|
|
* ------------------------------------
|
|
*/
|
|
|
|
define ecs2 = [(rt, ten, (one+onef(0))*10), (ro, 100000, 100..200), (rt, 12345, *)];
|
|
|
|
function t_ec_set()
|
|
ec set ecs;
|
|
{
|
|
ecs = [(rt, ten, (one+onef(0))*10), (ro, 100000, 100..200), (rt, 12345, *)];
|
|
bt_assert(format(ecs) = "[(rt, 10, 20), (rt, 12345, 0)..(rt, 12345, 4294967295), (ro, 100000, 100)..(ro, 100000, 200)]");
|
|
bt_assert(format(ecs2) = "[(rt, 10, 20), (rt, 12345, 0)..(rt, 12345, 4294967295), (ro, 100000, 100)..(ro, 100000, 200)]");
|
|
|
|
bt_assert((rt, 10, 20) ~ ecs);
|
|
bt_assert((ro, 100000, 100) ~ ecs);
|
|
bt_assert((ro, 100000, 128) ~ ecs);
|
|
bt_assert((ro, 100000, 200) ~ ecs);
|
|
bt_assert((rt, 12345, 0) ~ ecs);
|
|
bt_assert((rt, 12345, 200000) ~ ecs);
|
|
bt_assert((rt, 12345, 4000000) ~ ecs);
|
|
bt_assert((ro, 10, 20) !~ ecs);
|
|
bt_assert((rt, 10, 21) !~ ecs);
|
|
bt_assert((ro, 100000, 99) !~ ecs);
|
|
bt_assert((ro, 12345, 10) !~ ecs);
|
|
bt_assert((rt, 12346, 0) !~ ecs);
|
|
bt_assert((ro, 0.1.134.160, 150) !~ ecs);
|
|
}
|
|
|
|
bt_test_suite(t_ec_set, "Testing sets of extended communities");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing Large Communities
|
|
* -------------------------
|
|
*/
|
|
|
|
function mktrip(int a)
|
|
{
|
|
return (a, 2*a, 3*a);
|
|
}
|
|
|
|
function t_lclist()
|
|
lclist ll;
|
|
lclist ll2;
|
|
lclist r;
|
|
{
|
|
bt_assert(---empty--- = ---empty---);
|
|
bt_assert((10, 20, 30) !~ ---empty---);
|
|
|
|
bt_assert((10, 20, 30).asn = 10);
|
|
bt_assert((10, 20, 30).data1 = 20);
|
|
bt_assert((10, 20, 30).data2 = 30);
|
|
|
|
ll = --- empty ---;
|
|
ll = add(ll, (ten, 20, 30));
|
|
ll = add(ll, (1000, 2000, 3000));
|
|
ll = add(ll, mktrip(100000));
|
|
bt_assert(format(ll) = "(lclist (10, 20, 30) (1000, 2000, 3000) (100000, 200000, 300000))");
|
|
bt_assert(ll.len = 3);
|
|
bt_assert(ll = add(add(add(---empty---, (10, 20, 30)), (1000, 2000, 3000)), (100000, 200000, 300000)));
|
|
|
|
bt_assert(mktrip(1000) ~ ll);
|
|
bt_assert(mktrip(100) !~ ll);
|
|
|
|
ll = --- empty ---;
|
|
ll = add(ll, (10, 10, 10));
|
|
ll = add(ll, (20, 20, 20));
|
|
ll = add(ll, (30, 30, 30));
|
|
|
|
ll2 = --- empty ---;
|
|
ll2 = add(ll2, (20, 20, 20));
|
|
ll2 = add(ll2, (30, 30, 30));
|
|
ll2 = add(ll2, (40, 40, 40));
|
|
|
|
# lclist A (10, 20, 30)
|
|
bt_assert(format(ll) = "(lclist (10, 10, 10) (20, 20, 20) (30, 30, 30))");
|
|
|
|
# lclist B (20, 30, 40)
|
|
bt_assert(format(ll2) = "(lclist (20, 20, 20) (30, 30, 30) (40, 40, 40))");
|
|
|
|
# lclist A union B
|
|
r = add(ll, ll2);
|
|
bt_assert(r = add(add(add(add(---empty---, (10,10,10)), (20,20,20)), (30,30,30)), (40,40,40)));
|
|
bt_assert(format(r) = "(lclist (10, 10, 10) (20, 20, 20) (30, 30, 30) (40, 40, 40))");
|
|
|
|
# lclist A isect B
|
|
r = filter(ll, ll2);
|
|
bt_assert(r = add(add(---empty---, (20, 20, 20)), (30, 30, 30)));
|
|
bt_assert(format(r) = "(lclist (20, 20, 20) (30, 30, 30))");
|
|
|
|
# lclist A \ B
|
|
r = delete(ll, ll2);
|
|
bt_assert(r = add(---empty---, (10, 10, 10)));
|
|
bt_assert(format(r) = "(lclist (10, 10, 10))");
|
|
|
|
# lclist in lc set
|
|
r = filter(ll, [(5..15, *, *), (20, 15..25, *)]);
|
|
bt_assert(r = add(add(---empty---, (10, 10, 10)), (20, 20, 20)));
|
|
bt_assert(format(r) = "(lclist (10, 10, 10) (20, 20, 20))");
|
|
|
|
# minimim & maximum element
|
|
r = add(add(add(add(add(---empty---, (2, 3, 3)), (1, 2, 3)), (2, 3, 1)), (3, 1, 2)), (2, 1, 3));
|
|
bt_assert(format(r) = "(lclist (2, 3, 3) (1, 2, 3) (2, 3, 1) (3, 1, 2) (2, 1, 3))");
|
|
bt_assert(r.min = (1, 2, 3));
|
|
bt_assert(r.max = (3, 1, 2));
|
|
}
|
|
|
|
bt_test_suite(t_lclist, "Testing lists of large communities");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing sets of Large Communities
|
|
* ---------------------------------
|
|
*/
|
|
|
|
function t_lclist_set()
|
|
lclist ll;
|
|
lc set lls;
|
|
{
|
|
ll = --- empty ---;
|
|
ll = add(ll, (10, 20, 30));
|
|
ll = add(ll, (1000, 2000, 3000));
|
|
ll = add(ll, mktrip(100000));
|
|
|
|
bt_assert(ll ~ [(5,10,15), (10,20,30)]);
|
|
bt_assert(ll ~ [(10,15..25,*)]);
|
|
bt_assert(ll ~ [(ten, *, *)]);
|
|
|
|
bt_assert(ll !~ [(5,10,15), (10,21,30)]);
|
|
bt_assert(ll !~ [(10,21..25,*)]);
|
|
bt_assert(ll !~ [(11, *, *)]);
|
|
|
|
lls = [(10, 10, 10), (20, 20, 15..25), (30, 30, *), (40, 35..45, *), (50, *, *), (55..65, *, *)];
|
|
bt_assert(format(lls) = "[(10, 10, 10), (20, 20, 15)..(20, 20, 25), (30, 30, 0)..(30, 30, 4294967295), (40, 35, 0)..(40, 45, 4294967295), (50, 0, 0)..(50, 4294967295, 4294967295), (55, 0, 0)..(65, 4294967295, 4294967295)]");
|
|
bt_assert((10, 10, 10) ~ lls);
|
|
bt_assert((20, 20, 25) ~ lls);
|
|
bt_assert((20, 20, 26) !~ lls);
|
|
bt_assert((30, 30, 0) ~ lls);
|
|
bt_assert((40, 35, 40) ~ lls);
|
|
bt_assert((40, 34, 40) !~ lls);
|
|
bt_assert((50, 0, 0) ~ lls);
|
|
bt_assert((60, 60, 60) ~ lls);
|
|
bt_assert((70, 60, 60) !~ lls);
|
|
}
|
|
|
|
bt_test_suite(t_lclist_set, "Testing sets of large communities");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing Route Distinguishers
|
|
* ----------------------------
|
|
*/
|
|
|
|
function t_rd()
|
|
rd x;
|
|
{
|
|
x = 12345:20000;
|
|
bt_assert(format(x) = "12345:20000");
|
|
|
|
bt_assert(x = 12345:20000);
|
|
bt_assert(x < 12345:20010);
|
|
bt_assert(x != 12346:20000);
|
|
bt_assert(x != 2:12345:20000);
|
|
bt_assert(!(x > 12345:200010));
|
|
|
|
bt_assert(format(0:1:2) = "1:2");
|
|
bt_assert(format(10.0.0.1:1000) = "10.0.0.1:1000");
|
|
bt_assert(format(100000:20000) = "100000:20000");
|
|
bt_assert(format(2:100000:20000) = "100000:20000");
|
|
bt_assert(format(2:1000:1000) = "2:1000:1000");
|
|
}
|
|
|
|
bt_test_suite(t_rd, "Testing route distinguishers");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing sets of Route Distinguishers
|
|
* ------------------------------------
|
|
*/
|
|
|
|
function t_rd_set()
|
|
rd set rds;
|
|
{
|
|
rds = [10:20, 100000:100..100000:200];
|
|
bt_assert(format(rds) = "[10:20, 100000:100..100000:200]");
|
|
|
|
bt_assert(10:20 ~ rds);
|
|
bt_assert(10:21 !~ rds);
|
|
bt_assert(100000:90 !~ rds);
|
|
bt_assert(100000:100 ~ rds);
|
|
bt_assert(100000:128 ~ rds);
|
|
bt_assert(100000:200 ~ rds);
|
|
bt_assert(100010:150 !~ rds);
|
|
}
|
|
|
|
bt_test_suite(t_rd_set, "Testing sets of route distinguishers");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing defined() function
|
|
* --------------------------
|
|
*/
|
|
|
|
function test_undef(int a)
|
|
int b;
|
|
{
|
|
if a = 3 then {
|
|
b = 4;
|
|
bt_assert(defined(b));
|
|
}
|
|
else {
|
|
bt_assert(!defined(b));
|
|
}
|
|
}
|
|
|
|
function t_define()
|
|
int i;
|
|
{
|
|
test_undef(2);
|
|
test_undef(3);
|
|
test_undef(2);
|
|
|
|
bt_assert(defined(1));
|
|
bt_assert(defined(1.2.3.4));
|
|
}
|
|
|
|
bt_test_suite(t_define, "Testing defined() function");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Testing calling functions
|
|
* -------------------------
|
|
*/
|
|
|
|
function callme(int arg1; int arg2)
|
|
int i;
|
|
{
|
|
case arg1 {
|
|
1, 42: return 42;
|
|
else: return arg1 * arg2;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
function callmeagain(int a; int b; int c)
|
|
{
|
|
return a + b + c;
|
|
}
|
|
|
|
function fifteen()
|
|
{
|
|
return 15;
|
|
}
|
|
|
|
function t_call_function()
|
|
{
|
|
bt_assert(fifteen() = 15);
|
|
|
|
bt_assert(callme(1, 2) = 42);
|
|
bt_assert(callme(42, 2) = 42);
|
|
|
|
bt_assert(callme(2, 2) = 4);
|
|
bt_assert(callme(3, 2) = 6);
|
|
bt_assert(callme(4, 4) = 16);
|
|
bt_assert(callme(7, 2) = 14);
|
|
bt_assert(callmeagain(1, 2, 3) = 6);
|
|
}
|
|
|
|
bt_test_suite(t_call_function, "Testing calling functions");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Test including another config file
|
|
* ----------------------------------
|
|
*/
|
|
|
|
function t_include()
|
|
int i;
|
|
{
|
|
i = 1;
|
|
include "test.conf.inc";
|
|
bt_assert(i = 42);
|
|
}
|
|
|
|
bt_test_suite(t_include, "Testing including another config file");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Test if-else statement
|
|
* ----------------------
|
|
*/
|
|
|
|
function t_if_else()
|
|
int i;
|
|
{
|
|
/* Empty blocks regression test */
|
|
if true then {}
|
|
else {}
|
|
|
|
if true then
|
|
bt_assert(true);
|
|
|
|
if false then
|
|
bt_assert(false);
|
|
else if true then
|
|
bt_assert(true);
|
|
else
|
|
bt_assert(false);
|
|
|
|
/* Empty blocks regression test */
|
|
if true then {}
|
|
else {}
|
|
}
|
|
|
|
bt_test_suite(t_if_else, "Testing if-else statement");
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Unused functions -- testing only parsing
|
|
* ----------------------------------------
|
|
*/
|
|
|
|
function __test1()
|
|
{
|
|
if source ~ [ RTS_BGP, RTS_STATIC ] then {
|
|
# ospf_metric1 = 65535;
|
|
# ospf_metric2 = 1000;
|
|
ospf_tag = 0x12345678;
|
|
accept;
|
|
}
|
|
reject;
|
|
}
|
|
|
|
function __test2()
|
|
{
|
|
if source ~ [ RTS_BGP, RTS_STATIC ] then {
|
|
# ospf_metric1 = 65535;
|
|
# ospf_metric2 = 1000;
|
|
ospf_tag = 0x12345678;
|
|
accept;
|
|
}
|
|
reject;
|
|
}
|
|
|
|
filter testf
|
|
int j;
|
|
bool t;
|
|
{
|
|
print "Heya, filtering route to ", net.ip, " prefixlen ", net.len, " source ", source;
|
|
print "This route was from ", from;
|
|
j = 7;
|
|
j = 17;
|
|
if rip_metric > 15 then {
|
|
reject "RIP Metric is more than infinity";
|
|
}
|
|
rip_metric = 14;
|
|
unset(rip_metric);
|
|
|
|
test_ca_int1 = 42;
|
|
test_ca_ip2 = 1.3.5.7;
|
|
test_ca_quad3 = 2.4.6.8;
|
|
test_ca_bgppath4 = +empty+;
|
|
test_ca_clist5 = -empty-;
|
|
test_ca_eclist6 = --empty--;
|
|
test_ca_lclist7 = ---empty---;
|
|
|
|
igp_metric = 53;
|
|
babel_metric = 64;
|
|
t = defined(babel_router_id);
|
|
j = babel_seqno;
|
|
|
|
bgp_origin = ORIGIN_IGP;
|
|
bgp_path = +empty+;
|
|
bgp_next_hop = 3456:789a:bcde:f012::3456:789a;
|
|
bgp_med = 71;
|
|
bgp_local_pref = 942;
|
|
t = defined(bgp_atomic_aggr);
|
|
t = defined(bgp_aggregator);
|
|
bgp_community = -empty-;
|
|
bgp_originator_id = 9.7.5.3;
|
|
bgp_cluster_list = -empty-;
|
|
t = defined(bgp_mp_reach_nlri);
|
|
t = defined(bgp_mp_unreach_nlri);
|
|
bgp_ext_community = --empty--;
|
|
bgp_as4_path = +empty+;
|
|
t = defined(bgp_as4_aggregator);
|
|
t = defined(bgp_aigp);
|
|
bgp_large_community = ---empty---;
|
|
t = defined(bgp_mpls_label_stack);
|
|
|
|
ospf_metric1 = 64;
|
|
ospf_metric2 = 111;
|
|
ospf_tag = 654432;
|
|
|
|
radv_preference = RA_PREF_LOW;
|
|
radv_lifetime = 28;
|
|
|
|
rip_metric = 2;
|
|
rip_tag = 4;
|
|
t = defined(rip_from);
|
|
|
|
krt_source = 17;
|
|
krt_metric = 19;
|
|
|
|
# krt_lock_mtu = false;
|
|
# krt_lock_window = true;
|
|
# krt_lock_rtt = krt_lock_rttvar && krt_lock_sstresh || krt_lock_cwnd;
|
|
|
|
accept "ok I take that";
|
|
}
|
|
|
|
filter roa_filter
|
|
{
|
|
if net ~ [ 10.0.0.0/8{16,24} ] || net ~ [ 2000::/3{16,96} ] then {
|
|
accept;
|
|
}
|
|
reject;
|
|
}
|
|
|
|
roa4 table r4;
|
|
roa6 table r6;
|
|
|
|
protocol static
|
|
{
|
|
roa4 { table r4; import filter roa_filter; };
|
|
route 10.110.0.0/16 max 16 as 1000;
|
|
route 10.120.0.0/16 max 24 as 1000;
|
|
route 10.130.0.0/16 max 24 as 2000;
|
|
route 10.130.128.0/18 max 24 as 3000;
|
|
}
|
|
|
|
protocol static
|
|
{
|
|
roa6 { table r6; import filter roa_filter; };
|
|
route 2001:0db8:85a3:8a2e::/64 max 96 as 1000;
|
|
}
|
|
|
|
function t_roa_check()
|
|
prefix pfx;
|
|
{
|
|
bt_assert(roa_check(r4, 10.10.0.0/16, 1000) = ROA_UNKNOWN);
|
|
bt_assert(roa_check(r4, 10.0.0.0/8, 1000) = ROA_UNKNOWN);
|
|
bt_assert(roa_check(r4, 10.110.0.0/16, 1000) = ROA_VALID);
|
|
bt_assert(roa_check(r4, 10.110.0.0/16, 2000) = ROA_INVALID);
|
|
bt_assert(roa_check(r4, 10.110.32.0/20, 1000) = ROA_INVALID);
|
|
bt_assert(roa_check(r4, 10.120.32.0/20, 1000) = ROA_VALID);
|
|
bt_assert(roa_check(r4, 10.120.32.0/20, 2000) = ROA_INVALID);
|
|
bt_assert(roa_check(r4, 10.120.32.32/28, 1000) = ROA_INVALID);
|
|
bt_assert(roa_check(r4, 10.130.130.0/24, 1000) = ROA_INVALID);
|
|
bt_assert(roa_check(r4, 10.130.130.0/24, 2000) = ROA_VALID);
|
|
bt_assert(roa_check(r4, 10.130.30.0/24, 3000) = ROA_INVALID);
|
|
bt_assert(roa_check(r4, 10.130.130.0/24, 3000) = ROA_VALID);
|
|
|
|
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e:1234::/80, 1000) = ROA_VALID);
|
|
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e:1234::/97, 1000) = ROA_INVALID);
|
|
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e::/64, 1000) = ROA_VALID);
|
|
bt_assert(roa_check(r6, 2001:0db8:85a3::/48, 1000) = ROA_UNKNOWN);
|
|
|
|
bt_assert(roa_check(r4, 10.10.0.0/16, 1000) = ROA_UNKNOWN);
|
|
bt_assert(roa_check(r4, 10.0.0.0/8, 1000) = ROA_UNKNOWN);
|
|
bt_assert(roa_check(r4, 10.110.0.0/16, 1000) = ROA_VALID);
|
|
bt_assert(roa_check(r4, 10.110.0.0/16, 2000) = ROA_INVALID);
|
|
bt_assert(roa_check(r4, 10.110.32.0/20, 1000) = ROA_INVALID);
|
|
bt_assert(roa_check(r4, 10.120.32.0/20, 1000) = ROA_VALID);
|
|
|
|
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e:1234::/80, 1000) = ROA_VALID);
|
|
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e:1234::/97, 1000) = ROA_INVALID);
|
|
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e::/64, 1000) = ROA_VALID);
|
|
bt_assert(roa_check(r6, 2001:0db8:85a3::/48, 1000) = ROA_UNKNOWN);
|
|
|
|
bt_assert(roa_check(r4, 2001:0db8:85a3:8a2e:1234::/97, 1000) = ROA_UNKNOWN);
|
|
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e:1234::/97, 1000) = ROA_INVALID);
|
|
|
|
bt_assert(roa_check(r4, 2001:0db8:85a3:8a2e:1234::/80, 1000) = ROA_UNKNOWN);
|
|
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e:1234::/80, 1000) = ROA_VALID);
|
|
bt_assert(roa_check(r4, 2001:0db8:85a3::/48, 1000) = ROA_UNKNOWN);
|
|
bt_assert(roa_check(r6, 2001:0db8:85a3::/48, 1000) = ROA_UNKNOWN);
|
|
|
|
bt_assert(10.130.130.0/24 ~ 0.0.0.0/0);
|
|
bt_assert(2001:0db8:85a3:8a2e::/64 ~ ::/0);
|
|
bt_assert(10.130.130.0/24 !~ ::/0);
|
|
bt_assert(2001:0db8:85a3:8a2e::/64 !~ 0.0.0.0/0);
|
|
|
|
pfx = 12.13.0.0/16 max 24 as 1234;
|
|
bt_assert(pfx.len = 16);
|
|
bt_assert(pfx.maxlen = 24);
|
|
bt_assert(pfx.asn = 1234);
|
|
|
|
pfx = 1000::/8 max 32 as 1234;
|
|
bt_assert(pfx.len = 8);
|
|
bt_assert(pfx.maxlen = 32);
|
|
bt_assert(pfx.asn = 1234);
|
|
}
|
|
|
|
bt_test_suite(t_roa_check, "Testing ROA");
|
|
|
|
|
|
|
|
|
|
filter vpn_filter
|
|
{
|
|
bt_assert(format(net) = "1:2 10.1.10.0/24");
|
|
bt_assert(net.type = NET_VPN4);
|
|
bt_assert(net.type != NET_IP4);
|
|
bt_assert(net.type != NET_IP6);
|
|
bt_assert(net.rd = 0:1:2);
|
|
|
|
case (net.type) {
|
|
NET_IP4: print "IPV4";
|
|
NET_IP6: print "IPV6";
|
|
}
|
|
|
|
bt_check_assign(from, 10.20.30.40);
|
|
bt_check_assign(gw, 55.55.55.44);
|
|
|
|
bgp_community.add((3,5));
|
|
bgp_ext_community.add((ro, 135, 999));
|
|
bgp_large_community.add((6464156, 89646354, 8675643));
|
|
|
|
accept;
|
|
}
|
|
|
|
vpn4 table v4;
|
|
vpn4 table v6;
|
|
|
|
protocol static
|
|
{
|
|
vpn4 { table v4; import filter vpn_filter; };
|
|
route 0:1:2 10.1.10.0/24 unreachable;
|
|
}
|
|
|
|
protocol static
|
|
{
|
|
ipv6 { import where false; };
|
|
route fd01::/48 unreachable;
|
|
}
|