Line data Source code
1 : #include <zebra.h>
2 :
3 : #include "vty.h"
4 : #include "stream.h"
5 : #include "privs.h"
6 :
7 : #include "bgpd/bgpd.h"
8 : #include "bgpd/bgp_aspath.h"
9 : #include "bgpd/bgp_attr.h"
10 :
11 : #define VT100_RESET "\x1b[0m"
12 : #define VT100_RED "\x1b[31m"
13 : #define VT100_GREEN "\x1b[32m"
14 : #define VT100_YELLOW "\x1b[33m"
15 : #define OK VT100_GREEN "OK" VT100_RESET
16 : #define FAILED VT100_RED "failed" VT100_RESET
17 :
18 : /* need these to link in libbgp */
19 : struct zebra_privs_t *bgpd_privs = NULL;
20 : struct thread_master *master = NULL;
21 :
22 : static int failed = 0;
23 :
24 : /* specification for a test - what the results should be */
25 : struct test_spec
26 : {
27 : const char *shouldbe; /* the string the path should parse to */
28 : const char *shouldbe_delete_confed; /* ditto, but once confeds are deleted */
29 : const unsigned int hops; /* aspath_count_hops result */
30 : const unsigned int confeds; /* aspath_count_confeds */
31 : const int private_as; /* whether the private_as check should pass or fail */
32 : #define NOT_ALL_PRIVATE 0
33 : #define ALL_PRIVATE 1
34 : const as_t does_loop; /* an ASN which should trigger loop-check */
35 : const as_t doesnt_loop; /* one which should not */
36 : const as_t first; /* the first ASN, if there is one */
37 : #define NULL_ASN 0
38 : };
39 :
40 :
41 : /* test segments to parse and validate, and use for other tests */
42 : static struct test_segment {
43 : const char *name;
44 : const char *desc;
45 : const u_char asdata[1024];
46 : int len;
47 : struct test_spec sp;
48 : } test_segments [] =
49 : {
50 : { /* 0 */
51 : "seq1",
52 : "seq(8466,3,52737,4096)",
53 : { 0x2,0x4, 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00 },
54 : 10,
55 : { "8466 3 52737 4096",
56 : "8466 3 52737 4096",
57 : 4, 0, NOT_ALL_PRIVATE, 4096, 4, 8466 },
58 : },
59 : { /* 1 */
60 : "seq2",
61 : "seq(8722) seq(4)",
62 : { 0x2,0x1, 0x22,0x12,
63 : 0x2,0x1, 0x00,0x04 },
64 : 8,
65 : { "8722 4",
66 : "8722 4",
67 : 2, 0, NOT_ALL_PRIVATE, 4, 5, 8722, },
68 : },
69 : { /* 2 */
70 : "seq3",
71 : "seq(8466,3,52737,4096,8722,4)",
72 : { 0x2,0x6, 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00,
73 : 0x22,0x12, 0x00,0x04},
74 : 14,
75 : { "8466 3 52737 4096 8722 4",
76 : "8466 3 52737 4096 8722 4",
77 : 6, 0, NOT_ALL_PRIVATE, 3, 5, 8466 },
78 : },
79 : { /* 3 */
80 : "seqset",
81 : "seq(8482,51457) set(5204)",
82 : { 0x2,0x2, 0x21,0x22, 0xc9,0x01,
83 : 0x1,0x1, 0x14,0x54 },
84 : 10,
85 : { "8482 51457 {5204}",
86 : "8482 51457 {5204}",
87 : 3, 0, NOT_ALL_PRIVATE, 5204, 51456, 8482},
88 : },
89 : { /* 4 */
90 : "seqset2",
91 : "seq(8467, 59649) set(4196,48658) set(17322,30745)",
92 : { 0x2,0x2, 0x21,0x13, 0xe9,0x01,
93 : 0x1,0x2, 0x10,0x64, 0xbe,0x12,
94 : 0x1,0x2, 0x43,0xaa, 0x78,0x19 },
95 : 18,
96 : { "8467 59649 {4196,48658} {17322,30745}",
97 : "8467 59649 {4196,48658} {17322,30745}",
98 : 4, 0, NOT_ALL_PRIVATE, 48658, 1, 8467},
99 : },
100 : { /* 5 */
101 : "multi",
102 : "seq(6435,59408,21665) set(2457,61697,4369), seq(1842,41590,51793)",
103 : { 0x2,0x3, 0x19,0x23, 0xe8,0x10, 0x54,0xa1,
104 : 0x1,0x3, 0x09,0x99, 0xf1,0x01, 0x11,0x11,
105 : 0x2,0x3, 0x07,0x32, 0xa2,0x76, 0xca,0x51 },
106 : 24,
107 : { "6435 59408 21665 {2457,4369,61697} 1842 41590 51793",
108 : "6435 59408 21665 {2457,4369,61697} 1842 41590 51793",
109 : 7, 0, NOT_ALL_PRIVATE, 51793, 1, 6435 },
110 : },
111 : { /* 6 */
112 : "confed",
113 : "confseq(123,456,789)",
114 : { 0x3,0x3, 0x00,0x7b, 0x01,0xc8, 0x03,0x15 },
115 : 8,
116 : { "(123 456 789)",
117 : "",
118 : 0, 3, NOT_ALL_PRIVATE, 789, 1, NULL_ASN },
119 : },
120 : { /* 7 */
121 : "confed2",
122 : "confseq(123,456,789) confseq(111,222)",
123 : { 0x3,0x3, 0x00,0x7b, 0x01,0xc8, 0x03,0x15,
124 : 0x3,0x2, 0x00,0x6f, 0x00,0xde },
125 : 14,
126 : { "(123 456 789) (111 222)",
127 : "",
128 : 0, 5, NOT_ALL_PRIVATE, 111, 1, NULL_ASN },
129 : },
130 : { /* 8 */
131 : "confset",
132 : "confset(456,123,789)",
133 : { 0x4,0x3, 0x01,0xc8, 0x00,0x7b, 0x03,0x15 },
134 : 8,
135 : { "[123,456,789]",
136 : "[123,456,789]",
137 : 0, 1, NOT_ALL_PRIVATE, 123, 1, NULL_ASN },
138 : },
139 : { /* 9 */
140 : "confmulti",
141 : "confseq(123,456,789) confset(222,111) seq(8722) set(4196,48658)",
142 : { 0x3,0x3, 0x00,0x7b, 0x01,0xc8, 0x03,0x15,
143 : 0x4,0x2, 0x00,0xde, 0x00,0x6f,
144 : 0x2,0x1, 0x22,0x12,
145 : 0x1,0x2, 0x10,0x64, 0xbe,0x12 },
146 : 24,
147 : { "(123 456 789) [111,222] 8722 {4196,48658}",
148 : "8722 {4196,48658}",
149 : 2, 4, NOT_ALL_PRIVATE, 123, 1, NULL_ASN },
150 : },
151 : { /* 10 */
152 : "seq4",
153 : "seq(8466,2,52737,4096,8722,4)",
154 : { 0x2,0x6, 0x21,0x12, 0x00,0x02, 0xce,0x01, 0x10,0x00,
155 : 0x22,0x12, 0x00,0x04},
156 : 14,
157 : { "8466 2 52737 4096 8722 4",
158 : "8466 2 52737 4096 8722 4",
159 : 6, 0, NOT_ALL_PRIVATE, 4096, 1, 8466 },
160 : },
161 : { /* 11 */
162 : "tripleseq1",
163 : "seq(8466,2,52737) seq(4096,8722,4) seq(8722)",
164 : { 0x2,0x3, 0x21,0x12, 0x00,0x02, 0xce,0x01,
165 : 0x2,0x3, 0x10,0x00, 0x22,0x12, 0x00,0x04,
166 : 0x2,0x1, 0x22,0x12},
167 : 20,
168 : { "8466 2 52737 4096 8722 4 8722",
169 : "8466 2 52737 4096 8722 4 8722",
170 : 7, 0, NOT_ALL_PRIVATE, 4096, 1, 8466 },
171 : },
172 : { /* 12 */
173 : "someprivate",
174 : "seq(8466,64512,52737,65535)",
175 : { 0x2,0x4, 0x21,0x12, 0xfc,0x00, 0xce,0x01, 0xff,0xff },
176 : 10,
177 : { "8466 64512 52737 65535",
178 : "8466 64512 52737 65535",
179 : 4, 0, NOT_ALL_PRIVATE, 65535, 4, 8466 },
180 : },
181 : { /* 13 */
182 : "allprivate",
183 : "seq(65534,64512,64513,65535)",
184 : { 0x2,0x4, 0xff,0xfe, 0xfc,0x00, 0xfc,0x01, 0xff,0xff },
185 : 10,
186 : { "65534 64512 64513 65535",
187 : "65534 64512 64513 65535",
188 : 4, 0, ALL_PRIVATE, 65534, 4, 65534 },
189 : },
190 : { /* 14 */
191 : "long",
192 : "seq(8466,3,52737,4096,34285,<repeated 49 more times>)",
193 : { 0x2,0xfa, 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
194 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
195 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
196 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
197 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
198 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
199 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
200 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
201 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
202 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
203 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
204 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
205 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
206 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
207 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
208 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
209 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
210 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
211 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
212 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
213 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
214 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
215 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
216 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
217 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
218 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
219 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
220 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
221 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
222 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
223 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
224 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
225 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
226 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
227 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
228 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
229 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
230 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
231 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
232 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
233 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
234 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
235 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
236 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
237 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
238 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
239 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
240 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
241 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed,
242 : 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x85,0xed, },
243 : 502,
244 : { "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
245 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
246 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
247 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
248 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
249 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
250 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
251 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
252 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
253 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
254 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
255 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
256 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
257 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
258 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
259 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
260 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
261 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
262 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
263 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
264 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
265 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
266 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
267 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
268 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285",
269 :
270 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
271 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
272 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
273 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
274 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
275 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
276 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
277 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
278 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
279 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
280 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
281 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
282 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
283 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
284 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
285 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
286 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
287 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
288 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
289 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
290 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
291 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
292 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
293 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
294 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285",
295 : 250, 0, NOT_ALL_PRIVATE, 4096, 4, 8466 },
296 : },
297 : { /* 15 */
298 : "seq1extra",
299 : "seq(8466,3,52737,4096,3456)",
300 : { 0x2,0x5, 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x0d,0x80 },
301 : 12,
302 : { "8466 3 52737 4096 3456",
303 : "8466 3 52737 4096 3456",
304 : 5, 0, NOT_ALL_PRIVATE, 4096, 4, 8466 },
305 : },
306 : { /* 16 */
307 : "empty",
308 : "<empty>",
309 : {},
310 : 0,
311 : { "", "", 0, 0, 0, 0, 0, 0 },
312 : },
313 : { /* 17 */
314 : "redundantset",
315 : "seq(8466,3,52737,4096,3456) set(7099,8153,8153,8153)",
316 : { 0x2,0x5, 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x0d,0x80,
317 : 0x1,0x4, 0x1b,0xbb, 0x1f,0xd9, 0x1f,0xd9, 0x1f,0xd9 },
318 : 22,
319 : {
320 : /* We shouldn't ever /generate/ such paths. However, we should
321 : * cope with them fine.
322 : */
323 : "8466 3 52737 4096 3456 {7099,8153}",
324 : "8466 3 52737 4096 3456 {7099,8153}",
325 : 6, 0, NOT_ALL_PRIVATE, 4096, 4, 8466 },
326 : },
327 : { /* 18 */
328 : "reconcile_lead_asp",
329 : "seq(6435,59408,21665) set(23456,23456,23456), seq(23456,23456,23456)",
330 : { 0x2,0x3, 0x19,0x23, 0xe8,0x10, 0x54,0xa1,
331 : 0x1,0x3, 0x5b,0xa0, 0x5b,0xa0, 0x5b,0xa0,
332 : 0x2,0x3, 0x5b,0xa0, 0x5b,0xa0, 0x5b,0xa0 },
333 : 24,
334 : { "6435 59408 21665 {23456} 23456 23456 23456",
335 : "6435 59408 21665 {23456} 23456 23456 23456",
336 : 7, 0, NOT_ALL_PRIVATE, 23456, 1, 6435 },
337 : },
338 : { /* 19 */
339 : "reconcile_new_asp",
340 : "set(2457,61697,4369), seq(1842,41591,51793)",
341 : {
342 : 0x1,0x3, 0x09,0x99, 0xf1,0x01, 0x11,0x11,
343 : 0x2,0x3, 0x07,0x32, 0xa2,0x77, 0xca,0x51 },
344 : 16,
345 : { "{2457,4369,61697} 1842 41591 51793",
346 : "{2457,4369,61697} 1842 41591 51793",
347 : 4, 0, NOT_ALL_PRIVATE, 51793, 1, 2457 },
348 : },
349 : { /* 20 */
350 : "reconcile_confed",
351 : "confseq(123,456,789) confset(456,124,788) seq(6435,59408,21665)"
352 : " set(23456,23456,23456), seq(23456,23456,23456)",
353 : { 0x3,0x3, 0x00,0x7b, 0x01,0xc8, 0x03,0x15,
354 : 0x4,0x3, 0x01,0xc8, 0x00,0x7c, 0x03,0x14,
355 : 0x2,0x3, 0x19,0x23, 0xe8,0x10, 0x54,0xa1,
356 : 0x1,0x3, 0x5b,0xa0, 0x5b,0xa0, 0x5b,0xa0,
357 : 0x2,0x3, 0x5b,0xa0, 0x5b,0xa0, 0x5b,0xa0 },
358 : 40,
359 : { "(123 456 789) [124,456,788] 6435 59408 21665"
360 : " {23456} 23456 23456 23456",
361 : "6435 59408 21665 {23456} 23456 23456 23456",
362 : 7, 4, NOT_ALL_PRIVATE, 23456, 1, 6435 },
363 : },
364 : { /* 21 */
365 : "reconcile_start_trans",
366 : "seq(23456,23456,23456) seq(6435,59408,21665)",
367 : { 0x2,0x3, 0x5b,0xa0, 0x5b,0xa0, 0x5b,0xa0,
368 : 0x2,0x3, 0x19,0x23, 0xe8,0x10, 0x54,0xa1, },
369 : 16,
370 : { "23456 23456 23456 6435 59408 21665",
371 : "23456 23456 23456 6435 59408 21665",
372 : 6, 0, NOT_ALL_PRIVATE, 21665, 1, 23456 },
373 : },
374 : { /* 22 */
375 : "reconcile_start_trans4",
376 : "seq(1842,41591,51793) seq(6435,59408,21665)",
377 : { 0x2,0x3, 0x07,0x32, 0xa2,0x77, 0xca,0x51,
378 : 0x2,0x3, 0x19,0x23, 0xe8,0x10, 0x54,0xa1, },
379 : 16,
380 : { "1842 41591 51793 6435 59408 21665",
381 : "1842 41591 51793 6435 59408 21665",
382 : 6, 0, NOT_ALL_PRIVATE, 41591, 1, 1842 },
383 : },
384 : { /* 23 */
385 : "reconcile_start_trans_error",
386 : "seq(23456,23456,23456) seq(6435,59408)",
387 : { 0x2,0x3, 0x5b,0xa0, 0x5b,0xa0, 0x5b,0xa0,
388 : 0x2,0x2, 0x19,0x23, 0xe8,0x10, },
389 : 14,
390 : { "23456 23456 23456 6435 59408",
391 : "23456 23456 23456 6435 59408",
392 : 5, 0, NOT_ALL_PRIVATE, 59408, 1, 23456 },
393 : },
394 : { /* 24 */
395 : "redundantset2",
396 : "seq(8466,3,52737,4096,3456) set(7099,8153,8153,8153,7099)",
397 : { 0x2,0x5, 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x0d,0x80,
398 : 0x1,0x5, 0x1b,0xbb, 0x1f,0xd9, 0x1f,0xd9, 0x1f,0xd9, 0x1b,0xbb,},
399 : 24,
400 : {
401 : /* We should weed out duplicate set members. */
402 : "8466 3 52737 4096 3456 {7099,8153}",
403 : "8466 3 52737 4096 3456 {7099,8153}",
404 : 6, 0, NOT_ALL_PRIVATE, 4096, 4, 8466 },
405 : },
406 : { /* 25 */
407 : "zero-size overflow",
408 : "#ASNs = 0, data = seq(8466 3 52737 4096 3456)",
409 : { 0x2,0x0, 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x0d,0x80 },
410 : 12,
411 : { NULL, NULL,
412 : 0, 0, 0, 0, 0, 0 },
413 : },
414 : { /* 26 */
415 : "zero-size overflow + valid segment",
416 : "seq(#AS=0:8466 3 52737),seq(4096 3456)",
417 : { 0x2,0x0, 0x21,0x12, 0x00,0x03, 0xce,0x01,
418 : 0x2,0x2, 0x10,0x00, 0x0d,0x80 },
419 : 14
420 : ,
421 : { NULL, NULL,
422 : 0, 0, 0, 0, 0, 0 },
423 : },
424 : { /* 27 */
425 : "invalid segment type",
426 : "type=8(4096 3456)",
427 : { 0x8,0x2, 0x10,0x00, 0x0d,0x80 },
428 : 14
429 : ,
430 : { NULL, NULL,
431 : 0, 0, 0, 0, 0, 0 },
432 : }, { NULL, NULL, {0}, 0, { NULL, 0, 0 } }
433 : };
434 :
435 : /* */
436 : static struct aspath_tests {
437 : const char *desc;
438 : const struct test_segment *segment;
439 : const char *shouldbe; /* String it should evaluate to */
440 : const enum as4 { AS4_DATA, AS2_DATA }
441 : as4; /* whether data should be as4 or not (ie as2) */
442 : const int result; /* expected result for bgp_attr_parse */
443 : const int cap; /* capabilities to set for peer */
444 : const char attrheader [1024];
445 : size_t len;
446 : const struct test_segment *old_segment;
447 : } aspath_tests [] =
448 : {
449 : /* 0 */
450 : {
451 : "basic test",
452 : &test_segments[0],
453 : "8466 3 52737 4096",
454 : AS2_DATA, 0,
455 : 0,
456 : { BGP_ATTR_FLAG_TRANS,
457 : BGP_ATTR_AS_PATH,
458 : 10,
459 : },
460 : 3,
461 : },
462 : /* 1 */
463 : {
464 : "length too short",
465 : &test_segments[0],
466 : "8466 3 52737 4096",
467 : AS2_DATA, -1,
468 : 0,
469 : { BGP_ATTR_FLAG_TRANS,
470 : BGP_ATTR_AS_PATH,
471 : 8,
472 : },
473 : 3,
474 : },
475 : /* 2 */
476 : {
477 : "length too long",
478 : &test_segments[0],
479 : "8466 3 52737 4096",
480 : AS2_DATA, -1,
481 : 0,
482 : { BGP_ATTR_FLAG_TRANS,
483 : BGP_ATTR_AS_PATH,
484 : 12,
485 : },
486 : 3,
487 : },
488 : /* 3 */
489 : {
490 : "incorrect flag",
491 : &test_segments[0],
492 : "8466 3 52737 4096",
493 : AS2_DATA, -1,
494 : 0,
495 : { BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_OPTIONAL,
496 : BGP_ATTR_AS_PATH,
497 : 10,
498 : },
499 : 3,
500 : },
501 : /* 4 */
502 : {
503 : "as4_path, with as2 format data",
504 : &test_segments[0],
505 : "8466 3 52737 4096",
506 : AS2_DATA, -1,
507 : 0,
508 : { BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_OPTIONAL,
509 : BGP_ATTR_AS4_PATH,
510 : 10,
511 : },
512 : 3,
513 : },
514 : /* 5 */
515 : {
516 : "as4, with incorrect attr length",
517 : &test_segments[0],
518 : "8466 3 52737 4096",
519 : AS4_DATA, -1,
520 : PEER_CAP_AS4_RCV,
521 : { BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_OPTIONAL,
522 : BGP_ATTR_AS4_PATH,
523 : 10,
524 : },
525 : 3,
526 : },
527 : /* 6 */
528 : {
529 : "basic 4-byte as-path",
530 : &test_segments[0],
531 : "8466 3 52737 4096",
532 : AS4_DATA, 0,
533 : PEER_CAP_AS4_RCV|PEER_CAP_AS4_ADV,
534 : { BGP_ATTR_FLAG_TRANS,
535 : BGP_ATTR_AS_PATH,
536 : 18,
537 : },
538 : 3,
539 : },
540 : /* 7 */
541 : {
542 : "4b AS_PATH: too short",
543 : &test_segments[0],
544 : "8466 3 52737 4096",
545 : AS4_DATA, -1,
546 : PEER_CAP_AS4_RCV|PEER_CAP_AS4_ADV,
547 : { BGP_ATTR_FLAG_TRANS,
548 : BGP_ATTR_AS_PATH,
549 : 16,
550 : },
551 : 3,
552 : },
553 : /* 8 */
554 : {
555 : "4b AS_PATH: too long",
556 : &test_segments[0],
557 : "8466 3 52737 4096",
558 : AS4_DATA, -1,
559 : PEER_CAP_AS4_RCV|PEER_CAP_AS4_ADV,
560 : { BGP_ATTR_FLAG_TRANS,
561 : BGP_ATTR_AS_PATH,
562 : 20,
563 : },
564 : 3,
565 : },
566 : /* 9 */
567 : {
568 : "4b AS_PATH: too long2",
569 : &test_segments[0],
570 : "8466 3 52737 4096",
571 : AS4_DATA, -1,
572 : PEER_CAP_AS4_RCV|PEER_CAP_AS4_ADV,
573 : { BGP_ATTR_FLAG_TRANS,
574 : BGP_ATTR_AS_PATH,
575 : 22,
576 : },
577 : 3,
578 : },
579 : /* 10 */
580 : {
581 : "4b AS_PATH: bad flags",
582 : &test_segments[0],
583 : "8466 3 52737 4096",
584 : AS4_DATA, -1,
585 : PEER_CAP_AS4_RCV|PEER_CAP_AS4_ADV,
586 : { BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_OPTIONAL,
587 : BGP_ATTR_AS_PATH,
588 : 18,
589 : },
590 : 3,
591 : },
592 : /* 11 */
593 : {
594 : "4b AS4_PATH w/o AS_PATH",
595 : &test_segments[6],
596 : NULL,
597 : AS4_DATA, 0,
598 : PEER_CAP_AS4_ADV,
599 : { BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_OPTIONAL,
600 : BGP_ATTR_AS4_PATH,
601 : 14,
602 : },
603 : 3,
604 : },
605 : /* 12 */
606 : {
607 : "4b AS4_PATH: confed",
608 : &test_segments[6],
609 : "8466 3 52737 4096 (123 456 789)",
610 : AS4_DATA, 0,
611 : PEER_CAP_AS4_ADV,
612 : { BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_OPTIONAL,
613 : BGP_ATTR_AS4_PATH,
614 : 14,
615 : },
616 : 3,
617 : &test_segments[0],
618 : },
619 : { NULL, NULL, NULL, 0, 0, 0, { 0 }, 0 },
620 : };
621 :
622 : /* prepending tests */
623 : static struct tests {
624 : const struct test_segment *test1;
625 : const struct test_segment *test2;
626 : struct test_spec sp;
627 : } prepend_tests[] =
628 : {
629 : /* 0 */
630 : { &test_segments[0], &test_segments[1],
631 : { "8466 3 52737 4096 8722 4",
632 : "8466 3 52737 4096 8722 4",
633 : 6, 0, NOT_ALL_PRIVATE, 4096, 1, 8466 },
634 : },
635 : /* 1 */
636 : { &test_segments[1], &test_segments[3],
637 : { "8722 4 8482 51457 {5204}",
638 : "8722 4 8482 51457 {5204}",
639 : 5, 0, NOT_ALL_PRIVATE, 5204, 1, 8722 }
640 : },
641 : /* 2 */
642 : { &test_segments[3], &test_segments[4],
643 : { "8482 51457 {5204} 8467 59649 {4196,48658} {17322,30745}",
644 : "8482 51457 {5204} 8467 59649 {4196,48658} {17322,30745}",
645 : 7, 0, NOT_ALL_PRIVATE, 5204, 1, 8482 },
646 : },
647 : /* 3 */
648 : { &test_segments[4], &test_segments[5],
649 : { "8467 59649 {4196,48658} {17322,30745} 6435 59408 21665"
650 : " {2457,4369,61697} 1842 41590 51793",
651 : "8467 59649 {4196,48658} {17322,30745} 6435 59408 21665"
652 : " {2457,4369,61697} 1842 41590 51793",
653 : 11, 0, NOT_ALL_PRIVATE, 61697, 1, 8467 }
654 : },
655 : /* 4 */
656 : { &test_segments[5], &test_segments[6],
657 : { "6435 59408 21665 {2457,4369,61697} 1842 41590 51793",
658 : "6435 59408 21665 {2457,4369,61697} 1842 41590 51793",
659 : 7, 0, NOT_ALL_PRIVATE, 1842, 1, 6435 },
660 : },
661 : /* 5 */
662 : { &test_segments[6], &test_segments[7],
663 : { "(123 456 789) (123 456 789) (111 222)",
664 : "",
665 : 0, 8, NOT_ALL_PRIVATE, 111, 1, 0 }
666 : },
667 : { &test_segments[7], &test_segments[8],
668 : { "(123 456 789) (111 222) [123,456,789]",
669 : "",
670 : 0, 6, NOT_ALL_PRIVATE, 111, 1, 0 }
671 : },
672 : { &test_segments[8], &test_segments[9],
673 : { "[123,456,789] (123 456 789) [111,222] 8722 {4196,48658}",
674 : "[123,456,789] (123 456 789) [111,222] 8722 {4196,48658}",
675 : 2, 5, NOT_ALL_PRIVATE, 456, 1, NULL_ASN },
676 : },
677 : { &test_segments[9], &test_segments[8],
678 : { "(123 456 789) [111,222] 8722 {4196,48658} [123,456,789]",
679 : "8722 {4196,48658} [123,456,789]",
680 : 2, 5, NOT_ALL_PRIVATE, 48658, 1, NULL_ASN },
681 : },
682 : { &test_segments[14], &test_segments[11],
683 : { "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
684 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
685 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
686 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
687 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
688 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
689 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
690 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
691 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
692 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
693 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
694 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
695 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
696 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
697 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
698 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
699 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
700 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
701 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
702 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
703 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
704 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
705 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
706 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
707 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
708 : "8466 2 52737 4096 8722 4 8722",
709 :
710 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
711 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
712 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
713 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
714 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
715 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
716 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
717 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
718 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
719 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
720 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
721 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
722 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
723 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
724 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
725 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
726 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
727 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
728 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
729 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
730 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
731 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
732 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
733 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
734 : "8466 3 52737 4096 34285 8466 3 52737 4096 34285 "
735 : "8466 2 52737 4096 8722 4 8722",
736 : 257, 0, NOT_ALL_PRIVATE, 4096, 1000, 8466 },
737 : },
738 : { NULL, NULL, { NULL, 0, 0, 0, 0, 0, 0, } },
739 : };
740 :
741 : struct tests reconcile_tests[] =
742 : {
743 : { &test_segments[18], &test_segments[19],
744 : { "6435 59408 21665 {2457,4369,61697} 1842 41591 51793",
745 : "6435 59408 21665 {2457,4369,61697} 1842 41591 51793",
746 : 7, 0, NOT_ALL_PRIVATE, 51793, 1, 6435 },
747 : },
748 : { &test_segments[19], &test_segments[18],
749 : /* AS_PATH (19) has more hops than NEW_AS_PATH,
750 : * so just AS_PATH should be used (though, this practice
751 : * is bad imho).
752 : */
753 : { "{2457,4369,61697} 1842 41591 51793 6435 59408 21665 {23456} 23456 23456 23456",
754 : "{2457,4369,61697} 1842 41591 51793 6435 59408 21665 {23456} 23456 23456 23456",
755 : 11, 0, NOT_ALL_PRIVATE, 51793, 1, 6435 },
756 : },
757 : { &test_segments[20], &test_segments[19],
758 : { "(123 456 789) [124,456,788] 6435 59408 21665"
759 : " {2457,4369,61697} 1842 41591 51793",
760 : "6435 59408 21665 {2457,4369,61697} 1842 41591 51793",
761 : 7, 4, NOT_ALL_PRIVATE, 51793, 1, 6435 },
762 : },
763 : { &test_segments[21], &test_segments[22],
764 : { "1842 41591 51793 6435 59408 21665",
765 : "1842 41591 51793 6435 59408 21665",
766 : 6, 0, NOT_ALL_PRIVATE, 51793, 1, 1842 },
767 : },
768 : { &test_segments[23], &test_segments[22],
769 : { "23456 23456 23456 6435 59408 1842 41591 51793 6435 59408 21665",
770 : "23456 23456 23456 6435 59408 1842 41591 51793 6435 59408 21665",
771 : 11, 0, NOT_ALL_PRIVATE, 51793, 1, 1842 },
772 : },
773 : { NULL, NULL, { NULL, 0, 0, 0, 0, 0, 0, } },
774 : };
775 :
776 : struct tests aggregate_tests[] =
777 : {
778 : { &test_segments[0], &test_segments[2],
779 : { "8466 3 52737 4096 {4,8722}",
780 : "8466 3 52737 4096 {4,8722}",
781 : 5, 0, NOT_ALL_PRIVATE, 4, 1, 8466 },
782 : },
783 : { &test_segments[2], &test_segments[0],
784 : { "8466 3 52737 4096 {4,8722}",
785 : "8466 3 52737 4096 {4,8722}",
786 : 5, 0, NOT_ALL_PRIVATE, 8722, 1, 8466 },
787 : },
788 : { &test_segments[2], &test_segments[10],
789 : { "8466 {2,3,4,4096,8722,52737}",
790 : "8466 {2,3,4,4096,8722,52737}",
791 : 2, 0, NOT_ALL_PRIVATE, 8722, 5, 8466 },
792 : },
793 : { &test_segments[10], &test_segments[2],
794 : { "8466 {2,3,4,4096,8722,52737}",
795 : "8466 {2,3,4,4096,8722,52737}",
796 : 2, 0, NOT_ALL_PRIVATE, 2, 20000, 8466 },
797 : },
798 :
799 : { &test_segments[5], &test_segments[18],
800 : { "6435 59408 21665 {1842,2457,4369,23456,41590,51793,61697}",
801 : "6435 59408 21665 {1842,2457,4369,23456,41590,51793,61697}",
802 : 4, 0, NOT_ALL_PRIVATE, 41590, 1, 6435 },
803 : },
804 :
805 : { NULL, NULL, { NULL, 0, 0} },
806 : };
807 :
808 : struct compare_tests
809 : {
810 : int test_index1;
811 : int test_index2;
812 : #define CMP_RES_YES 1
813 : #define CMP_RES_NO 0
814 : char shouldbe_cmp;
815 : char shouldbe_confed;
816 : } left_compare [] =
817 : {
818 : { 0, 1, CMP_RES_NO, CMP_RES_NO },
819 : { 0, 2, CMP_RES_YES, CMP_RES_NO },
820 : { 0, 11, CMP_RES_YES, CMP_RES_NO },
821 : { 0, 15, CMP_RES_YES, CMP_RES_NO },
822 : { 0, 16, CMP_RES_NO, CMP_RES_NO },
823 : { 1, 11, CMP_RES_NO, CMP_RES_NO },
824 : { 6, 7, CMP_RES_NO, CMP_RES_YES },
825 : { 6, 8, CMP_RES_NO, CMP_RES_NO },
826 : { 7, 8, CMP_RES_NO, CMP_RES_NO },
827 : { 1, 9, CMP_RES_YES, CMP_RES_NO },
828 : { 0, 9, CMP_RES_NO, CMP_RES_NO },
829 : { 3, 9, CMP_RES_NO, CMP_RES_NO },
830 : { 0, 6, CMP_RES_NO, CMP_RES_NO },
831 : { 1, 6, CMP_RES_NO, CMP_RES_NO },
832 : { 0, 8, CMP_RES_NO, CMP_RES_NO },
833 : { 1, 8, CMP_RES_NO, CMP_RES_NO },
834 : { 11, 6, CMP_RES_NO, CMP_RES_NO },
835 : { 11, 7, CMP_RES_NO, CMP_RES_NO },
836 : { 11, 8, CMP_RES_NO, CMP_RES_NO },
837 : { 9, 6, CMP_RES_NO, CMP_RES_YES },
838 : { 9, 7, CMP_RES_NO, CMP_RES_YES },
839 : { 9, 8, CMP_RES_NO, CMP_RES_NO },
840 : };
841 :
842 : /* make an aspath from a data stream */
843 : static struct aspath *
844 295 : make_aspath (const u_char *data, size_t len, int use32bit)
845 : {
846 295 : struct stream *s = NULL;
847 : struct aspath *as;
848 :
849 295 : if (len)
850 : {
851 286 : s = stream_new (len);
852 286 : stream_put (s, data, len);
853 : }
854 295 : as = aspath_parse (s, len, use32bit);
855 :
856 295 : if (s)
857 286 : stream_free (s);
858 :
859 295 : return as;
860 : }
861 :
862 : static void
863 0 : printbytes (const u_char *bytes, int len)
864 : {
865 0 : int i = 0;
866 0 : while (i < len)
867 : {
868 0 : if (i % 2)
869 0 : printf ("%02hhx%s", bytes[i], " ");
870 : else
871 0 : printf ("0x%02hhx", bytes[i]);
872 0 : i++;
873 : }
874 0 : printf ("\n");
875 0 : }
876 :
877 : /* validate the given aspath */
878 : static int
879 77 : validate (struct aspath *as, const struct test_spec *sp)
880 : {
881 : size_t bytes, bytes4;
882 77 : int fails = 0;
883 : const u_char *out;
884 : static struct stream *s;
885 : struct aspath *asinout, *asconfeddel, *asstr, *as4;
886 :
887 77 : if (as == NULL && sp->shouldbe == NULL)
888 : {
889 6 : printf ("Correctly failed to parse\n");
890 6 : return fails;
891 : }
892 :
893 71 : out = aspath_snmp_pathseg (as, &bytes);
894 71 : asinout = make_aspath (out, bytes, 0);
895 :
896 : /* Excercise AS4 parsing a bit, with a dogfood test */
897 71 : if (!s)
898 1 : s = stream_new (4096);
899 71 : bytes4 = aspath_put (s, as, 1);
900 71 : as4 = make_aspath (STREAM_DATA(s), bytes4, 1);
901 :
902 71 : asstr = aspath_str2aspath (sp->shouldbe);
903 :
904 71 : asconfeddel = aspath_delete_confed_seq (aspath_dup (asinout));
905 :
906 71 : printf ("got: %s\n", aspath_print(as));
907 :
908 : /* the parsed path should match the specified 'shouldbe' string.
909 : * We should pass the "eat our own dog food" test, be able to output
910 : * this path and then input it again. Ie the path resulting from:
911 : *
912 : * aspath_parse(aspath_put(as))
913 : *
914 : * should:
915 : *
916 : * - also match the specified 'shouldbe' value
917 : * - hash to same value as original path
918 : * - have same hops and confed counts as original, and as the
919 : * the specified counts
920 : *
921 : * aspath_str2aspath() and shouldbe should match
922 : *
923 : * We do the same for:
924 : *
925 : * aspath_parse(aspath_put(as,USE32BIT))
926 : *
927 : * Confederation related tests:
928 : * - aspath_delete_confed_seq(aspath) should match shouldbe_confed
929 : * - aspath_delete_confed_seq should be idempotent.
930 : */
931 71 : if (strcmp(aspath_print (as), sp->shouldbe)
932 : /* hash validation */
933 71 : || (aspath_key_make (as) != aspath_key_make (asinout))
934 : /* by string */
935 71 : || strcmp(aspath_print (asinout), sp->shouldbe)
936 : /* By 4-byte parsing */
937 71 : || strcmp(aspath_print (as4), sp->shouldbe)
938 : /* by various path counts */
939 71 : || (aspath_count_hops (as) != sp->hops)
940 71 : || (aspath_count_confeds (as) != sp->confeds)
941 71 : || (aspath_count_hops (asinout) != sp->hops)
942 71 : || (aspath_count_confeds (asinout) != sp->confeds))
943 : {
944 0 : failed++;
945 0 : fails++;
946 0 : printf ("shouldbe:\n%s\n", sp->shouldbe);
947 0 : printf ("as4:\n%s\n", aspath_print (as4));
948 0 : printf ("hash keys: in: %d out->in: %d\n",
949 : aspath_key_make (as), aspath_key_make (asinout));
950 0 : printf ("hops: %d, counted %d %d\n", sp->hops,
951 : aspath_count_hops (as),
952 : aspath_count_hops (asinout) );
953 0 : printf ("confeds: %d, counted %d %d\n", sp->confeds,
954 : aspath_count_confeds (as),
955 : aspath_count_confeds (asinout));
956 0 : printf ("out->in:\n%s\nbytes: ", aspath_print(asinout));
957 0 : printbytes (out, bytes);
958 : }
959 : /* basic confed related tests */
960 71 : if ((aspath_print (asconfeddel) == NULL
961 0 : && sp->shouldbe_delete_confed != NULL)
962 71 : || (aspath_print (asconfeddel) != NULL
963 71 : && sp->shouldbe_delete_confed == NULL)
964 71 : || strcmp(aspath_print (asconfeddel), sp->shouldbe_delete_confed)
965 : /* delete_confed_seq should be idempotent */
966 142 : || (aspath_key_make (asconfeddel)
967 71 : != aspath_key_make (aspath_delete_confed_seq (asconfeddel))))
968 : {
969 0 : failed++;
970 0 : fails++;
971 0 : printf ("confed_del: %s\n", aspath_print (asconfeddel));
972 0 : printf ("should be: %s\n", sp->shouldbe_delete_confed);
973 : }
974 : /* aspath_str2aspath test */
975 71 : if ((aspath_print (asstr) == NULL && sp->shouldbe != NULL)
976 71 : || (aspath_print (asstr) != NULL && sp->shouldbe == NULL)
977 71 : || strcmp(aspath_print (asstr), sp->shouldbe))
978 : {
979 0 : failed++;
980 0 : fails++;
981 0 : printf ("asstr: %s\n", aspath_print (asstr));
982 : }
983 :
984 : /* loop, private and first as checks */
985 71 : if ((sp->does_loop && aspath_loop_check (as, sp->does_loop) == 0)
986 71 : || (sp->doesnt_loop && aspath_loop_check (as, sp->doesnt_loop) != 0)
987 71 : || (aspath_private_as_check (as) != sp->private_as)
988 71 : || (aspath_firstas_check (as,sp->first)
989 49 : && sp->first == 0))
990 : {
991 0 : failed++;
992 0 : fails++;
993 0 : printf ("firstas: %d, got %d\n", sp->first,
994 : aspath_firstas_check (as,sp->first));
995 0 : printf ("loop does: %d %d, doesnt: %d %d\n",
996 : sp->does_loop, aspath_loop_check (as, sp->does_loop),
997 : sp->doesnt_loop, aspath_loop_check (as, sp->doesnt_loop));
998 0 : printf ("private check: %d %d\n", sp->private_as,
999 : aspath_private_as_check (as));
1000 : }
1001 71 : aspath_unintern (&asinout);
1002 71 : aspath_unintern (&as4);
1003 :
1004 71 : aspath_free (asconfeddel);
1005 71 : aspath_free (asstr);
1006 71 : stream_reset (s);
1007 :
1008 71 : return fails;
1009 : }
1010 :
1011 : static void
1012 1 : empty_get_test ()
1013 : {
1014 1 : struct aspath *as = aspath_empty_get ();
1015 1 : struct test_spec sp = { "", "", 0, 0, 0, 0, 0, 0 };
1016 :
1017 1 : printf ("empty_get_test, as: %s\n",aspath_print (as));
1018 1 : if (!validate (as, &sp))
1019 1 : printf ("%s\n", OK);
1020 : else
1021 0 : printf ("%s!\n", FAILED);
1022 :
1023 1 : printf ("\n");
1024 :
1025 1 : aspath_free (as);
1026 1 : }
1027 :
1028 : /* basic parsing test */
1029 : static void
1030 28 : parse_test (struct test_segment *t)
1031 : {
1032 : struct aspath *asp;
1033 :
1034 28 : printf ("%s: %s\n", t->name, t->desc);
1035 :
1036 28 : asp = make_aspath (t->asdata, t->len, 0);
1037 :
1038 28 : printf ("aspath: %s\nvalidating...:\n", aspath_print (asp));
1039 :
1040 28 : if (!validate (asp, &t->sp))
1041 28 : printf (OK "\n");
1042 : else
1043 0 : printf (FAILED "\n");
1044 :
1045 28 : printf ("\n");
1046 :
1047 28 : if (asp)
1048 25 : aspath_unintern (&asp);
1049 28 : }
1050 :
1051 : /* prepend testing */
1052 : static void
1053 10 : prepend_test (struct tests *t)
1054 : {
1055 : struct aspath *asp1, *asp2, *ascratch;
1056 :
1057 10 : printf ("prepend %s: %s\n", t->test1->name, t->test1->desc);
1058 10 : printf ("to %s: %s\n", t->test2->name, t->test2->desc);
1059 :
1060 10 : asp1 = make_aspath (t->test1->asdata, t->test1->len, 0);
1061 10 : asp2 = make_aspath (t->test2->asdata, t->test2->len, 0);
1062 :
1063 10 : ascratch = aspath_dup (asp2);
1064 10 : aspath_unintern (&asp2);
1065 :
1066 10 : asp2 = aspath_prepend (asp1, ascratch);
1067 :
1068 10 : printf ("aspath: %s\n", aspath_print (asp2));
1069 :
1070 10 : if (!validate (asp2, &t->sp))
1071 10 : printf ("%s\n", OK);
1072 : else
1073 0 : printf ("%s!\n", FAILED);
1074 :
1075 10 : printf ("\n");
1076 10 : aspath_unintern (&asp1);
1077 10 : aspath_free (asp2);
1078 10 : }
1079 :
1080 : /* empty-prepend testing */
1081 : static void
1082 28 : empty_prepend_test (struct test_segment *t)
1083 : {
1084 : struct aspath *asp1, *asp2, *ascratch;
1085 :
1086 28 : printf ("empty prepend %s: %s\n", t->name, t->desc);
1087 :
1088 28 : asp1 = make_aspath (t->asdata, t->len, 0);
1089 28 : asp2 = aspath_empty ();
1090 :
1091 28 : ascratch = aspath_dup (asp2);
1092 28 : aspath_unintern (&asp2);
1093 :
1094 28 : asp2 = aspath_prepend (asp1, ascratch);
1095 :
1096 28 : printf ("aspath: %s\n", aspath_print (asp2));
1097 :
1098 28 : if (!validate (asp2, &t->sp))
1099 28 : printf (OK "\n");
1100 : else
1101 0 : printf (FAILED "!\n");
1102 :
1103 28 : printf ("\n");
1104 28 : if (asp1)
1105 25 : aspath_unintern (&asp1);
1106 28 : aspath_free (asp2);
1107 28 : }
1108 :
1109 : /* as2+as4 reconciliation testing */
1110 : static void
1111 5 : as4_reconcile_test (struct tests *t)
1112 : {
1113 : struct aspath *asp1, *asp2, *ascratch;
1114 :
1115 5 : printf ("reconciling %s:\n %s\n", t->test1->name, t->test1->desc);
1116 5 : printf ("with %s:\n %s\n", t->test2->name, t->test2->desc);
1117 :
1118 5 : asp1 = make_aspath (t->test1->asdata, t->test1->len, 0);
1119 5 : asp2 = make_aspath (t->test2->asdata, t->test2->len, 0);
1120 :
1121 5 : ascratch = aspath_reconcile_as4 (asp1, asp2);
1122 :
1123 5 : if (!validate (ascratch, &t->sp))
1124 5 : printf (OK "\n");
1125 : else
1126 0 : printf (FAILED "!\n");
1127 :
1128 5 : printf ("\n");
1129 5 : aspath_unintern (&asp1);
1130 5 : aspath_unintern (&asp2);
1131 5 : aspath_free (ascratch);
1132 5 : }
1133 :
1134 :
1135 : /* aggregation testing */
1136 : static void
1137 5 : aggregate_test (struct tests *t)
1138 : {
1139 : struct aspath *asp1, *asp2, *ascratch;
1140 :
1141 5 : printf ("aggregate %s: %s\n", t->test1->name, t->test1->desc);
1142 5 : printf ("with %s: %s\n", t->test2->name, t->test2->desc);
1143 :
1144 5 : asp1 = make_aspath (t->test1->asdata, t->test1->len, 0);
1145 5 : asp2 = make_aspath (t->test2->asdata, t->test2->len, 0);
1146 :
1147 5 : ascratch = aspath_aggregate (asp1, asp2);
1148 :
1149 5 : if (!validate (ascratch, &t->sp))
1150 5 : printf (OK "\n");
1151 : else
1152 0 : printf (FAILED "!\n");
1153 :
1154 5 : printf ("\n");
1155 5 : aspath_unintern (&asp1);
1156 5 : aspath_unintern (&asp2);
1157 5 : aspath_free (ascratch);
1158 : /* aspath_unintern (ascratch);*/
1159 5 : }
1160 :
1161 : /* cmp_left tests */
1162 : static void
1163 1 : cmp_test ()
1164 : {
1165 : unsigned int i;
1166 : #define CMP_TESTS_MAX \
1167 : (sizeof(left_compare) / sizeof (struct compare_tests))
1168 :
1169 23 : for (i = 0; i < CMP_TESTS_MAX; i++)
1170 : {
1171 22 : struct test_segment *t1 = &test_segments[left_compare[i].test_index1];
1172 22 : struct test_segment *t2 = &test_segments[left_compare[i].test_index2];
1173 : struct aspath *asp1, *asp2;
1174 :
1175 22 : printf ("left cmp %s: %s\n", t1->name, t1->desc);
1176 22 : printf ("and %s: %s\n", t2->name, t2->desc);
1177 :
1178 22 : asp1 = make_aspath (t1->asdata, t1->len, 0);
1179 22 : asp2 = make_aspath (t2->asdata, t2->len, 0);
1180 :
1181 22 : if (aspath_cmp_left (asp1, asp2) != left_compare[i].shouldbe_cmp
1182 22 : || aspath_cmp_left (asp2, asp1) != left_compare[i].shouldbe_cmp
1183 44 : || aspath_cmp_left_confed (asp1, asp2)
1184 22 : != left_compare[i].shouldbe_confed
1185 44 : || aspath_cmp_left_confed (asp2, asp1)
1186 22 : != left_compare[i].shouldbe_confed)
1187 : {
1188 0 : failed++;
1189 0 : printf (FAILED "\n");
1190 0 : printf ("result should be: cmp: %d, confed: %d\n",
1191 0 : left_compare[i].shouldbe_cmp,
1192 0 : left_compare[i].shouldbe_confed);
1193 0 : printf ("got: cmp %d, cmp_confed: %d\n",
1194 : aspath_cmp_left (asp1, asp2),
1195 : aspath_cmp_left_confed (asp1, asp2));
1196 0 : printf("path1: %s\npath2: %s\n", aspath_print (asp1),
1197 : aspath_print (asp2));
1198 : }
1199 : else
1200 22 : printf (OK "\n");
1201 :
1202 22 : printf ("\n");
1203 22 : aspath_unintern (&asp1);
1204 22 : aspath_unintern (&asp2);
1205 : }
1206 1 : }
1207 :
1208 : static int
1209 13 : handle_attr_test (struct aspath_tests *t)
1210 : {
1211 13 : struct bgp bgp = { 0 };
1212 13 : struct peer peer = { 0 };
1213 13 : struct attr attr = { 0 };
1214 : int ret;
1215 13 : int initfail = failed;
1216 : struct aspath *asp;
1217 : size_t datalen;
1218 :
1219 13 : asp = make_aspath (t->segment->asdata, t->segment->len, 0);
1220 :
1221 13 : peer.ibuf = stream_new (BGP_MAX_PACKET_SIZE);
1222 13 : peer.obuf = stream_fifo_new ();
1223 13 : peer.bgp = &bgp;
1224 13 : peer.host = (char *)"none";
1225 13 : peer.fd = -1;
1226 13 : peer.cap = t->cap;
1227 :
1228 13 : stream_write (peer.ibuf, t->attrheader, t->len);
1229 13 : datalen = aspath_put (peer.ibuf, asp, t->as4 == AS4_DATA);
1230 13 : if (t->old_segment)
1231 : {
1232 2 : char dummyaspath[] = { BGP_ATTR_FLAG_TRANS, BGP_ATTR_AS_PATH,
1233 1 : t->old_segment->len };
1234 1 : stream_write (peer.ibuf, dummyaspath, sizeof (dummyaspath));
1235 1 : stream_write (peer.ibuf, t->old_segment->asdata, t->old_segment->len);
1236 1 : datalen += sizeof (dummyaspath) + t->old_segment->len;
1237 : }
1238 :
1239 13 : ret = bgp_attr_parse (&peer, &attr, t->len + datalen, NULL, NULL);
1240 :
1241 13 : if (ret != t->result)
1242 : {
1243 0 : printf ("bgp_attr_parse returned %d, expected %d\n", ret, t->result);
1244 0 : printf ("datalen %zd\n", datalen);
1245 0 : failed++;
1246 : }
1247 13 : if (ret != 0)
1248 9 : goto out;
1249 :
1250 4 : if (t->shouldbe && attr.aspath == NULL)
1251 : {
1252 0 : printf ("aspath is NULL, but should be: %s\n", t->shouldbe);
1253 0 : failed++;
1254 : }
1255 4 : if (t->shouldbe && attr.aspath && strcmp (attr.aspath->str, t->shouldbe))
1256 : {
1257 0 : printf ("attr str and 'shouldbe' mismatched!\n"
1258 : "attr str: %s\n"
1259 : "shouldbe: %s\n",
1260 0 : attr.aspath->str, t->shouldbe);
1261 0 : failed++;
1262 : }
1263 4 : if (!t->shouldbe && attr.aspath)
1264 : {
1265 0 : printf ("aspath should be NULL, but is: %s\n", attr.aspath->str);
1266 0 : failed++;
1267 : }
1268 :
1269 : out:
1270 13 : if (attr.aspath)
1271 3 : aspath_unintern (&attr.aspath);
1272 13 : if (asp)
1273 13 : aspath_unintern (&asp);
1274 13 : return failed - initfail;
1275 : }
1276 :
1277 : static void
1278 13 : attr_test (struct aspath_tests *t)
1279 : {
1280 13 : printf ("%s\n", t->desc);
1281 13 : printf ("%s\n\n", handle_attr_test (t) ? FAILED : OK);
1282 13 : }
1283 :
1284 : int
1285 1 : main (void)
1286 : {
1287 1 : int i = 0;
1288 1 : bgp_master_init ();
1289 1 : master = bm->master;
1290 1 : bgp_option_set (BGP_OPT_NO_LISTEN);
1291 1 : bgp_attr_init ();
1292 :
1293 30 : while (test_segments[i].name)
1294 : {
1295 28 : printf ("test %u\n", i);
1296 28 : parse_test (&test_segments[i]);
1297 28 : empty_prepend_test (&test_segments[i++]);
1298 : }
1299 :
1300 1 : i = 0;
1301 12 : while (prepend_tests[i].test1)
1302 : {
1303 10 : printf ("prepend test %u\n", i);
1304 10 : prepend_test (&prepend_tests[i++]);
1305 : }
1306 :
1307 1 : i = 0;
1308 7 : while (aggregate_tests[i].test1)
1309 : {
1310 5 : printf ("aggregate test %u\n", i);
1311 5 : aggregate_test (&aggregate_tests[i++]);
1312 : }
1313 :
1314 1 : i = 0;
1315 :
1316 7 : while (reconcile_tests[i].test1)
1317 : {
1318 5 : printf ("reconcile test %u\n", i);
1319 5 : as4_reconcile_test (&reconcile_tests[i++]);
1320 : }
1321 :
1322 1 : i = 0;
1323 :
1324 1 : cmp_test();
1325 :
1326 1 : i = 0;
1327 :
1328 1 : empty_get_test();
1329 :
1330 1 : i = 0;
1331 :
1332 15 : while (aspath_tests[i].desc)
1333 : {
1334 13 : printf ("aspath_attr test %d\n", i);
1335 13 : attr_test (&aspath_tests[i++]);
1336 : }
1337 :
1338 1 : printf ("failures: %d\n", failed);
1339 1 : printf ("aspath count: %ld\n", aspath_count());
1340 :
1341 1 : return (failed + aspath_count());
1342 : }
|
