63 #define DEFAULT_DEFRAG_HASH_SIZE 0xffff
64 #define DEFAULT_DEFRAG_POOL_SIZE 0xffff
70 #define TIMEOUT_DEFAULT 60
75 #define TIMEOUT_MAX (60 * 60 * 24)
107 DefragFragReset(
Frag *frag)
109 if (frag->
pkt != NULL)
111 memset(frag, 0,
sizeof(*frag));
127 DefragFragReset(frag);
141 DefragContextNew(
void)
150 intmax_t tracker_pool_size;
151 if (!
SCConfGetInt(
"defrag.trackers", &tracker_pool_size) || tracker_pool_size == 0) {
156 intmax_t frag_pool_size;
157 if (!
SCConfGetInt(
"defrag.max-frags", &frag_pool_size) || frag_pool_size == 0 ||
158 frag_pool_size > UINT32_MAX) {
161 uint32_t frag_pool_prealloc = (uint32_t)frag_pool_size / 2;
163 PoolInit((uint32_t)frag_pool_size, frag_pool_prealloc,
sizeof(
Frag), NULL, NULL, NULL);
165 FatalError(
"Defrag: Failed to initialize fragment pool.");
168 FatalError(
"Defrag: Failed to initialize frag pool mutex.");
177 FatalError(
"defrag: Timeout less than minimum allowed value.");
180 FatalError(
"defrag: Timeout greater than maximum allowed value.");
182 dc->
timeout = (uint32_t)timeout;
187 SCLogDebug(
"\tMaximum defrag trackers: %"PRIuMAX, tracker_pool_size);
188 SCLogDebug(
"\tPreallocated defrag trackers: %"PRIuMAX, tracker_pool_size);
189 SCLogDebug(
"\tMaximum fragments: %"PRIuMAX, (uintmax_t)frag_pool_size);
190 SCLogDebug(
"\tPreallocated fragments: %"PRIuMAX, (uintmax_t)frag_pool_prealloc);
224 }
else if (first->
offset != 0) {
229 goto error_remove_tracker;
248 const IPV4Hdr *oip4h = PacketGetIPv4(
p);
254 goto error_remove_tracker;
260 int fragmentable_offset = 0;
261 uint16_t fragmentable_len = 0;
263 int ip_hdr_offset = 0;
266 uint16_t prev_offset = 0;
270 SCLogDebug(
"frag %p, data_len %u, offset %u, pcap_cnt %"PRIu64,
275 if (!more_frags && frag->
offset > prev_offset) {
286 goto error_remove_tracker;
298 int pkt_end = fragmentable_offset + frag->
offset + frag->
data_len;
301 "fragmented packet, exceeds size of packet buffer.");
302 goto error_remove_tracker;
308 goto error_remove_tracker;
312 "fragmentable_len exceeds UINT16_MAX");
313 goto error_remove_tracker;
328 prev_offset = frag->
offset;
331 SCLogDebug(
"ip_hdr_offset %u, hlen %" PRIu16
", fragmentable_len %" PRIu16, ip_hdr_offset, hlen,
334 const uint32_t packet_len = (uint32_t)hlen + fragmentable_len;
337 goto error_remove_tracker;
342 ip4h->
ip_len = htons((uint16_t)packet_len);
352 error_remove_tracker:
378 }
else if (first->
offset != 0) {
383 goto error_remove_tracker;
413 const IPV6Hdr *oip6h = PacketGetIPv6(
p);
420 goto error_remove_tracker;
426 uint16_t unfragmentable_len = 0;
427 int fragmentable_offset = 0;
428 uint16_t fragmentable_len = 0;
429 int ip_hdr_offset = 0;
430 uint8_t next_hdr = 0;
433 uint16_t prev_offset = 0;
437 if (!more_frags && frag->
offset > prev_offset) {
445 IPV6FragHdr *frag_hdr = (IPV6FragHdr *)(frag->
pkt +
447 next_hdr = frag_hdr->ip6fh_nxt;
453 goto error_remove_tracker;
457 goto error_remove_tracker;
471 unfragmentable_len = (uint16_t)(fragmentable_offset - ip_hdr_offset -
IPV6_HEADER_LEN);
472 if (unfragmentable_len >= fragmentable_offset)
473 goto error_remove_tracker;
479 goto error_remove_tracker;
493 prev_offset = frag->
offset;
496 const uint32_t
payload_len = (uint32_t)unfragmentable_len + fragmentable_len;
499 goto error_remove_tracker;
508 if (unfragmentable_len == 0)
509 ip6h->s_ip6_nxt = next_hdr;
517 error_remove_tracker:
546 static void DefragBsdTrimFollowing(
549 while ((
next != NULL) && (frag_end >
next->offset)) {
550 Frag *following = IP_FRAGMENTS_RB_NEXT(
next);
551 if (
next->offset <= frag_offset) {
556 uint16_t next_ltrim = frag_end -
next->offset;
557 if (next_ltrim >=
next->data_len) {
559 DefragFragReset(
next);
563 }
else if (next_ltrim >
next->ltrim) {
564 next->ltrim = next_ltrim;
582 uint16_t frag_offset;
589 uint16_t data_offset;
599 uint16_t ip_hdr_offset;
602 uint16_t frag_hdr_offset = 0;
605 int af = tracker->
af;
609 uint32_t ip6_nh_set_offset = 0;
610 uint8_t ip6_nh_set_value = 0;
616 if (tracker->
af == AF_INET) {
617 const IPV4Hdr *ip4h = PacketGetIPv4(
p);
621 data_offset = (uint16_t)((uint8_t *)ip4h + hlen -
GET_PKT_DATA(
p));
623 ip_hdr_offset = (uint16_t)((uint8_t *)ip4h -
GET_PKT_DATA(
p));
632 frag_end = (uint16_t)(frag_offset + data_len);
634 else if (tracker->
af == AF_INET6) {
635 const IPV6Hdr *ip6h = PacketGetIPv6(
p);
638 data_offset =
p->
l3.
vars.
ip6.eh.fh_data_offset;
648 frag_end = (uint16_t)(frag_offset + data_len);
649 ip_hdr_offset = (uint16_t)((uint8_t *)ip6h -
GET_PKT_DATA(
p));
650 frag_hdr_offset =
p->
l3.
vars.
ip6.eh.fh_header_offset;
652 SCLogDebug(
"mf %s frag_offset %u data_offset %u, data_len %u, "
653 "frag_end %u, ip_hdr_offset %u, frag_hdr_offset %u",
654 more_frags ?
"true" :
"false", frag_offset, data_offset,
655 data_len, frag_end, ip_hdr_offset, frag_hdr_offset);
659 SCLogDebug(
"we have exthdrs before fraghdr %u bytes",
666 ip6_nh_set_offset =
p->
l3.
vars.
ip6.eh.fh_prev_hdr_offset;
668 SCLogDebug(
"offset %d, value %u", ip6_nh_set_offset, ip6_nh_set_value);
680 bool overlap =
false;
685 .
offset = frag_offset ? frag_offset - 1 : 0,
690 next = IP_FRAGMENTS_RB_NEXT(prev);
692 prev = IP_FRAGMENTS_RB_PREV(
next);
695 next = IP_FRAGMENTS_RB_NEXT(prev);
698 while (prev != NULL) {
706 switch (tracker->
policy) {
709 if (prev->
offset <= frag_offset) {
715 if (prev_end > frag_end) {
720 ltrim = prev_end - frag_offset;
722 DefragBsdTrimFollowing(tracker,
next, frag_offset, frag_end);
736 uint16_t prev_ltrim = frag_end - prev->
offset;
737 if (prev_ltrim > prev->
ltrim) {
738 prev->
ltrim = prev_ltrim;
742 DefragBsdTrimFollowing(tracker,
next, frag_offset, frag_end);
755 if (prev->
offset + prev->
ltrim < frag_offset + ltrim &&
768 if (frag_offset + ltrim < prev->
offset + prev->
ltrim &&
779 if (frag_offset + ltrim <= prev->
offset + prev->
ltrim &&
788 if (frag_offset + ltrim >= prev->
offset + ltrim &&
795 if (frag_offset + ltrim < prev->
offset + ltrim &&
808 if (frag_offset + ltrim > prev->
offset + prev->
ltrim &&
817 if (frag_offset + ltrim == prev->
offset + ltrim &&
825 if (frag_offset >= prev->
offset) {
828 if ((frag_offset < prev->
offset) &&
836 if ((frag_offset >= prev->
offset) &&
840 if (frag_offset < prev->
offset) {
849 if (frag_offset <= prev->
offset) {
850 if (frag_end > prev->
offset) {
873 DefragFragReset(prev);
882 if (ltrim >= data_len) {
898 if (
tv != NULL &&
dtv != NULL) {
901 goto error_remove_tracker;
904 if (new->pkt == NULL) {
913 goto error_remove_tracker;
920 if (ip6_nh_set_offset > 0 && frag_offset == 0 && ltrim == 0) {
921 if (new->len > ip6_nh_set_offset) {
922 SCLogDebug(
"updating frag to have 'correct' nh value: %u -> %u",
923 new->pkt[ip6_nh_set_offset], ip6_nh_set_value);
924 new->pkt[ip6_nh_set_offset] = ip6_nh_set_value;
929 new->offset = frag_offset + ltrim;
930 new->data_offset = data_offset;
931 new->data_len = data_len - ltrim;
932 new->frag_hdr_offset = frag_hdr_offset;
933 new->more_frags = more_frags;
935 new->pcap_cnt = pcap_cnt;
937 if (new->offset == 0) {
949 if (tracker->
af == AF_INET) {
950 r = Defrag4Reassemble(
tv, tracker,
p);
951 if (r != NULL &&
tv != NULL &&
dtv != NULL) {
955 else if (tracker->
af == AF_INET6) {
956 r = Defrag6Reassemble(
tv, tracker,
p);
957 if (r != NULL &&
tv != NULL &&
dtv != NULL) {
974 error_remove_tracker:
993 if (PacketIsIPv4(
p)) {
995 }
else if (PacketIsIPv6(
p)) {
1000 return default_policy;
1043 return default_policy;
1069 uint16_t frag_offset;
1074 if (PacketIsIPv4(
p)) {
1075 const IPV4Hdr *ip4h = PacketGetIPv4(
p);
1079 }
else if (PacketIsIPv6(
p)) {
1087 if (frag_offset == 0 && more_frags == 0) {
1091 if (
af == AF_INET) {
1093 }
else if (
af == AF_INET6) {
1098 tracker = DefragGetTracker(
tv,
dtv,
p);
1099 if (tracker == NULL) {
1100 if (
tv != NULL &&
dtv != NULL) {
1111 int tracker_af = tracker->
af;
1120 const uint32_t
len =
GET_PKT_LEN(rp) - (uint32_t)tracker_ip_hdr_offset;
1122 if (tracker_af == AF_INET) {
1144 intmax_t tracker_pool_size;
1145 if (!
SCConfGetInt(
"defrag.trackers", &tracker_pool_size)) {
1153 defrag_context = DefragContextNew();
1154 if (defrag_context == NULL) {
1155 FatalError(
"Failed to allocate memory for the Defrag module.");
1165 DefragContextDestroy(defrag_context);
1166 defrag_context = NULL;
1174 #define IP_MF 0x2000
1183 static Packet *BuildIpv4TestPacket(
1184 uint8_t
proto, uint16_t
id, uint16_t off,
int mf,
const char content,
int content_len)
1201 struct timeval tval;
1202 gettimeofday(&tval, NULL);
1207 ip4h.
ip_len = htons(hlen + content_len);
1208 ip4h.
ip_id = htons(
id);
1212 ip4h.
ip_off = htons(off);
1216 ip4h.s_ip_src.s_addr = 0x01010101;
1217 ip4h.s_ip_dst.s_addr = 0x02020202;
1225 pcontent =
SCCalloc(1, content_len);
1228 memset(pcontent, content, content_len);
1252 static int BuildIpv4TestPacketWithContent(
Packet **packet, uint8_t
proto, uint16_t
id, uint16_t off,
1253 int mf,
const uint8_t *content,
int content_len)
1265 struct timeval tval;
1266 gettimeofday(&tval, NULL);
1270 ip4h.
ip_len = htons(hlen + content_len);
1271 ip4h.
ip_id = htons(
id);
1275 ip4h.
ip_off = htons(off);
1279 ip4h.s_ip_src.s_addr = 0x01010101;
1280 ip4h.s_ip_dst.s_addr = 0x02020202;
1307 static Packet *BuildIpv6TestPacket(
1308 uint8_t
proto, uint32_t
id, uint16_t off,
int mf,
const uint8_t content,
int content_len)
1323 struct timeval tval;
1324 gettimeofday(&tval, NULL);
1327 ip6h.s_ip6_nxt = 44;
1328 ip6h.s_ip6_hlim = 2;
1331 ip6h.s_ip6_src[0] = 0x01010101;
1332 ip6h.s_ip6_src[1] = 0x01010101;
1333 ip6h.s_ip6_src[2] = 0x01010101;
1334 ip6h.s_ip6_src[3] = 0x01010101;
1335 ip6h.s_ip6_dst[0] = 0x02020202;
1336 ip6h.s_ip6_dst[1] = 0x02020202;
1337 ip6h.s_ip6_dst[2] = 0x02020202;
1338 ip6h.s_ip6_dst[3] = 0x02020202;
1347 fh->ip6fh_nxt =
proto;
1348 fh->ip6fh_ident = htonl(
id);
1349 fh->ip6fh_offlg = htons((off << 3) | mf);
1353 pcontent =
SCCalloc(1, content_len);
1356 memset(pcontent, content, content_len);
1361 ip6p->s_ip6_plen = htons(
sizeof(IPV6FragHdr) + content_len);
1381 static Packet *BuildIpv6TestPacketWithContent(
1382 uint8_t
proto, uint32_t
id, uint16_t off,
int mf,
const uint8_t *content,
int content_len)
1396 struct timeval tval;
1397 gettimeofday(&tval, NULL);
1400 ip6h.s_ip6_nxt = 44;
1401 ip6h.s_ip6_hlim = 2;
1404 ip6h.s_ip6_src[0] = 0x01010101;
1405 ip6h.s_ip6_src[1] = 0x01010101;
1406 ip6h.s_ip6_src[2] = 0x01010101;
1407 ip6h.s_ip6_src[3] = 0x01010101;
1408 ip6h.s_ip6_dst[0] = 0x02020202;
1409 ip6h.s_ip6_dst[1] = 0x02020202;
1410 ip6h.s_ip6_dst[2] = 0x02020202;
1411 ip6h.s_ip6_dst[3] = 0x02020202;
1420 fh->ip6fh_nxt =
proto;
1421 fh->ip6fh_ident = htonl(
id);
1422 fh->ip6fh_offlg = htons((off << 3) | mf);
1429 ip6p->s_ip6_plen = htons(
sizeof(IPV6FragHdr) + content_len);
1453 static int DefragInOrderSimpleTest(
void)
1455 Packet *p1 = NULL, *p2 = NULL, *p3 = NULL;
1456 Packet *reassembled = NULL;
1461 p1 = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 0, 1,
'A', 8);
1463 p2 = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 1, 1,
'B', 8);
1465 p3 = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 2, 0,
'C', 3);
1478 for (
int i = 20; i < 20 + 8; i++) {
1483 for (
int i = 28; i < 28 + 8; i++) {
1488 for (
int i = 36; i < 36 + 3; i++) {
1504 static int DefragReverseSimpleTest(
void)
1506 Packet *p1 = NULL, *p2 = NULL, *p3 = NULL;
1507 Packet *reassembled = NULL;
1512 p1 = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 0, 1,
'A', 8);
1514 p2 = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 1, 1,
'B', 8);
1516 p3 = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 2, 0,
'C', 3);
1528 for (
int i = 20; i < 20 + 8; i++) {
1533 for (
int i = 28; i < 28 + 8; i++) {
1538 for (
int i = 36; i < 36 + 3; i++) {
1555 static int DefragInOrderSimpleIpv6Test(
void)
1557 Packet *p1 = NULL, *p2 = NULL, *p3 = NULL;
1558 Packet *reassembled = NULL;
1563 p1 = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 0, 1,
'A', 8);
1565 p2 = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 1, 1,
'B', 8);
1567 p3 = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 2, 0,
'C', 3);
1575 const IPV6Hdr *ip6h = PacketGetIPv6(reassembled);
1579 for (
int i = 40; i < 40 + 8; i++) {
1584 for (
int i = 48; i < 48 + 8; i++) {
1589 for (
int i = 56; i < 56 + 3; i++) {
1602 static int DefragReverseSimpleIpv6Test(
void)
1605 Packet *p1 = NULL, *p2 = NULL, *p3 = NULL;
1606 Packet *reassembled = NULL;
1611 dc = DefragContextNew();
1614 p1 = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 0, 1,
'A', 8);
1616 p2 = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 1, 1,
'B', 8);
1618 p3 = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 2, 0,
'C', 3);
1627 for (
int i = 40; i < 40 + 8; i++) {
1632 for (
int i = 48; i < 48 + 8; i++) {
1637 for (
int i = 56; i < 56 + 3; i++) {
1641 DefragContextDestroy(dc);
1651 static int DefragDoSturgesNovakTest(
int policy, uint8_t *expected,
size_t expected_len)
1663 memset(packets, 0x00,
sizeof(packets));
1670 packets[0] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 0, 1,
'A', 24);
1673 packets[1] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 32 >> 3, 1,
'B', 16);
1676 packets[2] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 48 >> 3, 1,
'C', 24);
1679 packets[3] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 80 >> 3, 1,
'D', 8);
1682 packets[4] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 104 >> 3, 1,
'E', 16);
1685 packets[5] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 120 >> 3, 1,
'F', 24);
1688 packets[6] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 144 >> 3, 1,
'G', 16);
1691 packets[7] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 160 >> 3, 1,
'H', 16);
1694 packets[8] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 176 >> 3, 1,
'I', 8);
1701 packets[9] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 8 >> 3, 1,
'J', 32);
1704 packets[10] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 48 >> 3, 1,
'K', 24);
1707 packets[11] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 72 >> 3, 1,
'L', 24);
1710 packets[12] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 96 >> 3, 1,
'M', 24);
1713 packets[13] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 128 >> 3, 1,
'N', 8);
1716 packets[14] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 152 >> 3, 1,
'O', 8);
1719 packets[15] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 160 >> 3, 1,
'P', 8);
1722 packets[16] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 176 >> 3, 0,
'Q', 16);
1724 default_policy = policy;
1727 for (i = 0; i < 9; i++) {
1733 for (; i < 16; i++) {
1750 if (memcmp(expected,
GET_PKT_DATA(reassembled) + 20, expected_len) != 0) {
1751 printf(
"Expected:\n");
1762 for (i = 0; i < 17; i++) {
1769 static int DefragDoSturgesNovakIpv6Test(
int policy, uint8_t *expected,
size_t expected_len)
1781 memset(packets, 0x00,
sizeof(packets));
1788 packets[0] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 0, 1,
'A', 24);
1791 packets[1] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 32 >> 3, 1,
'B', 16);
1794 packets[2] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 48 >> 3, 1,
'C', 24);
1797 packets[3] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 80 >> 3, 1,
'D', 8);
1800 packets[4] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 104 >> 3, 1,
'E', 16);
1803 packets[5] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 120 >> 3, 1,
'F', 24);
1806 packets[6] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 144 >> 3, 1,
'G', 16);
1809 packets[7] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 160 >> 3, 1,
'H', 16);
1812 packets[8] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 176 >> 3, 1,
'I', 8);
1819 packets[9] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 8 >> 3, 1,
'J', 32);
1822 packets[10] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 48 >> 3, 1,
'K', 24);
1825 packets[11] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 72 >> 3, 1,
'L', 24);
1828 packets[12] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 96 >> 3, 1,
'M', 24);
1831 packets[13] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 128 >> 3, 1,
'N', 8);
1834 packets[14] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 152 >> 3, 1,
'O', 8);
1837 packets[15] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 160 >> 3, 1,
'P', 8);
1840 packets[16] = BuildIpv6TestPacket(IPPROTO_ICMPV6,
id, 176 >> 3, 0,
'Q', 16);
1842 default_policy = policy;
1845 for (i = 0; i < 9; i++) {
1851 for (; i < 16; i++) {
1872 for (i = 0; i < 17; i++) {
1887 #define D_1 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A'
1888 #define D_2 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B'
1889 #define D_3 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C'
1890 #define D_3_1 'D', 'D', 'D', 'D', 'D', 'D', 'D', 'D'
1891 #define D_3_2 'E', 'E', 'E', 'E', 'E', 'E', 'E', 'E'
1892 #define D_3_3 'F', 'F', 'F', 'F', 'F', 'F', 'F', 'F'
1893 #define D_3_4 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G'
1894 #define D_3_5 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H'
1895 #define D_3_6 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I'
1896 #define D_4 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J'
1897 #define D_5 'K', 'K', 'K', 'K', 'K', 'K', 'K', 'K'
1898 #define D_6 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L'
1899 #define D_7 'M', 'M', 'M', 'M', 'M', 'M', 'M', 'M'
1900 #define D_8 'N', 'N', 'N', 'N', 'N', 'N', 'N', 'N'
1901 #define D_9 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'
1902 #define D_10 'P', 'P', 'P', 'P', 'P', 'P', 'P', 'P'
1903 #define D_11 'Q', 'Q', 'Q', 'Q', 'Q', 'Q', 'Q', 'Q'
1906 DefragSturgesNovakBsdTest(
void)
1909 uint8_t expected[] = {
1941 static int DefragSturgesNovakBsdIpv6Test(
void)
1944 uint8_t expected[] = {
1975 static int DefragSturgesNovakLinuxIpv4Test(
void)
1978 uint8_t expected[] = {
2010 static int DefragSturgesNovakLinuxIpv6Test(
void)
2013 uint8_t expected[] = {
2044 static int DefragSturgesNovakWindowsIpv4Test(
void)
2047 uint8_t expected[] = {
2079 static int DefragSturgesNovakWindowsIpv6Test(
void)
2082 uint8_t expected[] = {
2113 static int DefragSturgesNovakSolarisTest(
void)
2116 uint8_t expected[] = {
2148 static int DefragSturgesNovakSolarisIpv6Test(
void)
2151 uint8_t expected[] = {
2182 static int DefragSturgesNovakFirstTest(
void)
2185 uint8_t expected[] = {
2217 static int DefragSturgesNovakFirstIpv6Test(
void)
2220 uint8_t expected[] = {
2251 DefragSturgesNovakLastTest(
void)
2254 uint8_t expected[] = {
2286 static int DefragSturgesNovakLastIpv6Test(
void)
2289 uint8_t expected[] = {
2320 static int DefragTimeoutTest(
void)
2330 for (i = 0; i < 16; i++) {
2331 Packet *
p = BuildIpv4TestPacket(IPPROTO_ICMP, i, 0, 1,
'A' + i, 16);
2341 Packet *
p = BuildIpv4TestPacket(IPPROTO_ICMP, 99, 0, 1,
'A' + i, 16);
2366 static int DefragNoDataIpv4Test(
void)
2374 dc = DefragContextNew();
2378 p = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 1, 0,
'A', 0);
2388 DefragContextDestroy(dc);
2395 static int DefragTooLargeIpv4Test(
void)
2402 dc = DefragContextNew();
2407 p = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 8183, 0,
'A', 71);
2420 DefragContextDestroy(dc);
2432 static int DefragVlanTest(
void)
2434 Packet *p1 = NULL, *p2 = NULL, *r = NULL;
2438 p1 = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 0, 1,
'A', 8);
2440 p2 = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 1, 0,
'B', 8);
2464 static int DefragVlanQinQTest(
void)
2466 Packet *p1 = NULL, *p2 = NULL, *r = NULL;
2470 p1 = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 0, 1,
'A', 8);
2472 p2 = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 1, 0,
'B', 8);
2498 static int DefragVlanQinQinQTest(
void)
2504 Packet *p1 = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 0, 1,
'A', 8);
2506 Packet *p2 = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 1, 0,
'B', 8);
2530 static int DefragTrackerReuseTest(
void)
2540 p1 = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 0, 0,
'A', 8);
2553 FAIL_IF(tracker2 != tracker1);
2566 FAIL_IF(tracker2 != tracker1);
2583 static int DefragMfIpv4Test(
void)
2590 Packet *p1 = BuildIpv4TestPacket(IPPROTO_ICMP, ip_id, 2, 1,
'C', 8);
2591 Packet *p2 = BuildIpv4TestPacket(IPPROTO_ICMP, ip_id, 0, 1,
'A', 8);
2592 Packet *p3 = BuildIpv4TestPacket(IPPROTO_ICMP, ip_id, 1, 0,
'B', 8);
2593 FAIL_IF(p1 == NULL || p2 == NULL || p3 == NULL);
2610 uint8_t expected_payload[] =
"AAAAAAAABBBBBBBB";
2630 static int DefragMfIpv6Test(
void)
2637 Packet *p1 = BuildIpv6TestPacket(IPPROTO_ICMPV6, ip_id, 2, 1,
'C', 8);
2638 Packet *p2 = BuildIpv6TestPacket(IPPROTO_ICMPV6, ip_id, 0, 1,
'A', 8);
2639 Packet *p3 = BuildIpv6TestPacket(IPPROTO_ICMPV6, ip_id, 1, 0,
'B', 8);
2640 FAIL_IF(p1 == NULL || p2 == NULL || p3 == NULL);
2657 uint8_t expected_payload[] =
"AAAAAAAABBBBBBBB";
2672 static int DefragTestBadProto(
void)
2674 Packet *p1 = NULL, *p2 = NULL, *p3 = NULL;
2679 p1 = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 0, 1,
'A', 8);
2681 p2 = BuildIpv4TestPacket(IPPROTO_UDP,
id, 1, 1,
'B', 8);
2683 p3 = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 2, 0,
'C', 3);
2702 static int DefragTestJeremyLinux(
void)
2705 uint8_t expected[] =
"AAAAAAAA"
2726 packets[0] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 0, 1,
'A', 24);
2727 packets[1] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 40 >> 3, 1,
'B', 48);
2728 packets[2] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 24 >> 3, 1,
'C', 48);
2729 packets[3] = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 88 >> 3, 0,
'D', 14);
2745 for (i = 0; i < 4; i++) {
2764 static int DefragBsdFragmentAfterNoMfIpv4Test(
void)
2770 packets[0] = BuildIpv4TestPacket(IPPROTO_ICMP, 0x96, 24 >> 3, 0,
'A', 16);
2771 packets[1] = BuildIpv4TestPacket(IPPROTO_ICMP, 0x96, 8 >> 3, 1,
'B', 16);
2772 packets[2] = BuildIpv4TestPacket(IPPROTO_ICMP, 0x96, 16 >> 3, 1,
'C', 16);
2773 packets[3] = BuildIpv4TestPacket(IPPROTO_ICMP, 0x96, 0, 1,
'D', 8);
2788 uint8_t expected[] = {
2789 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
2790 'B',
'B',
'B',
'B',
'B',
'B',
'B',
'B',
2791 'B',
'B',
'B',
'B',
'B',
'B',
'B',
'B',
2792 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
2793 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
2797 if (memcmp(expected,
GET_PKT_DATA(r) + 20,
sizeof(expected)) != 0) {
2798 printf(
"Expected:\n");
2805 for (
int i = 0; i < 4; i++) {
2813 static int DefragBsdFragmentAfterNoMfIpv6Test(
void)
2819 packets[0] = BuildIpv6TestPacket(IPPROTO_ICMP, 0x96, 24 >> 3, 0,
'A', 16);
2820 packets[1] = BuildIpv6TestPacket(IPPROTO_ICMP, 0x96, 8 >> 3, 1,
'B', 16);
2821 packets[2] = BuildIpv6TestPacket(IPPROTO_ICMP, 0x96, 16 >> 3, 1,
'C', 16);
2822 packets[3] = BuildIpv6TestPacket(IPPROTO_ICMP, 0x96, 0, 1,
'D', 8);
2837 uint8_t expected[] = {
2838 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
2839 'B',
'B',
'B',
'B',
'B',
'B',
'B',
'B',
2840 'B',
'B',
'B',
'B',
'B',
'B',
'B',
'B',
2841 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
2842 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
2846 if (memcmp(expected,
GET_PKT_DATA(r) + 40,
sizeof(expected)) != 0) {
2847 printf(
"Expected:\n");
2854 for (
int i = 0; i < 4; i++) {
2862 static int DefragBsdSubsequentOverlapsStartOfOriginalIpv4Test_2(
void)
2870 &packets[0], IPPROTO_ICMP, 6, 16 >> 3, 1, (uint8_t *)
"AABBCCDDAABBDDCC", 16));
2874 &packets[1], IPPROTO_ICMP, 6, 8 >> 3, 1, (uint8_t *)
"AACCBBDDAACCDDBB", 16));
2878 &packets[2], IPPROTO_ICMP, 6, 0, 1, (uint8_t *)
"ZZZZZZZZ", 8));
2882 &packets[3], IPPROTO_ICMP, 6, 32 >> 3, 0, (uint8_t *)
"DDCCBBAA", 8));
2897 const uint8_t expected[] = {
2902 'A',
'A',
'C',
'C',
'B',
'B',
'D',
'D',
2903 'A',
'A',
'C',
'C',
'D',
'D',
'B',
'B',
2904 'A',
'A',
'B',
'B',
'D',
'D',
'C',
'C',
2905 'D',
'D',
'C',
'C',
'B',
'B',
'A',
'A',
2911 for (
int i = 0; i < 4; i++) {
2919 static int DefragBsdSubsequentOverlapsStartOfOriginalIpv6Test_2(
void)
2926 packets[0] = BuildIpv6TestPacketWithContent(
2927 IPPROTO_ICMP, 6, 16 >> 3, 1, (uint8_t *)
"AABBCCDDAABBDDCC", 16);
2930 packets[1] = BuildIpv6TestPacketWithContent(
2931 IPPROTO_ICMP, 6, 8 >> 3, 1, (uint8_t *)
"AACCBBDDAACCDDBB", 16);
2934 packets[2] = BuildIpv6TestPacketWithContent(IPPROTO_ICMP, 6, 0, 1, (uint8_t *)
"ZZZZZZZZ", 8);
2938 BuildIpv6TestPacketWithContent(IPPROTO_ICMP, 6, 32 >> 3, 0, (uint8_t *)
"DDCCBBAA", 8);
2953 const uint8_t expected[] = {
2958 'A',
'A',
'C',
'C',
'B',
'B',
'D',
'D',
2959 'A',
'A',
'C',
'C',
'D',
'D',
'B',
'B',
2960 'A',
'A',
'B',
'B',
'D',
'D',
'C',
'C',
2961 'D',
'D',
'C',
'C',
'B',
'B',
'A',
'A',
2967 for (
int i = 0; i < 4; i++) {
2987 static int DefragBsdSubsequentOverlapsStartOfOriginalIpv4Test(
void)
2993 packets[0] = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 8 >> 3, 0,
'E', 24);
2994 packets[1] = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 0, 1,
'M', 24);
3003 const uint8_t expected[] = {
3004 'M',
'M',
'M',
'M',
'M',
'M',
'M',
'M',
3005 'M',
'M',
'M',
'M',
'M',
'M',
'M',
'M',
3006 'M',
'M',
'M',
'M',
'M',
'M',
'M',
'M',
3007 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3011 if (memcmp(expected,
GET_PKT_DATA(r) + 20,
sizeof(expected)) != 0) {
3012 printf(
"Expected:\n");
3019 for (
int i = 0; i < 2; i++) {
3027 static int DefragBsdSubsequentOverlapsStartOfOriginalIpv6Test(
void)
3033 packets[0] = BuildIpv6TestPacket(IPPROTO_ICMP, 1, 8 >> 3, 0,
'E', 24);
3034 packets[1] = BuildIpv6TestPacket(IPPROTO_ICMP, 1, 0, 1,
'M', 24);
3043 const uint8_t expected[] = {
3044 'M',
'M',
'M',
'M',
'M',
'M',
'M',
'M',
3045 'M',
'M',
'M',
'M',
'M',
'M',
'M',
'M',
3046 'M',
'M',
'M',
'M',
'M',
'M',
'M',
'M',
3047 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3051 if (memcmp(expected,
GET_PKT_DATA(r) + 40,
sizeof(expected)) != 0) {
3052 printf(
"Expected:\n");
3059 for (
int i = 0; i < 2; i++) {
3078 static int DefragBsdMissingFragmentIpv4Test(
void)
3085 &packets[0], IPPROTO_ICMP, 189, 16 >> 3, 1, (uint8_t *)
"AABBCCDDAABBDDCC", 16));
3088 &packets[1], IPPROTO_ICMP, 189, 40 >> 3, 1, (uint8_t *)
"AACCBBDD", 8));
3091 &packets[2], IPPROTO_ICMP, 189, 8 >> 3, 1, (uint8_t *)
"AACCDDBBAADDBBCC", 16));
3095 &packets[3], IPPROTO_ICMP, 189, 0, 1, (uint8_t *)
"ZZZZZZZZ", 8));
3098 &packets[4], IPPROTO_ICMP, 189, 48 >> 3, 0, (uint8_t *)
"DDCCBBAA", 8));
3119 for (
int i = 0; i < 5; i++) {
3126 static int DefragBsdMissingFragmentIpv6Test(
void)
3132 packets[0] = BuildIpv6TestPacketWithContent(
3133 IPPROTO_ICMP, 189, 16 >> 3, 1, (uint8_t *)
"AABBCCDDAABBDDCC", 16);
3136 BuildIpv6TestPacketWithContent(IPPROTO_ICMP, 189, 40 >> 3, 1, (uint8_t *)
"AACCBBDD", 8);
3138 packets[2] = BuildIpv6TestPacketWithContent(
3139 IPPROTO_ICMP, 189, 8 >> 3, 1, (uint8_t *)
"AACCDDBBAADDBBCC", 16);
3142 packets[3] = BuildIpv6TestPacketWithContent(IPPROTO_ICMP, 189, 0, 1, (uint8_t *)
"ZZZZZZZZ", 8);
3145 BuildIpv6TestPacketWithContent(IPPROTO_ICMP, 189, 48 >> 3, 0, (uint8_t *)
"DDCCBBAA", 8);
3166 for (
int i = 0; i < 5; i++) {
3187 static int DefragBsdOverlapAfterCoveredStartsInsidePrevIpv4Test(
void)
3193 packets[0] = BuildIpv4TestPacket(IPPROTO_ICMP, 54, 0, 1,
'A', 16);
3194 packets[1] = BuildIpv4TestPacket(IPPROTO_ICMP, 54, 24 >> 3, 1,
'B', 16);
3195 packets[2] = BuildIpv4TestPacket(IPPROTO_ICMP, 54, 48 >> 3, 0,
'C', 8);
3196 packets[3] = BuildIpv4TestPacket(IPPROTO_ICMP, 54, 8 >> 3, 1,
'D', 32);
3197 packets[4] = BuildIpv4TestPacket(IPPROTO_ICMP, 54, 32 >> 3, 1,
'E', 16);
3217 const uint8_t expected[] = {
3218 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3219 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3220 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3221 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3222 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3223 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3224 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
3229 if (memcmp(expected,
GET_PKT_DATA(rp) + 20,
sizeof(expected)) != 0) {
3230 printf(
"Expected:\n");
3240 for (
int i = 0; i < 5; i++) {
3249 static int DefragBsdOverlapAfterCoveredStartsInsidePrevIpv6Test(
void)
3255 packets[0] = BuildIpv6TestPacket(IPPROTO_ICMP, 54, 0, 1,
'A', 16);
3256 packets[1] = BuildIpv6TestPacket(IPPROTO_ICMP, 54, 24 >> 3, 1,
'B', 16);
3257 packets[2] = BuildIpv6TestPacket(IPPROTO_ICMP, 54, 48 >> 3, 0,
'C', 8);
3258 packets[3] = BuildIpv6TestPacket(IPPROTO_ICMP, 54, 8 >> 3, 1,
'D', 32);
3259 packets[4] = BuildIpv6TestPacket(IPPROTO_ICMP, 54, 32 >> 3, 1,
'E', 16);
3279 const uint8_t expected[] = {
3280 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3281 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3282 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3283 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3284 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3285 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3286 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
3291 if (memcmp(expected,
GET_PKT_DATA(rp) + 40,
sizeof(expected)) != 0) {
3292 printf(
"Expected:\n");
3302 for (
int i = 0; i < 5; i++) {
3325 static int DefragBsdOverlapAfterCoveredStartsBeforeIpv4Test(
void)
3331 packets[0] = BuildIpv4TestPacket(IPPROTO_ICMP, 55, 0, 1,
'A', 16);
3332 packets[1] = BuildIpv4TestPacket(IPPROTO_ICMP, 55, 24 >> 3, 1,
'B', 8);
3333 packets[2] = BuildIpv4TestPacket(IPPROTO_ICMP, 55, 40 >> 3, 1,
'C', 16);
3334 packets[3] = BuildIpv4TestPacket(IPPROTO_ICMP, 55, 64 >> 3, 0,
'D', 8);
3335 packets[4] = BuildIpv4TestPacket(IPPROTO_ICMP, 55, 16 >> 3, 1,
'E', 40);
3336 packets[5] = BuildIpv4TestPacket(IPPROTO_ICMP, 55, 48 >> 3, 1,
'F', 16);
3359 const uint8_t expected[] = {
3360 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3361 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3362 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3363 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3364 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3365 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3366 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3367 'F',
'F',
'F',
'F',
'F',
'F',
'F',
'F',
3368 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3373 if (memcmp(expected,
GET_PKT_DATA(rp) + 20,
sizeof(expected)) != 0) {
3374 printf(
"Expected:\n");
3384 for (
int i = 0; i < 6; i++) {
3393 static int DefragBsdOverlapAfterCoveredStartsBeforeIpv6Test(
void)
3399 packets[0] = BuildIpv6TestPacket(IPPROTO_ICMP, 55, 0, 1,
'A', 16);
3400 packets[1] = BuildIpv6TestPacket(IPPROTO_ICMP, 55, 24 >> 3, 1,
'B', 8);
3401 packets[2] = BuildIpv6TestPacket(IPPROTO_ICMP, 55, 40 >> 3, 1,
'C', 16);
3402 packets[3] = BuildIpv6TestPacket(IPPROTO_ICMP, 55, 64 >> 3, 0,
'D', 8);
3403 packets[4] = BuildIpv6TestPacket(IPPROTO_ICMP, 55, 16 >> 3, 1,
'E', 40);
3404 packets[5] = BuildIpv6TestPacket(IPPROTO_ICMP, 55, 48 >> 3, 1,
'F', 16);
3427 const uint8_t expected[] = {
3428 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3429 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3430 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3431 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3432 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3433 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3434 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3435 'F',
'F',
'F',
'F',
'F',
'F',
'F',
'F',
3436 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3441 if (memcmp(expected,
GET_PKT_DATA(rp) + 40,
sizeof(expected)) != 0) {
3442 printf(
"Expected:\n");
3452 for (
int i = 0; i < 6; i++) {
3475 static int DefragBsdFollowingStartsBeforeNewIpv4Test(
void)
3481 packets[0] = BuildIpv4TestPacket(IPPROTO_ICMP, 56, 0, 1,
'A', 32);
3482 packets[1] = BuildIpv4TestPacket(IPPROTO_ICMP, 56, 16 >> 3, 1,
'B', 40);
3483 packets[2] = BuildIpv4TestPacket(IPPROTO_ICMP, 56, 24 >> 3, 1,
'C', 16);
3484 packets[3] = BuildIpv4TestPacket(IPPROTO_ICMP, 56, 0, 1,
'D', 40);
3485 packets[4] = BuildIpv4TestPacket(IPPROTO_ICMP, 56, 40 >> 3, 1,
'E', 16);
3486 packets[5] = BuildIpv4TestPacket(IPPROTO_ICMP, 56, 56 >> 3, 0,
'F', 8);
3488 for (
int i = 0; i < 5; i++) {
3498 const uint8_t expected[] = {
3499 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3500 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3501 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3502 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3503 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3504 'B',
'B',
'B',
'B',
'B',
'B',
'B',
'B',
3505 'B',
'B',
'B',
'B',
'B',
'B',
'B',
'B',
3506 'F',
'F',
'F',
'F',
'F',
'F',
'F',
'F',
3511 if (memcmp(expected,
GET_PKT_DATA(rp) + 20,
sizeof(expected)) != 0) {
3512 printf(
"Expected:\n");
3522 for (
int i = 0; i < 6; i++) {
3531 static int DefragBsdFollowingStartsBeforeNewIpv6Test(
void)
3537 packets[0] = BuildIpv6TestPacket(IPPROTO_ICMP, 56, 0, 1,
'A', 32);
3538 packets[1] = BuildIpv6TestPacket(IPPROTO_ICMP, 56, 16 >> 3, 1,
'B', 40);
3539 packets[2] = BuildIpv6TestPacket(IPPROTO_ICMP, 56, 24 >> 3, 1,
'C', 16);
3540 packets[3] = BuildIpv6TestPacket(IPPROTO_ICMP, 56, 0, 1,
'D', 40);
3541 packets[4] = BuildIpv6TestPacket(IPPROTO_ICMP, 56, 40 >> 3, 1,
'E', 16);
3542 packets[5] = BuildIpv6TestPacket(IPPROTO_ICMP, 56, 56 >> 3, 0,
'F', 8);
3544 for (
int i = 0; i < 5; i++) {
3554 const uint8_t expected[] = {
3555 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3556 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3557 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3558 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3559 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3560 'B',
'B',
'B',
'B',
'B',
'B',
'B',
'B',
3561 'B',
'B',
'B',
'B',
'B',
'B',
'B',
'B',
3562 'F',
'F',
'F',
'F',
'F',
'F',
'F',
'F',
3567 if (memcmp(expected,
GET_PKT_DATA(rp) + 40,
sizeof(expected)) != 0) {
3568 printf(
"Expected:\n");
3578 for (
int i = 0; i < 6; i++) {
3603 static int DefragBsdNextLtrimNotLoweredIpv4Test(
void)
3609 packets[0] = BuildIpv4TestPacket(IPPROTO_ICMP, 53, 24 >> 3, 1,
'A', 32);
3610 packets[1] = BuildIpv4TestPacket(IPPROTO_ICMP, 53, 16 >> 3, 1,
'B', 32);
3611 packets[2] = BuildIpv4TestPacket(IPPROTO_ICMP, 53, 0, 1,
'C', 40);
3612 packets[3] = BuildIpv4TestPacket(IPPROTO_ICMP, 53, 56 >> 3, 0,
'D', 8);
3627 const uint8_t expected[] = {
3628 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
3629 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
3630 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
3631 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
3632 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
3633 'B',
'B',
'B',
'B',
'B',
'B',
'B',
'B',
3634 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3635 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3640 if (memcmp(expected,
GET_PKT_DATA(r) + 20,
sizeof(expected)) != 0) {
3641 printf(
"Expected:\n");
3648 for (
int i = 0; i < 4; i++) {
3657 static int DefragBsdNextLtrimNotLoweredIpv6Test(
void)
3663 packets[0] = BuildIpv6TestPacket(IPPROTO_ICMP, 53, 24 >> 3, 1,
'A', 32);
3664 packets[1] = BuildIpv6TestPacket(IPPROTO_ICMP, 53, 16 >> 3, 1,
'B', 32);
3665 packets[2] = BuildIpv6TestPacket(IPPROTO_ICMP, 53, 0, 1,
'C', 40);
3666 packets[3] = BuildIpv6TestPacket(IPPROTO_ICMP, 53, 56 >> 3, 0,
'D', 8);
3681 const uint8_t expected[] = {
3682 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
3683 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
3684 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
3685 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
3686 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
3687 'B',
'B',
'B',
'B',
'B',
'B',
'B',
'B',
3688 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3689 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3694 if (memcmp(expected,
GET_PKT_DATA(r) + 40,
sizeof(expected)) != 0) {
3695 printf(
"Expected:\n");
3702 for (
int i = 0; i < 4; i++) {
3728 static int DefragBsdTrimAllOverlappedStartsInsidePrevIpv4Test(
void)
3734 packets[0] = BuildIpv4TestPacket(IPPROTO_ICMP, 50, 0, 1,
'A', 16);
3735 packets[1] = BuildIpv4TestPacket(IPPROTO_ICMP, 50, 16 >> 3, 1,
'B', 16);
3736 packets[2] = BuildIpv4TestPacket(IPPROTO_ICMP, 50, 32 >> 3, 1,
'C', 16);
3737 packets[3] = BuildIpv4TestPacket(IPPROTO_ICMP, 50, 8 >> 3, 1,
'D', 40);
3738 packets[4] = BuildIpv4TestPacket(IPPROTO_ICMP, 50, 48 >> 3, 0,
'E', 8);
3756 const uint8_t expected[] = {
3757 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3758 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3759 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3760 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3761 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3762 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3763 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3768 if (memcmp(expected,
GET_PKT_DATA(r) + 20,
sizeof(expected)) != 0) {
3769 printf(
"Expected:\n");
3776 for (
int i = 0; i < 5; i++) {
3785 static int DefragBsdTrimAllOverlappedStartsInsidePrevIpv6Test(
void)
3791 packets[0] = BuildIpv6TestPacket(IPPROTO_ICMP, 50, 0, 1,
'A', 16);
3792 packets[1] = BuildIpv6TestPacket(IPPROTO_ICMP, 50, 16 >> 3, 1,
'B', 16);
3793 packets[2] = BuildIpv6TestPacket(IPPROTO_ICMP, 50, 32 >> 3, 1,
'C', 16);
3794 packets[3] = BuildIpv6TestPacket(IPPROTO_ICMP, 50, 8 >> 3, 1,
'D', 40);
3795 packets[4] = BuildIpv6TestPacket(IPPROTO_ICMP, 50, 48 >> 3, 0,
'E', 8);
3813 const uint8_t expected[] = {
3814 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3815 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
3816 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3817 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3818 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3819 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3820 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3825 if (memcmp(expected,
GET_PKT_DATA(r) + 40,
sizeof(expected)) != 0) {
3826 printf(
"Expected:\n");
3833 for (
int i = 0; i < 5; i++) {
3859 static int DefragBsdTrimAllOverlappedStartsBeforeIpv4Test(
void)
3865 packets[0] = BuildIpv4TestPacket(IPPROTO_ICMP, 51, 8 >> 3, 1,
'A', 16);
3866 packets[1] = BuildIpv4TestPacket(IPPROTO_ICMP, 51, 24 >> 3, 1,
'B', 16);
3867 packets[2] = BuildIpv4TestPacket(IPPROTO_ICMP, 51, 40 >> 3, 1,
'C', 16);
3868 packets[3] = BuildIpv4TestPacket(IPPROTO_ICMP, 51, 0, 1,
'D', 56);
3869 packets[4] = BuildIpv4TestPacket(IPPROTO_ICMP, 51, 56 >> 3, 0,
'E', 8);
3887 const uint8_t expected[] = {
3888 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3889 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3890 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3891 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3892 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3893 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3894 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3895 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3900 if (memcmp(expected,
GET_PKT_DATA(r) + 20,
sizeof(expected)) != 0) {
3901 printf(
"Expected:\n");
3908 for (
int i = 0; i < 5; i++) {
3917 static int DefragBsdTrimAllOverlappedStartsBeforeIpv6Test(
void)
3923 packets[0] = BuildIpv6TestPacket(IPPROTO_ICMP, 51, 8 >> 3, 1,
'A', 16);
3924 packets[1] = BuildIpv6TestPacket(IPPROTO_ICMP, 51, 24 >> 3, 1,
'B', 16);
3925 packets[2] = BuildIpv6TestPacket(IPPROTO_ICMP, 51, 40 >> 3, 1,
'C', 16);
3926 packets[3] = BuildIpv6TestPacket(IPPROTO_ICMP, 51, 0, 1,
'D', 56);
3927 packets[4] = BuildIpv6TestPacket(IPPROTO_ICMP, 51, 56 >> 3, 0,
'E', 8);
3945 const uint8_t expected[] = {
3946 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3947 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3948 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3949 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3950 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3951 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3952 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
3953 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
3958 if (memcmp(expected,
GET_PKT_DATA(r) + 40,
sizeof(expected)) != 0) {
3959 printf(
"Expected:\n");
3966 for (
int i = 0; i < 5; i++) {
3979 static int DefragOutOfOrderFirstFragmentTest(
void)
3981 Packet *p1 = NULL, *p2 = NULL, *p3 = NULL, *p4 = NULL;
3982 Packet *reassembled = NULL;
3989 p1 = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 24 >> 3, 0,
'D', 8);
3991 p2 = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 8 >> 3, 1,
'B', 8);
3993 p3 = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 16 >> 3, 1,
'C', 8);
3995 p4 = BuildIpv4TestPacket(IPPROTO_ICMP,
id, 0, 1,
'A', 8);
4008 for (
int i = 20 + 0; i < 20 + 8; i++)
4010 for (
int i = 20 + 8; i < 20 + 16; i++)
4012 for (
int i = 20 + 16; i < 20 + 24; i++)
4014 for (
int i = 20 + 24; i < 20 + 32; i++)
4033 static int DefragSameOffsetPrecedingOverlapTest(
void)
4035 Packet *packets[5] = { NULL };
4036 Packet *reassembled = NULL;
4045 &packets[0], IPPROTO_ICMP,
id, 8 >> 3, 1, (uint8_t *)
"BBBBBBBBBBBBBBBB", 16));
4048 &packets[1], IPPROTO_ICMP,
id, 0, 1, (uint8_t *)
"AAAAAAAAAAAAAAAA", 16));
4051 &packets[2], IPPROTO_ICMP,
id, 24 >> 3, 1, (uint8_t *)
"CCCCCCCC", 8));
4054 &packets[3], IPPROTO_ICMP,
id, 8 >> 3, 1, (uint8_t *)
"DDDDDDDDDDDDDDDD", 16));
4057 &packets[4], IPPROTO_ICMP,
id, 32 >> 3, 0, (uint8_t *)
"EEEEEEEE", 8));
4059 for (
int i = 0; i < 4; i++)
4067 const uint8_t expected[] = {
4068 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
4069 'A',
'A',
'A',
'A',
'A',
'A',
'A',
'A',
4070 'D',
'D',
'D',
'D',
'D',
'D',
'D',
'D',
4071 'C',
'C',
'C',
'C',
'C',
'C',
'C',
'C',
4072 'E',
'E',
'E',
'E',
'E',
'E',
'E',
'E',
4077 for (
int i = 0; i < 5; i++)
4090 UtRegisterTest(
"DefragInOrderSimpleTest", DefragInOrderSimpleTest);
4091 UtRegisterTest(
"DefragReverseSimpleTest", DefragReverseSimpleTest);
4092 UtRegisterTest(
"DefragSturgesNovakBsdTest", DefragSturgesNovakBsdTest);
4094 DefragSturgesNovakLinuxIpv4Test);
4096 DefragSturgesNovakWindowsIpv4Test);
4098 DefragSturgesNovakSolarisTest);
4099 UtRegisterTest(
"DefragSturgesNovakFirstTest", DefragSturgesNovakFirstTest);
4100 UtRegisterTest(
"DefragSturgesNovakLastTest", DefragSturgesNovakLastTest);
4103 UtRegisterTest(
"DefragTooLargeIpv4Test", DefragTooLargeIpv4Test);
4105 UtRegisterTest(
"DefragInOrderSimpleIpv6Test", DefragInOrderSimpleIpv6Test);
4106 UtRegisterTest(
"DefragReverseSimpleIpv6Test", DefragReverseSimpleIpv6Test);
4107 UtRegisterTest(
"DefragSturgesNovakBsdIpv6Test", DefragSturgesNovakBsdIpv6Test);
4108 UtRegisterTest(
"DefragSturgesNovakLinuxIpv6Test", DefragSturgesNovakLinuxIpv6Test);
4109 UtRegisterTest(
"DefragSturgesNovakWindowsIpv6Test", DefragSturgesNovakWindowsIpv6Test);
4110 UtRegisterTest(
"DefragSturgesNovakSolarisIpv6Test", DefragSturgesNovakSolarisIpv6Test);
4111 UtRegisterTest(
"DefragSturgesNovakFirstIpv6Test", DefragSturgesNovakFirstIpv6Test);
4112 UtRegisterTest(
"DefragSturgesNovakLastIpv6Test", DefragSturgesNovakLastIpv6Test);
4117 UtRegisterTest(
"DefragTrackerReuseTest", DefragTrackerReuseTest);
4125 UtRegisterTest(
"DefragBsdFragmentAfterNoMfIpv4Test", DefragBsdFragmentAfterNoMfIpv4Test);
4126 UtRegisterTest(
"DefragBsdFragmentAfterNoMfIpv6Test", DefragBsdFragmentAfterNoMfIpv6Test);
4127 UtRegisterTest(
"DefragBsdSubsequentOverlapsStartOfOriginalIpv4Test",
4128 DefragBsdSubsequentOverlapsStartOfOriginalIpv4Test);
4129 UtRegisterTest(
"DefragBsdSubsequentOverlapsStartOfOriginalIpv6Test",
4130 DefragBsdSubsequentOverlapsStartOfOriginalIpv6Test);
4131 UtRegisterTest(
"DefragBsdSubsequentOverlapsStartOfOriginalIpv4Test_2",
4132 DefragBsdSubsequentOverlapsStartOfOriginalIpv4Test_2);
4133 UtRegisterTest(
"DefragBsdSubsequentOverlapsStartOfOriginalIpv6Test_2",
4134 DefragBsdSubsequentOverlapsStartOfOriginalIpv6Test_2);
4135 UtRegisterTest(
"DefragBsdMissingFragmentIpv4Test", DefragBsdMissingFragmentIpv4Test);
4136 UtRegisterTest(
"DefragBsdMissingFragmentIpv6Test", DefragBsdMissingFragmentIpv6Test);
4137 UtRegisterTest(
"DefragBsdOverlapAfterCoveredStartsInsidePrevIpv4Test",
4138 DefragBsdOverlapAfterCoveredStartsInsidePrevIpv4Test);
4139 UtRegisterTest(
"DefragBsdOverlapAfterCoveredStartsInsidePrevIpv6Test",
4140 DefragBsdOverlapAfterCoveredStartsInsidePrevIpv6Test);
4141 UtRegisterTest(
"DefragBsdOverlapAfterCoveredStartsBeforeIpv4Test",
4142 DefragBsdOverlapAfterCoveredStartsBeforeIpv4Test);
4143 UtRegisterTest(
"DefragBsdOverlapAfterCoveredStartsBeforeIpv6Test",
4144 DefragBsdOverlapAfterCoveredStartsBeforeIpv6Test);
4146 "DefragBsdFollowingStartsBeforeNewIpv4Test", DefragBsdFollowingStartsBeforeNewIpv4Test);
4148 "DefragBsdFollowingStartsBeforeNewIpv6Test", DefragBsdFollowingStartsBeforeNewIpv6Test);
4149 UtRegisterTest(
"DefragBsdNextLtrimNotLoweredIpv4Test", DefragBsdNextLtrimNotLoweredIpv4Test);
4150 UtRegisterTest(
"DefragBsdNextLtrimNotLoweredIpv6Test", DefragBsdNextLtrimNotLoweredIpv6Test);
4151 UtRegisterTest(
"DefragBsdTrimAllOverlappedStartsInsidePrevIpv4Test",
4152 DefragBsdTrimAllOverlappedStartsInsidePrevIpv4Test);
4153 UtRegisterTest(
"DefragBsdTrimAllOverlappedStartsInsidePrevIpv6Test",
4154 DefragBsdTrimAllOverlappedStartsInsidePrevIpv6Test);
4156 DefragBsdTrimAllOverlappedStartsBeforeIpv4Test);
4158 DefragBsdTrimAllOverlappedStartsBeforeIpv6Test);
4159 UtRegisterTest(
"DefragOutOfOrderFirstFragmentTest", DefragOutOfOrderFirstFragmentTest);
4160 UtRegisterTest(
"DefragSameOffsetPrecedingOverlapTest", DefragSameOffsetPrecedingOverlapTest);