diff options
Diffstat (limited to 'tests/bgpd/test_aspath.c')
| -rw-r--r-- | tests/bgpd/test_aspath.c | 1347 |
1 files changed, 1347 insertions, 0 deletions
diff --git a/tests/bgpd/test_aspath.c b/tests/bgpd/test_aspath.c new file mode 100644 index 0000000..ef1fcf5 --- /dev/null +++ b/tests/bgpd/test_aspath.c @@ -0,0 +1,1347 @@ +/* + * Copyright (C) 2005 Sun Microsystems, Inc. + * + * This file is part of Quagga. + * + * Quagga is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2, or (at your option) any + * later version. + * + * Quagga is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; see the file COPYING; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <zebra.h> + +#include "vty.h" +#include "stream.h" +#include "privs.h" +#include "queue.h" +#include "filter.h" +#include "frr_pthread.h" + +#include "bgpd/bgpd.c" +#include "bgpd/bgp_aspath.h" +#include "bgpd/bgp_attr.h" +#include "bgpd/bgp_packet.h" + +#define VT100_RESET "\x1b[0m" +#define VT100_RED "\x1b[31m" +#define VT100_GREEN "\x1b[32m" +#define VT100_YELLOW "\x1b[33m" +#define OK VT100_GREEN "OK" VT100_RESET +#define FAILED VT100_RED "failed" VT100_RESET + +/* need these to link in libbgp */ +struct zebra_privs_t bgpd_privs = {}; +struct thread_master *master = NULL; + +static int failed = 0; + +/* specification for a test - what the results should be */ +struct test_spec { + const char *shouldbe; /* the string the path should parse to */ + const char *shouldbe_delete_confed; /* ditto, but once confeds are + deleted */ + const unsigned int hops; /* aspath_count_hops result */ + const unsigned int confeds; /* aspath_count_confeds */ + const int private_as; /* whether the private_as check should pass or + fail */ +#define NOT_ALL_PRIVATE 0 +#define ALL_PRIVATE 1 + const as_t does_loop; /* an ASN which should trigger loop-check */ + const as_t doesnt_loop; /* one which should not */ + const as_t first; /* the first ASN, if there is one */ +#define NULL_ASN 0 +}; + + +/* test segments to parse and validate, and use for other tests */ +static struct test_segment { + const char *name; + const char *desc; + const uint8_t asdata[1024]; + int len; + struct test_spec sp; +} test_segments[] = { + { + /* 0 */ + "seq1", + "seq(8466,3,52737,4096)", + {0x2, 0x4, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00}, + 10, + {"8466 3 52737 4096", "8466 3 52737 4096", 4, 0, + NOT_ALL_PRIVATE, 4096, 4, 8466}, + }, + { + /* 1 */ + "seq2", + "seq(8722) seq(4)", + {0x2, 0x1, 0x22, 0x12, 0x2, 0x1, 0x00, 0x04}, + 8, + { + "8722 4", "8722 4", 2, 0, NOT_ALL_PRIVATE, 4, 5, 8722, + }, + }, + { + /* 2 */ + "seq3", + "seq(8466,3,52737,4096,8722,4)", + {0x2, 0x6, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x22, + 0x12, 0x00, 0x04}, + 14, + {"8466 3 52737 4096 8722 4", "8466 3 52737 4096 8722 4", 6, 0, + NOT_ALL_PRIVATE, 3, 5, 8466}, + }, + { + /* 3 */ + "seqset", + "seq(8482,51457) set(5204)", + {0x2, 0x2, 0x21, 0x22, 0xc9, 0x01, 0x1, 0x1, 0x14, 0x54}, + 10, + {"8482 51457 {5204}", "8482 51457 {5204}", 3, 0, + NOT_ALL_PRIVATE, 5204, 51456, 8482}, + }, + { + /* 4 */ + "seqset2", + "seq(8467, 59649) set(4196,48658) set(17322,30745)", + {0x2, 0x2, 0x21, 0x13, 0xe9, 0x01, 0x1, 0x2, 0x10, 0x64, 0xbe, + 0x12, 0x1, 0x2, 0x43, 0xaa, 0x78, 0x19}, + 18, + {"8467 59649 {4196,48658} {17322,30745}", + "8467 59649 {4196,48658} {17322,30745}", 4, 0, NOT_ALL_PRIVATE, + 48658, 1, 8467}, + }, + { + /* 5 */ + "multi", + "seq(6435,59408,21665) set(2457,61697,4369), seq(1842,41590,51793)", + {0x2, 0x3, 0x19, 0x23, 0xe8, 0x10, 0x54, 0xa1, + 0x1, 0x3, 0x09, 0x99, 0xf1, 0x01, 0x11, 0x11, + 0x2, 0x3, 0x07, 0x32, 0xa2, 0x76, 0xca, 0x51}, + 24, + {"6435 59408 21665 {2457,4369,61697} 1842 41590 51793", + "6435 59408 21665 {2457,4369,61697} 1842 41590 51793", 7, 0, + NOT_ALL_PRIVATE, 51793, 1, 6435}, + }, + { + /* 6 */ + "confed", + "confseq(123,456,789)", + {0x3, 0x3, 0x00, 0x7b, 0x01, 0xc8, 0x03, 0x15}, + 8, + {"(123 456 789)", "", 0, 3, NOT_ALL_PRIVATE, 789, 1, NULL_ASN}, + }, + { + /* 7 */ + "confed2", + "confseq(123,456,789) confseq(111,222)", + {0x3, 0x3, 0x00, 0x7b, 0x01, 0xc8, 0x03, 0x15, 0x3, 0x2, 0x00, + 0x6f, 0x00, 0xde}, + 14, + {"(123 456 789) (111 222)", "", 0, 5, NOT_ALL_PRIVATE, 111, 1, + NULL_ASN}, + }, + { + /* 8 */ + "confset", + "confset(456,123,789)", + {0x4, 0x3, 0x01, 0xc8, 0x00, 0x7b, 0x03, 0x15}, + 8, + {"[123,456,789]", "", 0, 1, NOT_ALL_PRIVATE, 123, 1, NULL_ASN}, + }, + { + /* 9 */ + "confmulti", + "confseq(123,456,789) confset(222,111) seq(8722) set(4196,48658)", + {0x3, 0x3, 0x00, 0x7b, 0x01, 0xc8, 0x03, 0x15, + 0x4, 0x2, 0x00, 0xde, 0x00, 0x6f, 0x2, 0x1, + 0x22, 0x12, 0x1, 0x2, 0x10, 0x64, 0xbe, 0x12}, + 24, + {"(123 456 789) [111,222] 8722 {4196,48658}", + "8722 {4196,48658}", 2, 4, NOT_ALL_PRIVATE, 123, 1, NULL_ASN}, + }, + { + /* 10 */ + "seq4", + "seq(8466,2,52737,4096,8722,4)", + {0x2, 0x6, 0x21, 0x12, 0x00, 0x02, 0xce, 0x01, 0x10, 0x00, 0x22, + 0x12, 0x00, 0x04}, + 14, + {"8466 2 52737 4096 8722 4", "8466 2 52737 4096 8722 4", 6, 0, + NOT_ALL_PRIVATE, 4096, 1, 8466}, + }, + { + /* 11 */ + "tripleseq1", + "seq(8466,2,52737) seq(4096,8722,4) seq(8722)", + {0x2, 0x3, 0x21, 0x12, 0x00, 0x02, 0xce, 0x01, 0x2, 0x3, + 0x10, 0x00, 0x22, 0x12, 0x00, 0x04, 0x2, 0x1, 0x22, 0x12}, + 20, + {"8466 2 52737 4096 8722 4 8722", + "8466 2 52737 4096 8722 4 8722", 7, 0, NOT_ALL_PRIVATE, 4096, + 1, 8466}, + }, + { + /* 12 */ + "someprivate", + "seq(8466,64512,52737,65535)", + {0x2, 0x4, 0x21, 0x12, 0xfc, 0x00, 0xce, 0x01, 0xff, 0xff}, + 10, + {"8466 64512 52737 65535", "8466 64512 52737 65535", 4, 0, + NOT_ALL_PRIVATE, 65535, 4, 8466}, + }, + { + /* 13 */ + "allprivate", + "seq(65534,64512,64513,65535)", + {0x2, 0x4, 0xff, 0xfe, 0xfc, 0x00, 0xfc, 0x01, 0xff, 0xff}, + 10, + {"65534 64512 64513 65535", "65534 64512 64513 65535", 4, 0, + ALL_PRIVATE, 65534, 4, 65534}, + }, + { + /* 14 */ + "long", + "seq(8466,3,52737,4096,34285,<repeated 49 more times>)", + { + 0x2, 0xfa, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, + 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, + 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, + 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, + 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, + 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, + 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, + 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, + 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, + 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, + 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, + 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, + 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, + 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, + 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, + 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, + 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, + 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, + 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, + 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, + 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, + 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, + 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, + 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, + 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, + 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, + 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, + 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, + 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, + 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, + 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, + 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, + 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, + 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, + 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, + 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, + 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, + 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, + 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, + 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, + 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, + 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, + 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, + 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, + 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, + 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, + 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, + 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, + 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, + 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, + 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, + 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, + 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, 0xce, + 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, 0x03, + 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, 0x21, 0x12, 0x00, + 0x03, 0xce, 0x01, 0x10, 0x00, 0x85, 0xed, + }, + 502, + {"8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285", + + "8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285", + 250, 0, NOT_ALL_PRIVATE, 4096, 4, 8466}, + }, + { + /* 15 */ + "seq1extra", + "seq(8466,3,52737,4096,3456)", + {0x2, 0x5, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x0d, + 0x80}, + 12, + {"8466 3 52737 4096 3456", "8466 3 52737 4096 3456", 5, 0, + NOT_ALL_PRIVATE, 4096, 4, 8466}, + }, + { + /* 16 */ + "empty", + "<empty>", + {}, + 0, + {"", "", 0, 0, 0, 0, 0, 0}, + }, + { + /* 17 */ + "redundantset", + "seq(8466,3,52737,4096,3456) set(7099,8153,8153,8153)", + {0x2, 0x5, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, + 0x10, 0x00, 0x0d, 0x80, 0x1, 0x4, 0x1b, 0xbb, + 0x1f, 0xd9, 0x1f, 0xd9, 0x1f, 0xd9}, + 22, + {/* We shouldn't ever /generate/ such paths. However, we should + * cope with them fine. + */ + "8466 3 52737 4096 3456 {7099,8153}", + "8466 3 52737 4096 3456 {7099,8153}", 6, 0, NOT_ALL_PRIVATE, + 4096, 4, 8466}, + }, + { + /* 18 */ + "reconcile_lead_asp", + "seq(6435,59408,21665) set(23456,23456,23456), seq(23456,23456,23456)", + {0x2, 0x3, 0x19, 0x23, 0xe8, 0x10, 0x54, 0xa1, + 0x1, 0x3, 0x5b, 0xa0, 0x5b, 0xa0, 0x5b, 0xa0, + 0x2, 0x3, 0x5b, 0xa0, 0x5b, 0xa0, 0x5b, 0xa0}, + 24, + {"6435 59408 21665 {23456} 23456 23456 23456", + "6435 59408 21665 {23456} 23456 23456 23456", 7, 0, + NOT_ALL_PRIVATE, 23456, 1, 6435}, + }, + { + /* 19 */ + "reconcile_new_asp", + "set(2457,61697,4369), seq(1842,41591,51793)", + {0x1, 0x3, 0x09, 0x99, 0xf1, 0x01, 0x11, 0x11, 0x2, 0x3, 0x07, + 0x32, 0xa2, 0x77, 0xca, 0x51}, + 16, + {"{2457,4369,61697} 1842 41591 51793", + "{2457,4369,61697} 1842 41591 51793", 4, 0, NOT_ALL_PRIVATE, + 51793, 1, 2457}, + }, + { + /* 20 */ + "reconcile_confed", + "confseq(123,456,789) confset(456,124,788) seq(6435,59408,21665) set(23456,23456,23456), seq(23456,23456,23456)", + {0x3, 0x3, 0x00, 0x7b, 0x01, 0xc8, 0x03, 0x15, 0x4, 0x3, + 0x01, 0xc8, 0x00, 0x7c, 0x03, 0x14, 0x2, 0x3, 0x19, 0x23, + 0xe8, 0x10, 0x54, 0xa1, 0x1, 0x3, 0x5b, 0xa0, 0x5b, 0xa0, + 0x5b, 0xa0, 0x2, 0x3, 0x5b, 0xa0, 0x5b, 0xa0, 0x5b, 0xa0}, + 40, + {"(123 456 789) [124,456,788] 6435 59408 21665 {23456} 23456 23456 23456", + "6435 59408 21665 {23456} 23456 23456 23456", 7, 4, + NOT_ALL_PRIVATE, 23456, 1, 6435}, + }, + { + /* 21 */ + "reconcile_start_trans", + "seq(23456,23456,23456) seq(6435,59408,21665)", + { + 0x2, 0x3, 0x5b, 0xa0, 0x5b, 0xa0, 0x5b, 0xa0, 0x2, 0x3, + 0x19, 0x23, 0xe8, 0x10, 0x54, 0xa1, + }, + 16, + {"23456 23456 23456 6435 59408 21665", + "23456 23456 23456 6435 59408 21665", 6, 0, NOT_ALL_PRIVATE, + 21665, 1, 23456}, + }, + { + /* 22 */ + "reconcile_start_trans4", + "seq(1842,41591,51793) seq(6435,59408,21665)", + { + 0x2, 0x3, 0x07, 0x32, 0xa2, 0x77, 0xca, 0x51, 0x2, 0x3, + 0x19, 0x23, 0xe8, 0x10, 0x54, 0xa1, + }, + 16, + {"1842 41591 51793 6435 59408 21665", + "1842 41591 51793 6435 59408 21665", 6, 0, NOT_ALL_PRIVATE, + 41591, 1, 1842}, + }, + { + /* 23 */ + "reconcile_start_trans_error", + "seq(23456,23456,23456) seq(6435,59408)", + { + 0x2, 0x3, 0x5b, 0xa0, 0x5b, 0xa0, 0x5b, 0xa0, 0x2, 0x2, + 0x19, 0x23, 0xe8, 0x10, + }, + 14, + {"23456 23456 23456 6435 59408", "23456 23456 23456 6435 59408", + 5, 0, NOT_ALL_PRIVATE, 59408, 1, 23456}, + }, + { + /* 24 */ + "redundantset2", + "seq(8466,3,52737,4096,3456) set(7099,8153,8153,8153,7099)", + { + 0x2, 0x5, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, + 0x10, 0x00, 0x0d, 0x80, 0x1, 0x5, 0x1b, 0xbb, + 0x1f, 0xd9, 0x1f, 0xd9, 0x1f, 0xd9, 0x1b, 0xbb, + }, + 24, + {/* We should weed out duplicate set members. */ + "8466 3 52737 4096 3456 {7099,8153}", + "8466 3 52737 4096 3456 {7099,8153}", 6, 0, NOT_ALL_PRIVATE, + 4096, 4, 8466}, + }, + { + /* 25 */ + "zero-size overflow", + "#ASNs = 0, data = seq(8466 3 52737 4096 3456)", + {0x2, 0x0, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x10, 0x00, 0x0d, + 0x80}, + 12, + {NULL, NULL, 0, 0, 0, 0, 0, 0}, + }, + { + /* 26 */ + "zero-size overflow + valid segment", + "seq(#AS=0:8466 3 52737),seq(4096 3456)", + {0x2, 0x0, 0x21, 0x12, 0x00, 0x03, 0xce, 0x01, 0x2, 0x2, 0x10, + 0x00, 0x0d, 0x80}, + 14, + {NULL, NULL, 0, 0, 0, 0, 0, 0}, + }, + { + /* 27 */ + "invalid segment type", + "type=8(4096 3456)", + {0x8, 0x2, 0x10, 0x00, 0x0d, 0x80}, + 14, + {NULL, NULL, 0, 0, 0, 0, 0, 0}, + }, + { + /* 28 */ + "BGP_AS_ZERO", + "seq(8466,3,52737,0,4096)", + {0x2, 0x5, + 0x21, 0x12, + 0x00, 0x03, + 0xce, 0x01, + 0x00, 0x00, + 0x10, 0x00}, + 12, + {"8466 3 52737 0 4096", "8466 3 52737 0 4096", 5, 0, + NOT_ALL_PRIVATE, 4096, 4, 8466}, + }, + {NULL, NULL, {0}, 0, {NULL, 0, 0}}}; + +#define COMMON_ATTRS \ + BGP_ATTR_FLAG_TRANS, BGP_ATTR_ORIGIN, 1, BGP_ORIGIN_EGP, \ + BGP_ATTR_FLAG_TRANS, BGP_ATTR_NEXT_HOP, 4, 192, 0, 2, 0 +#define COMMON_ATTR_SIZE 11 + +/* */ +static struct aspath_tests { + const char *desc; + const struct test_segment *segment; + const char *shouldbe; /* String it should evaluate to */ + const enum as4 { + AS4_DATA, + AS2_DATA + } as4; /* whether data should be as4 or not (ie as2) */ + const int result; /* expected result for bgp_attr_parse */ + const int cap; /* capabilities to set for peer */ + const char attrheader[1024]; + size_t len; + const struct test_segment *old_segment; +} aspath_tests[] = { + /* 0 */ + { + "basic test", + &test_segments[0], + "8466 3 52737 4096", + AS2_DATA, + 0, + 0, + { + COMMON_ATTRS, + BGP_ATTR_FLAG_TRANS, + BGP_ATTR_AS_PATH, + 10, + }, + COMMON_ATTR_SIZE + 3, + }, + /* 1 */ + { + "length too short", + &test_segments[0], + "8466 3 52737 4096", + AS2_DATA, + -1, + 0, + { + COMMON_ATTRS, + BGP_ATTR_FLAG_TRANS, + BGP_ATTR_AS_PATH, + 8, + }, + COMMON_ATTR_SIZE + 3, + }, + /* 2 */ + { + "length too long", + &test_segments[0], + "8466 3 52737 4096", + AS2_DATA, + -1, + 0, + { + COMMON_ATTRS, + BGP_ATTR_FLAG_TRANS, + BGP_ATTR_AS_PATH, + 12, + }, + COMMON_ATTR_SIZE + 3, + }, + /* 3 */ + { + "incorrect flag", + &test_segments[0], + "8466 3 52737 4096", + AS2_DATA, + -1, + 0, + { + COMMON_ATTRS, + BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL, + BGP_ATTR_AS_PATH, + 10, + }, + COMMON_ATTR_SIZE + 3, + }, + /* 4 */ + { + "as4_path, with as2 format data", + &test_segments[0], + "8466 3 52737 4096", + AS2_DATA, + -1, + 0, + { + COMMON_ATTRS, + BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL, + BGP_ATTR_AS4_PATH, + 10, + }, + COMMON_ATTR_SIZE + 3, + }, + /* 5 */ + { + "as4, with incorrect attr length", + &test_segments[0], + "8466 3 52737 4096", + AS4_DATA, + -1, + PEER_CAP_AS4_RCV, + { + COMMON_ATTRS, + BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL, + BGP_ATTR_AS4_PATH, + 10, + }, + COMMON_ATTR_SIZE + 3, + }, + /* 6 */ + { + "basic 4-byte as-path", + &test_segments[0], + "8466 3 52737 4096", + AS4_DATA, + 0, + PEER_CAP_AS4_RCV | PEER_CAP_AS4_ADV, + { + COMMON_ATTRS, + BGP_ATTR_FLAG_TRANS, + BGP_ATTR_AS_PATH, + 18, + }, + COMMON_ATTR_SIZE + 3, + }, + /* 7 */ + { + "4b AS_PATH: too short", + &test_segments[0], + "8466 3 52737 4096", + AS4_DATA, + -1, + PEER_CAP_AS4_RCV | PEER_CAP_AS4_ADV, + { + COMMON_ATTRS, + BGP_ATTR_FLAG_TRANS, + BGP_ATTR_AS_PATH, + 16, + }, + COMMON_ATTR_SIZE + 3, + }, + /* 8 */ + { + "4b AS_PATH: too long", + &test_segments[0], + "8466 3 52737 4096", + AS4_DATA, + -1, + PEER_CAP_AS4_RCV | PEER_CAP_AS4_ADV, + { + COMMON_ATTRS, + BGP_ATTR_FLAG_TRANS, + BGP_ATTR_AS_PATH, + 20, + }, + COMMON_ATTR_SIZE + 3, + }, + /* 9 */ + { + "4b AS_PATH: too long2", + &test_segments[0], + "8466 3 52737 4096", + AS4_DATA, + -1, + PEER_CAP_AS4_RCV | PEER_CAP_AS4_ADV, + { + COMMON_ATTRS, + BGP_ATTR_FLAG_TRANS, + BGP_ATTR_AS_PATH, + 22, + }, + COMMON_ATTR_SIZE + 3, + }, + /* 10 */ + { + "4b AS_PATH: bad flags", + &test_segments[0], + "8466 3 52737 4096", + AS4_DATA, + -1, + PEER_CAP_AS4_RCV | PEER_CAP_AS4_ADV, + { + COMMON_ATTRS, + BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL, + BGP_ATTR_AS_PATH, + 18, + }, + COMMON_ATTR_SIZE + 3, + }, + /* 11 */ + { + "4b AS4_PATH w/o AS_PATH", + &test_segments[6], + NULL, + AS4_DATA, + -2, + PEER_CAP_AS4_ADV, + { + COMMON_ATTRS, + BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL, + BGP_ATTR_AS4_PATH, + 14, + }, + COMMON_ATTR_SIZE + 3, + }, + /* 12 */ + { + "4b AS4_PATH: confed", + &test_segments[6], + "8466 3 52737 4096 (123 456 789)", + AS4_DATA, + 0, + PEER_CAP_AS4_ADV, + { + COMMON_ATTRS, + BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL, + BGP_ATTR_AS4_PATH, + 14, + }, + COMMON_ATTR_SIZE + 3, + &test_segments[0], + }, + /* 13 */ + { + "4b AS4_PATH: BGP_AS_ZERO", + &test_segments[28], + "8466 3 52737 0 4096", + AS4_DATA, + -2, + PEER_CAP_AS4_RCV | PEER_CAP_AS4_ADV, + { + COMMON_ATTRS, + BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL, + BGP_ATTR_AS4_PATH, + 22, + }, + COMMON_ATTR_SIZE + 3, + }, + {NULL, NULL, NULL, 0, 0, 0, {0}, 0}, +}; + +/* prepending tests */ +static struct tests { + const struct test_segment *test1; + const struct test_segment *test2; + struct test_spec sp; +} prepend_tests[] = { + /* 0 */ + { + &test_segments[0], + &test_segments[1], + {"8466 3 52737 4096 8722 4", "8466 3 52737 4096 8722 4", 6, 0, + NOT_ALL_PRIVATE, 4096, 1, 8466}, + }, + /* 1 */ + {&test_segments[1], + &test_segments[3], + {"8722 4 8482 51457 {5204}", "8722 4 8482 51457 {5204}", 5, 0, + NOT_ALL_PRIVATE, 5204, 1, 8722}}, + /* 2 */ + { + &test_segments[3], + &test_segments[4], + {"8482 51457 {5204} 8467 59649 {4196,48658} {17322,30745}", + "8482 51457 {5204} 8467 59649 {4196,48658} {17322,30745}", 7, + 0, NOT_ALL_PRIVATE, 5204, 1, 8482}, + }, + /* 3 */ + {&test_segments[4], + &test_segments[5], + {"8467 59649 {4196,48658} {17322,30745} 6435 59408 21665 {2457,4369,61697} 1842 41590 51793", + "8467 59649 {4196,48658} {17322,30745} 6435 59408 21665 {2457,4369,61697} 1842 41590 51793", + 11, 0, NOT_ALL_PRIVATE, 61697, 1, 8467}}, + /* 4 */ + { + &test_segments[5], + &test_segments[6], + {"6435 59408 21665 {2457,4369,61697} 1842 41590 51793", + "6435 59408 21665 {2457,4369,61697} 1842 41590 51793", 7, 0, + NOT_ALL_PRIVATE, 1842, 1, 6435}, + }, + /* 5 */ + {&test_segments[6], + &test_segments[7], + {"(123 456 789) (123 456 789) (111 222)", "", 0, 8, NOT_ALL_PRIVATE, + 111, 1, 0}}, + {&test_segments[7], + &test_segments[8], + {"(123 456 789) (111 222) [123,456,789]", "", 0, 6, NOT_ALL_PRIVATE, + 111, 1, 0}}, + { + &test_segments[8], + &test_segments[9], + {"[123,456,789] (123 456 789) [111,222] 8722 {4196,48658}", + "8722 {4196,48658}", 2, 5, NOT_ALL_PRIVATE, 456, 1, NULL_ASN}, + }, + { + &test_segments[9], + &test_segments[8], + {"(123 456 789) [111,222] 8722 {4196,48658} [123,456,789]", + "8722 {4196,48658}", 2, 5, NOT_ALL_PRIVATE, 48658, 1, + NULL_ASN}, + }, + { + &test_segments[14], + &test_segments[11], + {"8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 2 52737 4096 8722 4 8722", + + "8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 3 52737 4096 34285 8466 2 52737 4096 8722 4 8722", + 257, 0, NOT_ALL_PRIVATE, 4096, 1000, 8466}, + }, + {NULL, + NULL, + { + NULL, 0, 0, 0, 0, 0, 0, + }}, +}; + +struct tests reconcile_tests[] = { + { + &test_segments[18], + &test_segments[19], + {"6435 59408 21665 {2457,4369,61697} 1842 41591 51793", + "6435 59408 21665 {2457,4369,61697} 1842 41591 51793", 7, 0, + NOT_ALL_PRIVATE, 51793, 1, 6435}, + }, + { + &test_segments[19], + &test_segments[18], + /* AS_PATH (19) has more hops than NEW_AS_PATH, + * so just AS_PATH should be used (though, this practice + * is bad imho). + */ + {"{2457,4369,61697} 1842 41591 51793 6435 59408 21665 {23456} 23456 23456 23456", + "{2457,4369,61697} 1842 41591 51793 6435 59408 21665 {23456} 23456 23456 23456", + 11, 0, NOT_ALL_PRIVATE, 51793, 1, 6435}, + }, + { + &test_segments[20], + &test_segments[19], + {"(123 456 789) [124,456,788] 6435 59408 21665 {2457,4369,61697} 1842 41591 51793", + "6435 59408 21665 {2457,4369,61697} 1842 41591 51793", 7, 4, + NOT_ALL_PRIVATE, 51793, 1, 6435}, + }, + { + &test_segments[21], + &test_segments[22], + {"1842 41591 51793 6435 59408 21665", + "1842 41591 51793 6435 59408 21665", 6, 0, NOT_ALL_PRIVATE, + 51793, 1, 1842}, + }, + { + &test_segments[23], + &test_segments[22], + {"23456 23456 23456 6435 59408 1842 41591 51793 6435 59408 21665", + "23456 23456 23456 6435 59408 1842 41591 51793 6435 59408 21665", + 11, 0, NOT_ALL_PRIVATE, 51793, 1, 1842}, + }, + {NULL, + NULL, + { + NULL, 0, 0, 0, 0, 0, 0, + }}, +}; + +struct tests aggregate_tests[] = { + { + &test_segments[0], + &test_segments[2], + {"8466 3 52737 4096 {4,8722}", "8466 3 52737 4096 {4,8722}", 5, + 0, NOT_ALL_PRIVATE, 4, 1, 8466}, + }, + { + &test_segments[2], + &test_segments[0], + {"8466 3 52737 4096 {4,8722}", "8466 3 52737 4096 {4,8722}", 5, + 0, NOT_ALL_PRIVATE, 8722, 1, 8466}, + }, + { + &test_segments[2], + &test_segments[10], + {"8466 {2,3,4,4096,8722,52737}", "8466 {2,3,4,4096,8722,52737}", + 2, 0, NOT_ALL_PRIVATE, 8722, 5, 8466}, + }, + { + &test_segments[10], + &test_segments[2], + {"8466 {2,3,4,4096,8722,52737}", "8466 {2,3,4,4096,8722,52737}", + 2, 0, NOT_ALL_PRIVATE, 2, 20000, 8466}, + }, + + { + &test_segments[5], + &test_segments[18], + {"6435 59408 21665 {1842,2457,4369,23456,41590,51793,61697}", + "6435 59408 21665 {1842,2457,4369,23456,41590,51793,61697}", 4, + 0, NOT_ALL_PRIVATE, 41590, 1, 6435}, + }, + + {NULL, NULL, {NULL, 0, 0}}, +}; + +struct compare_tests { + int test_index1; + int test_index2; +#define CMP_RES_YES 1 +#define CMP_RES_NO 0 + char shouldbe_cmp; + char shouldbe_confed; +} left_compare[] = { + {0, 1, CMP_RES_NO, CMP_RES_NO}, {0, 2, CMP_RES_YES, CMP_RES_NO}, + {0, 11, CMP_RES_YES, CMP_RES_NO}, {0, 15, CMP_RES_YES, CMP_RES_NO}, + {0, 16, CMP_RES_NO, CMP_RES_NO}, {1, 11, CMP_RES_NO, CMP_RES_NO}, + {6, 7, CMP_RES_NO, CMP_RES_YES}, {6, 8, CMP_RES_NO, CMP_RES_NO}, + {7, 8, CMP_RES_NO, CMP_RES_NO}, {1, 9, CMP_RES_YES, CMP_RES_NO}, + {0, 9, CMP_RES_NO, CMP_RES_NO}, {3, 9, CMP_RES_NO, CMP_RES_NO}, + {0, 6, CMP_RES_NO, CMP_RES_NO}, {1, 6, CMP_RES_NO, CMP_RES_NO}, + {0, 8, CMP_RES_NO, CMP_RES_NO}, {1, 8, CMP_RES_NO, CMP_RES_NO}, + {11, 6, CMP_RES_NO, CMP_RES_NO}, {11, 7, CMP_RES_NO, CMP_RES_NO}, + {11, 8, CMP_RES_NO, CMP_RES_NO}, {9, 6, CMP_RES_NO, CMP_RES_YES}, + {9, 7, CMP_RES_NO, CMP_RES_YES}, {9, 8, CMP_RES_NO, CMP_RES_NO}, +}; + +/* make an aspath from a data stream */ +static struct aspath *make_aspath(const uint8_t *data, size_t len, int use32bit) +{ + struct stream *s = NULL; + struct aspath *as; + + if (len) { + s = stream_new(len); + stream_put(s, data, len); + } + as = aspath_parse(s, len, use32bit); + + if (s) + stream_free(s); + + return as; +} + +static void printbytes(const uint8_t *bytes, int len) +{ + int i = 0; + while (i < len) { + if (i % 2) + printf("%02hhx%s", bytes[i], " "); + else + printf("0x%02hhx", bytes[i]); + i++; + } + printf("\n"); +} + +/* validate the given aspath */ +static int validate(struct aspath *as, const struct test_spec *sp) +{ + size_t bytes, bytes4; + int fails = 0; + const uint8_t *out; + static struct stream *s; + struct aspath *asinout, *asconfeddel, *asstr, *as4; + + if (as == NULL && sp->shouldbe == NULL) { + printf("Correctly failed to parse\n"); + return fails; + } + + out = aspath_snmp_pathseg(as, &bytes); + asinout = make_aspath(out, bytes, 0); + + /* Excercise AS4 parsing a bit, with a dogfood test */ + if (!s) + s = stream_new(BGP_MAX_PACKET_SIZE); + bytes4 = aspath_put(s, as, 1); + as4 = make_aspath(STREAM_DATA(s), bytes4, 1); + + asstr = aspath_str2aspath(sp->shouldbe); + + asconfeddel = aspath_delete_confed_seq(aspath_dup(asinout)); + + printf("got: %s\n", aspath_print(as)); + + /* the parsed path should match the specified 'shouldbe' string. + * We should pass the "eat our own dog food" test, be able to output + * this path and then input it again. Ie the path resulting from: + * + * aspath_parse(aspath_put(as)) + * + * should: + * + * - also match the specified 'shouldbe' value + * - hash to same value as original path + * - have same hops and confed counts as original, and as the + * the specified counts + * + * aspath_str2aspath() and shouldbe should match + * + * We do the same for: + * + * aspath_parse(aspath_put(as,USE32BIT)) + * + * Confederation related tests: + * - aspath_delete_confed_seq(aspath) should match shouldbe_confed + * - aspath_delete_confed_seq should be idempotent. + */ + if (strcmp(aspath_print(as), sp->shouldbe) + /* hash validation */ + || (aspath_key_make(as) != aspath_key_make(asinout)) + /* by string */ + || strcmp(aspath_print(asinout), sp->shouldbe) + /* By 4-byte parsing */ + || strcmp(aspath_print(as4), sp->shouldbe) + /* by various path counts */ + || (aspath_count_hops(as) != sp->hops) + || (aspath_count_confeds(as) != sp->confeds) + || (aspath_count_hops(asinout) != sp->hops) + || (aspath_count_confeds(asinout) != sp->confeds)) { + failed++; + fails++; + printf("shouldbe:\n%s\n", sp->shouldbe); + printf("as4:\n%s\n", aspath_print(as4)); + printf("hash keys: in: %d out->in: %d\n", aspath_key_make(as), + aspath_key_make(asinout)); + printf("hops: %d, counted %d %d\n", sp->hops, + aspath_count_hops(as), aspath_count_hops(asinout)); + printf("confeds: %d, counted %d %d\n", sp->confeds, + aspath_count_confeds(as), aspath_count_confeds(asinout)); + printf("out->in:\n%s\nbytes: ", aspath_print(asinout)); + printbytes(out, bytes); + } + /* basic confed related tests */ + if ((aspath_print(asconfeddel) == NULL + && sp->shouldbe_delete_confed != NULL) + || (aspath_print(asconfeddel) != NULL + && sp->shouldbe_delete_confed == NULL) + || strcmp(aspath_print(asconfeddel), sp->shouldbe_delete_confed) + /* delete_confed_seq should be idempotent */ + || (aspath_key_make(asconfeddel) + != aspath_key_make(aspath_delete_confed_seq(asconfeddel)))) { + failed++; + fails++; + printf("as-path minus confeds is: %s\n", + aspath_print(asconfeddel)); + printf("as-path minus confeds should be: %s\n", + sp->shouldbe_delete_confed); + } + /* aspath_str2aspath test */ + if ((aspath_print(asstr) == NULL && sp->shouldbe != NULL) + || (aspath_print(asstr) != NULL && sp->shouldbe == NULL) + || strcmp(aspath_print(asstr), sp->shouldbe)) { + failed++; + fails++; + printf("asstr: %s\n", aspath_print(asstr)); + } + + /* loop, private and first as checks */ + if ((sp->does_loop && aspath_loop_check(as, sp->does_loop) == 0) + || (sp->doesnt_loop && aspath_loop_check(as, sp->doesnt_loop) != 0) + || (aspath_private_as_check(as) != sp->private_as) + || (aspath_firstas_check(as, sp->first) && sp->first == 0)) { + failed++; + fails++; + printf("firstas: %d, got %d\n", sp->first, + aspath_firstas_check(as, sp->first)); + printf("loop does: %d %d, doesn't: %d %d\n", sp->does_loop, + aspath_loop_check(as, sp->does_loop), sp->doesnt_loop, + aspath_loop_check(as, sp->doesnt_loop)); + printf("private check: %d %d\n", sp->private_as, + aspath_private_as_check(as)); + } + aspath_unintern(&asinout); + aspath_unintern(&as4); + + aspath_free(asconfeddel); + aspath_free(asstr); + stream_reset(s); + + return fails; +} + +static void empty_get_test(void) +{ + struct aspath *as = aspath_empty_get(); + struct test_spec sp = {"", "", 0, 0, 0, 0, 0, 0}; + + printf("empty_get_test, as: %s\n", aspath_print(as)); + if (!validate(as, &sp)) + printf("%s\n", OK); + else + printf("%s!\n", FAILED); + + printf("\n"); + + aspath_free(as); +} + +/* basic parsing test */ +static void parse_test(struct test_segment *t) +{ + struct aspath *asp; + + printf("%s: %s\n", t->name, t->desc); + + asp = make_aspath(t->asdata, t->len, 0); + + printf("aspath: %s\nvalidating...:\n", aspath_print(asp)); + + if (!validate(asp, &t->sp)) + printf(OK "\n"); + else + printf(FAILED "\n"); + + printf("\n"); + + aspath_unintern(&asp); +} + +/* prepend testing */ +static void prepend_test(struct tests *t) +{ + struct aspath *asp1, *asp2, *ascratch; + + printf("prepend %s: %s\n", t->test1->name, t->test1->desc); + printf("to %s: %s\n", t->test2->name, t->test2->desc); + + asp1 = make_aspath(t->test1->asdata, t->test1->len, 0); + asp2 = make_aspath(t->test2->asdata, t->test2->len, 0); + + ascratch = aspath_dup(asp2); + aspath_unintern(&asp2); + + asp2 = aspath_prepend(asp1, ascratch); + + printf("aspath: %s\n", aspath_print(asp2)); + + if (!validate(asp2, &t->sp)) + printf("%s\n", OK); + else + printf("%s!\n", FAILED); + + printf("\n"); + aspath_unintern(&asp1); + aspath_free(asp2); +} + +/* empty-prepend testing */ +static void empty_prepend_test(struct test_segment *t) +{ + struct aspath *asp1, *asp2, *ascratch; + + printf("empty prepend %s: %s\n", t->name, t->desc); + + asp1 = make_aspath(t->asdata, t->len, 0); + asp2 = aspath_empty(); + + ascratch = aspath_dup(asp2); + aspath_unintern(&asp2); + + asp2 = aspath_prepend(asp1, ascratch); + + printf("aspath: %s\n", aspath_print(asp2)); + + if (!validate(asp2, &t->sp)) + printf(OK "\n"); + else + printf(FAILED "!\n"); + + printf("\n"); + aspath_unintern(&asp1); + aspath_free(asp2); +} + +/* as2+as4 reconciliation testing */ +static void as4_reconcile_test(struct tests *t) +{ + struct aspath *asp1, *asp2, *ascratch; + + printf("reconciling %s:\n %s\n", t->test1->name, t->test1->desc); + printf("with %s:\n %s\n", t->test2->name, t->test2->desc); + + asp1 = make_aspath(t->test1->asdata, t->test1->len, 0); + asp2 = make_aspath(t->test2->asdata, t->test2->len, 0); + + ascratch = aspath_reconcile_as4(asp1, asp2); + + if (!validate(ascratch, &t->sp)) + printf(OK "\n"); + else + printf(FAILED "!\n"); + + printf("\n"); + aspath_unintern(&asp1); + aspath_unintern(&asp2); + aspath_free(ascratch); +} + + +/* aggregation testing */ +static void aggregate_test(struct tests *t) +{ + struct aspath *asp1, *asp2, *ascratch; + + printf("aggregate %s: %s\n", t->test1->name, t->test1->desc); + printf("with %s: %s\n", t->test2->name, t->test2->desc); + + asp1 = make_aspath(t->test1->asdata, t->test1->len, 0); + asp2 = make_aspath(t->test2->asdata, t->test2->len, 0); + + ascratch = aspath_aggregate(asp1, asp2); + + if (!validate(ascratch, &t->sp)) + printf(OK "\n"); + else + printf(FAILED "!\n"); + + printf("\n"); + aspath_unintern(&asp1); + aspath_unintern(&asp2); + aspath_free(ascratch); + /* aspath_unintern (ascratch);*/ +} + +/* cmp_left tests */ +static void cmp_test(void) +{ + unsigned int i; +#define CMP_TESTS_MAX (sizeof(left_compare) / sizeof(struct compare_tests)) + + for (i = 0; i < CMP_TESTS_MAX; i++) { + struct test_segment *t1 = + &test_segments[left_compare[i].test_index1]; + struct test_segment *t2 = + &test_segments[left_compare[i].test_index2]; + struct aspath *asp1, *asp2; + + printf("left cmp %s: %s\n", t1->name, t1->desc); + printf("and %s: %s\n", t2->name, t2->desc); + + asp1 = make_aspath(t1->asdata, t1->len, 0); + asp2 = make_aspath(t2->asdata, t2->len, 0); + + if (aspath_cmp_left(asp1, asp2) != left_compare[i].shouldbe_cmp + || aspath_cmp_left(asp2, asp1) + != left_compare[i].shouldbe_cmp + || aspath_cmp_left_confed(asp1, asp2) + != left_compare[i].shouldbe_confed + || aspath_cmp_left_confed(asp2, asp1) + != left_compare[i].shouldbe_confed) { + failed++; + printf(FAILED "\n"); + printf("result should be: cmp: %d, confed: %d\n", + left_compare[i].shouldbe_cmp, + left_compare[i].shouldbe_confed); + printf("got: cmp %d, cmp_confed: %d\n", + aspath_cmp_left(asp1, asp2), + aspath_cmp_left_confed(asp1, asp2)); + printf("path1: %s\npath2: %s\n", aspath_print(asp1), + aspath_print(asp2)); + } else + printf(OK "\n"); + + printf("\n"); + aspath_unintern(&asp1); + aspath_unintern(&asp2); + } +} + +static int handle_attr_test(struct aspath_tests *t) +{ + struct bgp bgp = {0}; + struct peer peer = {0}; + struct attr attr = {0}; + int ret; + int initfail = failed; + struct aspath *asp; + size_t datalen; + + asp = make_aspath(t->segment->asdata, t->segment->len, 0); + + peer.curr = stream_new(BGP_MAX_PACKET_SIZE); + peer.obuf = stream_fifo_new(); + peer.bgp = &bgp; + peer.host = (char *)"none"; + peer.fd = -1; + peer.cap = t->cap; + peer.max_packet_size = BGP_STANDARD_MESSAGE_MAX_PACKET_SIZE; + + stream_write(peer.curr, t->attrheader, t->len); + datalen = aspath_put(peer.curr, asp, t->as4 == AS4_DATA); + if (t->old_segment) { + char dummyaspath[] = {BGP_ATTR_FLAG_TRANS, BGP_ATTR_AS_PATH, + t->old_segment->len}; + stream_write(peer.curr, dummyaspath, sizeof(dummyaspath)); + stream_write(peer.curr, t->old_segment->asdata, + t->old_segment->len); + datalen += sizeof(dummyaspath) + t->old_segment->len; + } + + ret = bgp_attr_parse(&peer, &attr, t->len + datalen, NULL, NULL); + + if (ret != t->result) { + printf("bgp_attr_parse returned %d, expected %d\n", ret, + t->result); + printf("datalen %zd\n", datalen); + failed++; + } + if (ret != 0) + goto out; + + if (t->shouldbe && attr.aspath == NULL) { + printf("aspath is NULL, but should be: %s\n", t->shouldbe); + failed++; + } + if (t->shouldbe && attr.aspath + && strcmp(attr.aspath->str, t->shouldbe)) { + printf("attr str and 'shouldbe' mismatched!\n" + "attr str: %s\n" + "shouldbe: %s\n", + attr.aspath->str, t->shouldbe); + failed++; + } + if (!t->shouldbe && attr.aspath) { + printf("aspath should be NULL, but is: %s\n", attr.aspath->str); + failed++; + } + +out: + aspath_unintern(&attr.aspath); + aspath_unintern(&asp); + return failed - initfail; +} + +static void attr_test(struct aspath_tests *t) +{ + printf("%s\n", t->desc); + printf("%s\n\n", handle_attr_test(t) ? FAILED : OK); +} + +int main(void) +{ + int i = 0; + qobj_init(); + bgp_master_init(thread_master_create(NULL), BGP_SOCKET_SNDBUF_SIZE, + list_new()); + master = bm->master; + bgp_option_set(BGP_OPT_NO_LISTEN); + bgp_attr_init(); + + while (test_segments[i].name) { + printf("test %u\n", i); + parse_test(&test_segments[i]); + empty_prepend_test(&test_segments[i++]); + } + + i = 0; + while (prepend_tests[i].test1) { + printf("prepend test %u\n", i); + prepend_test(&prepend_tests[i++]); + } + + i = 0; + while (aggregate_tests[i].test1) { + printf("aggregate test %u\n", i); + aggregate_test(&aggregate_tests[i++]); + } + + i = 0; + + while (reconcile_tests[i].test1) { + printf("reconcile test %u\n", i); + as4_reconcile_test(&reconcile_tests[i++]); + } + + i = 0; + + cmp_test(); + + i = 0; + + empty_get_test(); + + i = 0; + + frr_pthread_init(); + bgp_pthreads_init(); + bgp_pth_ka->running = true; + + while (aspath_tests[i].desc) { + printf("aspath_attr test %d\n", i); + attr_test(&aspath_tests[i++]); + } + + printf("failures: %d\n", failed); + printf("aspath count: %ld\n", aspath_count()); + + return (failed + aspath_count()); +} |