Annotation of embedaddon/bird2/lib/flowspec_test.c, revision 1.1.1.1
1.1 misho 1: /*
2: * BIRD Library -- Flow specification (RFC 5575) Tests
3: *
4: * (c) 2016 CZ.NIC z.s.p.o.
5: *
6: * Can be freely distributed and used under the terms of the GNU GPL.
7: */
8:
9: #include "test/birdtest.h"
10: #include "lib/flowspec.h"
11:
12: #define NET_ADDR_FLOW4_(what,prefix,pxlen,data_) \
13: do \
14: { \
15: what = alloca(sizeof(net_addr_flow4) + 128); \
16: *what = NET_ADDR_FLOW4(prefix, pxlen, sizeof(data_)); \
17: memcpy(what->data, &(data_), sizeof(data_)); \
18: } while(0)
19:
20: #define NET_ADDR_FLOW6_(what,prefix,pxlen,data_) \
21: do \
22: { \
23: what = alloca(sizeof(net_addr_flow6) + 128); \
24: *what = NET_ADDR_FLOW6(prefix, pxlen, sizeof(data_)); \
25: memcpy(what->data, &(data_), sizeof(data_)); \
26: } while(0)
27:
28: static int
29: t_read_length(void)
30: {
31: byte data[] = { 0xcc, 0xcc, 0xcc };
32:
33: for (uint expect = 0; expect < 0xf0; expect++)
34: {
35: *data = expect;
36: uint get = flow_read_length(data);
37: bt_assert_msg(get == expect, "Testing get length 0x%02x (get 0x%02x)", expect, get);
38: }
39:
40: for (uint expect = 0; expect <= 0xfff; expect++)
41: {
42: put_u16(data, expect | 0xf000);
43: uint get = flow_read_length(data);
44: bt_assert_msg(get == expect, "Testing get length 0x%03x (get 0x%03x)", expect, get);
45: }
46:
47: return 1;
48: }
49:
50: static int
51: t_write_length(void)
52: {
53: byte data[] = { 0xcc, 0xcc, 0xcc };
54:
55: for (uint expect = 0; expect <= 0xfff; expect++)
56: {
57: uint offset = flow_write_length(data, expect);
58:
59: uint set = (expect < 0xf0) ? *data : (get_u16(data) & 0x0fff);
60: bt_assert_msg(set == expect, "Testing set length 0x%03x (set 0x%03x)", expect, set);
61: bt_assert(offset == (expect < 0xf0 ? 1 : 2));
62: }
63:
64: return 1;
65: }
66:
67: static int
68: t_first_part(void)
69: {
70: net_addr_flow4 *f;
71: NET_ADDR_FLOW4_(f, ip4_build(10,0,0,1), 24, ((byte[]) { 0x00, 0x00, 0xab }));
72:
73: const byte *under240 = &f->data[1];
74: const byte *above240 = &f->data[2];
75:
76: /* Case 0x00 0x00 */
77: bt_assert(flow4_first_part(f) == NULL);
78:
79: /* Case 0x01 0x00 */
80: f->data[0] = 0x01;
81: bt_assert(flow4_first_part(f) == under240);
82:
83: /* Case 0xef 0x00 */
84: f->data[0] = 0xef;
85: bt_assert(flow4_first_part(f) == under240);
86:
87: /* Case 0xf0 0x00 */
88: f->data[0] = 0xf0;
89: bt_assert(flow4_first_part(f) == NULL);
90:
91: /* Case 0xf0 0x01 */
92: f->data[1] = 0x01;
93: bt_assert(flow4_first_part(f) == above240);
94:
95: /* Case 0xff 0xff */
96: f->data[0] = 0xff;
97: f->data[1] = 0xff;
98: bt_assert(flow4_first_part(f) == above240);
99:
100: return 1;
101: }
102:
103: static int
104: t_iterators4(void)
105: {
106: net_addr_flow4 *f;
107: NET_ADDR_FLOW4_(f, ip4_build(5,6,7,0), 24, ((byte[]) {
108: 25, /* Length */
109: FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
110: FLOW_TYPE_SRC_PREFIX, 32, 10, 11, 12, 13,
111: FLOW_TYPE_IP_PROTOCOL, 0x81, 0x06,
112: FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
113: FLOW_TYPE_TCP_FLAGS, 0x80, 0x55,
114: }));
115:
116: const byte *start = f->data;
117: const byte *p1_dst_pfx = &f->data[1];
118: const byte *p2_src_pfx = &f->data[6];
119: const byte *p3_ip_proto = &f->data[12];
120: const byte *p4_port = &f->data[15];
121: const byte *p5_tcp_flags = &f->data[23];
122: const byte *end = &f->data[25];
123:
124: bt_assert(flow_read_length(f->data) == (end-start));
125: bt_assert(flow4_first_part(f) == p1_dst_pfx);
126:
127: bt_assert(flow4_next_part(p1_dst_pfx, end) == p2_src_pfx);
128: bt_assert(flow4_next_part(p2_src_pfx, end) == p3_ip_proto);
129: bt_assert(flow4_next_part(p3_ip_proto, end) == p4_port);
130: bt_assert(flow4_next_part(p4_port, end) == p5_tcp_flags);
131: bt_assert(flow4_next_part(p5_tcp_flags, end) == NULL);
132:
133: return 1;
134: }
135:
136: static int
137: t_iterators6(void)
138: {
139: net_addr_flow6 *f;
140: NET_ADDR_FLOW6_(f, ip6_build(0,0,0x12345678,0x9a000000), 64, ((byte[]) {
141: 26, /* Length */
142: FLOW_TYPE_DST_PREFIX, 0x68, 0x40, 0x12, 0x34, 0x56, 0x78, 0x9a,
143: FLOW_TYPE_SRC_PREFIX, 0x08, 0x0, 0xc0,
144: FLOW_TYPE_NEXT_HEADER, 0x81, 0x06,
145: FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
146: FLOW_TYPE_LABEL, 0x80, 0x55,
147: }));
148:
149: const byte *start = f->data;
150: const byte *p1_dst_pfx = &f->data[1];
151: const byte *p2_src_pfx = &f->data[9];
152: const byte *p3_next_header = &f->data[13];
153: const byte *p4_port = &f->data[16];
154: const byte *p5_label = &f->data[24];
155: const byte *end = &f->data[26];
156:
157: bt_assert(flow_read_length(f->data) == (end-start));
158: bt_assert(flow6_first_part(f) == p1_dst_pfx);
159:
160: bt_assert(flow6_next_part(p1_dst_pfx, end) == p2_src_pfx);
161: bt_assert(flow6_next_part(p2_src_pfx, end) == p3_next_header);
162: bt_assert(flow6_next_part(p3_next_header, end) == p4_port);
163: bt_assert(flow6_next_part(p4_port, end) == p5_label);
164: bt_assert(flow6_next_part(p5_label, end) == NULL);
165:
166: return 1;
167: }
168:
169: static int
170: t_validation4(void)
171: {
172: enum flow_validated_state res;
173:
174: byte nlri1[] = {
175: FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
176: FLOW_TYPE_SRC_PREFIX, 32, 10, 11, 12, 13,
177: FLOW_TYPE_IP_PROTOCOL, 0x81, 0x06,
178: FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
179: FLOW_TYPE_TCP_FLAGS, 0x80, 0x55,
180: };
181:
182: /* Isn't included destination prefix */
183: res = flow4_validate(nlri1, 0);
184: bt_assert(res == FLOW_ST_DEST_PREFIX_REQUIRED);
185: res = flow4_validate(&nlri1[5], sizeof(nlri1)-5);
186: bt_assert(res == FLOW_ST_DEST_PREFIX_REQUIRED);
187:
188: /* Valid / Not Complete testing */
189: uint valid_sizes[] = {5, 11, 14, 22, 25, 0};
190: uint valid_idx = 0;
191: for (uint size = 1; size <= sizeof(nlri1); size++)
192: {
193: res = flow4_validate(nlri1, size);
194: bt_debug("size %u, result: %s\n", size, flow_validated_state_str(res));
195: if (size == valid_sizes[valid_idx])
196: {
197: valid_idx++;
198: bt_assert(res == FLOW_ST_VALID);
199: }
200: else
201: {
202: bt_assert(res == FLOW_ST_NOT_COMPLETE);
203: }
204: }
205:
206: /* Misc err tests */
207:
208: struct tset {
209: enum flow_validated_state expect;
210: char *description;
211: u16 size;
212: byte *nlri;
213: };
214:
215: #define TS(type, msg, data) ((struct tset) {type, msg, sizeof(data), (data)})
216: struct tset tset[] = {
217: TS(
218: FLOW_ST_EXCEED_MAX_PREFIX_LENGTH,
219: "33-length IPv4 prefix",
220: ((byte []) {
221: FLOW_TYPE_DST_PREFIX, 33, 5, 6, 7, 8, 9
222: })
223: ),
224: TS(
225: FLOW_ST_BAD_TYPE_ORDER,
226: "Bad flowspec component type order",
227: ((byte []) {
228: FLOW_TYPE_SRC_PREFIX, 32, 10, 11, 12, 13,
229: FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
230: })
231: ),
232: TS(
233: FLOW_ST_BAD_TYPE_ORDER,
234: "Doubled destination prefix component",
235: ((byte []) {
236: FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
237: FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
238: })
239: ),
240: TS(
241: FLOW_ST_AND_BIT_SHOULD_BE_UNSET,
242: "The first numeric operator has set the AND bit",
243: ((byte []) {
244: FLOW_TYPE_PORT, 0x43, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
245: })
246: ),
247: TS(
248: FLOW_ST_ZERO_BIT_SHOULD_BE_UNSED,
249: "Set zero bit in operand to one",
250: ((byte []) {
251: FLOW_TYPE_IP_PROTOCOL, 0x89, 0x06,
252: })
253: ),
254: TS(
255: FLOW_ST_UNKNOWN_COMPONENT,
256: "Unknown component of type number 13",
257: ((byte []) {
258: FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
259: FLOW_TYPE_TCP_FLAGS, 0x80, 0x55,
260: 13 /*something new*/, 0x80, 0x55,
261: })
262: ),
263: };
264: #undef TS
265:
266: for (uint tcase = 0; tcase < ARRAY_SIZE(tset); tcase++)
267: {
268: res = flow4_validate(tset[tcase].nlri, tset[tcase].size);
269: bt_assert_msg(res == tset[tcase].expect, "Assertion (%s == %s) %s", flow_validated_state_str(res), flow_validated_state_str(tset[tcase].expect), tset[tcase].description);
270: }
271:
272: return 1;
273: }
274:
275: static int
276: t_validation6(void)
277: {
278: enum flow_validated_state res;
279:
280: byte nlri1[] = {
281: FLOW_TYPE_DST_PREFIX, 103, 61, 0x01, 0x12, 0x34, 0x56, 0x78, 0x98,
282: FLOW_TYPE_SRC_PREFIX, 8, 0, 0xc0,
283: FLOW_TYPE_NEXT_HEADER, 0x81, 0x06,
284: FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
285: FLOW_TYPE_LABEL, 0x80, 0x55,
286: };
287:
288: /* Isn't included destination prefix */
289: res = flow6_validate(nlri1, 0);
290: bt_assert(res == FLOW_ST_VALID);
291:
292: /* Valid / Not Complete testing */
293: uint valid_sizes[] = {0, 9, 13, 16, 24, 27, 0};
294: uint valid_idx = 0;
295: for (uint size = 0; size <= sizeof(nlri1); size++)
296: {
297: res = flow6_validate(nlri1, size);
298: bt_debug("size %u, result: %s\n", size, flow_validated_state_str(res));
299: if (size == valid_sizes[valid_idx])
300: {
301: valid_idx++;
302: bt_assert(res == FLOW_ST_VALID);
303: }
304: else
305: {
306: bt_assert(res == FLOW_ST_NOT_COMPLETE);
307: }
308: }
309:
310: /* Misc err tests */
311:
312: struct tset {
313: enum flow_validated_state expect;
314: char *description;
315: u16 size;
316: byte *nlri;
317: };
318:
319: #define TS(type, msg, data) ((struct tset) {type, msg, sizeof(data), (data)})
320: struct tset tset[] = {
321: TS(
322: FLOW_ST_EXCEED_MAX_PREFIX_LENGTH,
323: "129-length IPv6 prefix",
324: ((byte []) {
325: FLOW_TYPE_DST_PREFIX, 129, 64, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
326: })
327: ),
328: TS(
329: FLOW_ST_EXCEED_MAX_PREFIX_OFFSET,
330: "Prefix offset is higher than prefix length",
331: ((byte []) {
332: FLOW_TYPE_DST_PREFIX, 48, 64, 0x40, 0x12, 0x34
333: })
334: ),
335: TS(
336: FLOW_ST_BAD_TYPE_ORDER,
337: "Bad flowspec component type order",
338: ((byte []) {
339: FLOW_TYPE_NEXT_HEADER, 0x81, 0x06,
340: FLOW_TYPE_SRC_PREFIX, 8, 0, 0xc0,
341: })
342: ),
343: TS(
344: FLOW_ST_BAD_TYPE_ORDER,
345: "Doubled destination prefix component",
346: ((byte []) {
347: FLOW_TYPE_DST_PREFIX, 103, 61, 0x01, 0x12, 0x34, 0x56, 0x78, 0x98,
348: FLOW_TYPE_DST_PREFIX, 103, 61, 0x01, 0x12, 0x34, 0x56, 0x78, 0x98,
349: })
350: ),
351: TS(
352: FLOW_ST_AND_BIT_SHOULD_BE_UNSET,
353: "The first numeric operator has set the AND bit",
354: ((byte []) {
355: FLOW_TYPE_PORT, 0x43, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90
356: })
357: ),
358: TS(
359: FLOW_ST_ZERO_BIT_SHOULD_BE_UNSED,
360: "Set zero bit in operand to one",
361: ((byte []) {
362: FLOW_TYPE_NEXT_HEADER, 0x89, 0x06
363: })
364: ),
365: TS(
366: FLOW_ST_VALID,
367: "Component of type number 13 (Label) is well-known in IPv6",
368: ((byte []) {
369: FLOW_TYPE_LABEL, 0x80, 0x55
370: })
371: ),
372: TS(
373: FLOW_ST_UNKNOWN_COMPONENT,
374: "Unknown component of type number 14",
375: ((byte []) {
376: FLOW_TYPE_LABEL, 0x80, 0x55,
377: 14 /*something new*/, 0x80, 0x55,
378: })
379: )
380: };
381: #undef TS
382:
383: for (uint tcase = 0; tcase < ARRAY_SIZE(tset); tcase++)
384: {
385: res = flow6_validate(tset[tcase].nlri, tset[tcase].size);
386: bt_assert_msg(res == tset[tcase].expect, "Assertion (%s == %s) %s", flow_validated_state_str(res), flow_validated_state_str(tset[tcase].expect), tset[tcase].description);
387: }
388:
389: return 1;
390: }
391:
392:
393:
394: /*
395: * Builder tests
396: */
397:
398: static int
399: t_builder4(void)
400: {
401: resource_init();
402:
403: struct flow_builder *fb = flow_builder_init(&root_pool);
404: linpool *lp = lp_new_default(&root_pool);
405:
406: /* Expectation */
407:
408: static byte nlri[] = {
409: 25,
410: FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
411: FLOW_TYPE_SRC_PREFIX, 32, 10, 11, 12, 13,
412: FLOW_TYPE_IP_PROTOCOL, 0x80, 0x06,
413: FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
414: FLOW_TYPE_TCP_FLAGS, 0x80, 0x55
415: };
416:
417: net_addr_flow4 *expect;
418: NET_ADDR_FLOW4_(expect, ip4_build(5, 6, 7, 0), 24, nlri);
419:
420: /* Normal order */
421:
422: net_addr_ip4 n1;
423: net_fill_ip4((net_addr *) &n1, ip4_build(5,6,7,0), 24);
424: flow_builder_set_type(fb, FLOW_TYPE_DST_PREFIX);
425: flow_builder4_add_pfx(fb, &n1);
426:
427: net_addr_ip4 n2;
428: net_fill_ip4((net_addr *) &n2, ip4_build(10,11,12,13), 32);
429: flow_builder_set_type(fb, FLOW_TYPE_SRC_PREFIX);
430: flow_builder4_add_pfx(fb, &n2);
431:
432: flow_builder_set_type(fb, FLOW_TYPE_IP_PROTOCOL);
433: flow_builder_add_op_val(fb, 0, 0x06);
434:
435: flow_builder_set_type(fb, FLOW_TYPE_PORT);
436: flow_builder_add_op_val(fb, 0x03, 0x89);
437: flow_builder_add_op_val(fb, 0x45, 0x8b);
438: flow_builder_add_op_val(fb, 0x01, 0x1f90);
439:
440: /* Try put a component twice time */
441: flow_builder_set_type(fb, FLOW_TYPE_IP_PROTOCOL);
442: flow_builder_add_op_val(fb, 0, 0x06);
443:
444: flow_builder_set_type(fb, FLOW_TYPE_TCP_FLAGS);
445: flow_builder_add_op_val(fb, 0, 0x55);
446:
447: net_addr_flow4 *res = flow_builder4_finalize(fb, lp);
448:
449: bt_assert(memcmp(res, expect, expect->length) == 0);
450:
451: /* Reverse order */
452:
453: flow_builder_clear(fb);
454:
455: flow_builder_set_type(fb, FLOW_TYPE_TCP_FLAGS);
456: flow_builder_add_op_val(fb, 0, 0x55);
457:
458: flow_builder_set_type(fb, FLOW_TYPE_PORT);
459: flow_builder_add_op_val(fb, 0x03, 0x89);
460: flow_builder_add_op_val(fb, 0x45, 0x8b);
461: flow_builder_add_op_val(fb, 0x01, 0x1f90);
462:
463: flow_builder_set_type(fb, FLOW_TYPE_IP_PROTOCOL);
464: flow_builder_add_op_val(fb, 0, 0x06);
465:
466: net_fill_ip4((net_addr *) &n2, ip4_build(10,11,12,13), 32);
467: flow_builder_set_type(fb, FLOW_TYPE_SRC_PREFIX);
468: flow_builder4_add_pfx(fb, &n2);
469:
470: net_fill_ip4((net_addr *) &n1, ip4_build(5,6,7,0), 24);
471: flow_builder_set_type(fb, FLOW_TYPE_DST_PREFIX);
472: flow_builder4_add_pfx(fb, &n1);
473:
474: bt_assert(memcmp(res, expect, expect->length) == 0);
475:
476: return 1;
477: }
478:
479: static int
480: t_builder6(void)
481: {
482: net_addr_ip6 ip;
483:
484: resource_init();
485: linpool *lp = lp_new_default(&root_pool);
486: struct flow_builder *fb = flow_builder_init(&root_pool);
487: fb->ipv6 = 1;
488:
489: /* Expectation */
490:
491: byte nlri[] = {
492: 27,
493: FLOW_TYPE_DST_PREFIX, 103, 61, 0x01, 0x12, 0x34, 0x56, 0x78, 0x98,
494: FLOW_TYPE_SRC_PREFIX, 8, 0, 0xc0,
495: FLOW_TYPE_NEXT_HEADER, 0x80, 0x06,
496: FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
497: FLOW_TYPE_LABEL, 0x80, 0x55,
498: };
499:
500: net_addr_flow6 *expect;
501: NET_ADDR_FLOW6_(expect, ip6_build(0, 1, 0x12345678, 0x98000000), 103, nlri);
502:
503: /* Normal order */
504:
505: net_fill_ip6((net_addr *) &ip, ip6_build(0, 1, 0x12345678, 0x98000000), 103);
506: flow_builder_set_type(fb, FLOW_TYPE_DST_PREFIX);
507: flow_builder6_add_pfx(fb, &ip, 61);
508:
509: /* Try put a component twice time */
510: net_fill_ip6((net_addr *) &ip, ip6_build(0, 1, 0x12345678, 0x98000000), 103);
511: flow_builder_set_type(fb, FLOW_TYPE_DST_PREFIX);
512: bt_assert(flow_builder6_add_pfx(fb, &ip, 61) == 0);
513:
514: net_fill_ip6((net_addr *) &ip, ip6_build(0xc0000000,0,0,0), 8);
515: flow_builder_set_type(fb, FLOW_TYPE_SRC_PREFIX);
516: flow_builder6_add_pfx(fb, &ip, 0);
517:
518: flow_builder_set_type(fb, FLOW_TYPE_NEXT_HEADER);
519: flow_builder_add_op_val(fb, 0, 0x06);
520:
521: flow_builder_set_type(fb, FLOW_TYPE_PORT);
522: flow_builder_add_op_val(fb, 0x03, 0x89);
523: flow_builder_add_op_val(fb, 0x45, 0x8b);
524: flow_builder_add_op_val(fb, 0x01, 0x1f90);
525:
526: flow_builder_set_type(fb, FLOW_TYPE_LABEL);
527: flow_builder_add_op_val(fb, 0, 0x55);
528:
529: net_addr_flow6 *res = flow_builder6_finalize(fb, lp);
530: bt_assert(memcmp(res, expect, expect->length) == 0);
531:
532: /* Reverse order */
533:
534: flow_builder_clear(fb);
535: fb->ipv6 = 1;
536:
537: flow_builder_set_type(fb, FLOW_TYPE_LABEL);
538: flow_builder_add_op_val(fb, 0, 0x55);
539:
540: flow_builder_set_type(fb, FLOW_TYPE_PORT);
541: flow_builder_add_op_val(fb, 0x03, 0x89);
542: flow_builder_add_op_val(fb, 0x45, 0x8b);
543: flow_builder_add_op_val(fb, 0x01, 0x1f90);
544:
545: flow_builder_set_type(fb, FLOW_TYPE_NEXT_HEADER);
546: flow_builder_add_op_val(fb, 0, 0x06);
547:
548: net_fill_ip6((net_addr *) &ip, ip6_build(0xc0000000,0,0,0), 8);
549: flow_builder_set_type(fb, FLOW_TYPE_SRC_PREFIX);
550: flow_builder6_add_pfx(fb, &ip, 0);
551:
552: net_fill_ip6((net_addr *) &ip, ip6_build(0, 1, 0x12345678, 0x98000000), 103);
553: flow_builder_set_type(fb, FLOW_TYPE_DST_PREFIX);
554: flow_builder6_add_pfx(fb, &ip, 61);
555:
556: res = flow_builder6_finalize(fb, lp);
557: bt_assert(memcmp(res, expect, expect->length) == 0);
558:
559: return 1;
560: }
561:
562: static int
563: t_formatting4(void)
564: {
565: char b[1024];
566:
567: byte nlri[] = {
568: 0,
569: FLOW_TYPE_DST_PREFIX, 0x08, 10,
570: FLOW_TYPE_IP_PROTOCOL, 0x81, 23,
571: FLOW_TYPE_DST_PORT, 0x02, 24, 0x44, 30, 0x03, 40, 0x45, 50, 0x03, 60, 0x45, 70, 0x01, 80, 0xc3, 90,
572: FLOW_TYPE_SRC_PORT, 0x02, 24, 0x44, 0x1e, 0x01, 0x28, 0x01, 0x32, 0x03, 0x3c, 0x45, 0x46, 0x81, 0x50,
573: FLOW_TYPE_ICMP_TYPE, 0x81, 0x50,
574: FLOW_TYPE_ICMP_CODE, 0x81, 0x5a,
575: FLOW_TYPE_TCP_FLAGS, 0x01, 0x03, 0xc2, 0x0c,
576: FLOW_TYPE_PACKET_LENGTH, 0x03, 0, 0xd5, 0xff, 0xff,
577: FLOW_TYPE_DSCP, 0x81, 63,
578: FLOW_TYPE_FRAGMENT, 0x01, 0x01, 0x82, 0x02
579: };
580: *nlri = (u8) sizeof(nlri);
581:
582: net_addr_flow4 *input;
583: NET_ADDR_FLOW4_(input, ip4_build(5, 6, 7, 0), 24, nlri);
584:
585: const char *expect = "flow4 { dst 10.0.0.0/8; proto 23; dport > 24 && < 30 || 40..50,60..70,80 && >= 90; sport > 24 && < 30 || 40,50,60..70,80; icmp type 80; icmp code 90; tcp flags 0x3/0x3,0x0/0xc; length 0..65535; dscp 63; fragment dont_fragment || !is_fragment; }";
586:
587: bt_assert(flow4_net_format(b, sizeof(b), input) == strlen(expect));
588: bt_debug(" expect: '%s',\n output: '%s'\n", expect, b);
589: bt_assert(strcmp(b, expect) == 0);
590:
591: return 1;
592: }
593:
594: static int
595: t_formatting6(void)
596: {
597: char b[1024];
598:
599: byte nlri[] = {
600: 0,
601: FLOW_TYPE_DST_PREFIX, 103, 61, 0x01, 0x12, 0x34, 0x56, 0x78, 0x98,
602: FLOW_TYPE_SRC_PREFIX, 8, 0, 0xc0,
603: FLOW_TYPE_NEXT_HEADER, 0x81, 0x06,
604: FLOW_TYPE_PORT, 0x03, 20, 0x45, 40, 0x91, 0x01, 0x11,
605: FLOW_TYPE_LABEL, 0xa0, 0x12, 0x34, 0x56, 0x78,
606: };
607: *nlri = (u8) sizeof(nlri);
608:
609: net_addr_flow6 *input;
610: NET_ADDR_FLOW6_(input, ip6_build(0, 1, 0x12345678, 0x98000000), 103, nlri);
611:
612: const char *expect = "flow6 { dst ::1:1234:5678:9800:0/103 offset 61; src c000::/8; next header 6; port 20..40,273; label !0x0/0x12345678; }";
613:
614: bt_assert(flow6_net_format(b, sizeof(b), input) == strlen(expect));
615: bt_debug(" expect: '%s',\n output: '%s'\n", expect, b);
616: bt_assert(strcmp(b, expect) == 0);
617:
618: return 1;
619: }
620:
621: int
622: main(int argc, char *argv[])
623: {
624: bt_init(argc, argv);
625:
626: bt_test_suite(t_read_length, "Testing get NLRI length");
627: bt_test_suite(t_write_length, "Testing set NLRI length");
628: bt_test_suite(t_first_part, "Searching first part in net_addr_flow");
629: bt_test_suite(t_iterators4, "Testing iterators (IPv4)");
630: bt_test_suite(t_iterators6, "Testing iterators (IPv6)");
631: bt_test_suite(t_validation4, "Testing validation (IPv4)");
632: bt_test_suite(t_validation6, "Testing validation (IPv6)");
633: bt_test_suite(t_builder4, "Inserting components into existing Flow Specification (IPv4)");
634: bt_test_suite(t_builder6, "Inserting components into existing Flow Specification (IPv6)");
635: bt_test_suite(t_formatting4, "Formatting Flow Specification (IPv4) into text representation");
636: bt_test_suite(t_formatting6, "Formatting Flow Specification (IPv6) into text representation");
637:
638: return bt_exit_value();
639: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to flowspec_test.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / lib