suricata
defrag.c
Go to the documentation of this file.
1 /* Copyright (C) 2007-2024 Open Information Security Foundation
2  *
3  * You can copy, redistribute or modify this Program under the terms of
4  * the GNU General Public License version 2 as published by the Free
5  * Software Foundation.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * version 2 along with this program; if not, write to the Free Software
14  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
15  * 02110-1301, USA.
16  */
17 
18 /**
19  * \file
20  *
21  * \author Endace Technology Limited, Jason Ish <jason.ish@endace.com>
22  *
23  * Defragmentation module.
24  * References:
25  * - RFC 815
26  * - OpenBSD PF's IP normalization (pf_norm.c)
27  *
28  * \todo pool for frag packet storage
29  * \todo policy bsd-right
30  * \todo profile hash function
31  * \todo log anomalies
32  */
33 
34 #include "suricata-common.h"
35 
36 #include "queue.h"
37 
38 #include "suricata.h"
39 #include "threads.h"
40 #include "conf.h"
41 #include "decode-ipv6.h"
42 #include "util-hashlist.h"
43 #include "util-pool.h"
44 #include "util-print.h"
45 #include "util-debug.h"
46 #include "util-fix_checksum.h"
47 #include "util-random.h"
48 #include "stream-tcp-private.h"
49 #include "stream-tcp-reassemble.h"
50 #include "util-host-os-info.h"
51 #include "util-validate.h"
52 
53 #include "defrag.h"
54 #include "defrag-hash.h"
55 #include "defrag-config.h"
56 
57 #include "tmqh-packetpool.h"
58 #include "decode.h"
59 
60 #ifdef UNITTESTS
61 #endif
62 
63 #define DEFAULT_DEFRAG_HASH_SIZE 0xffff
64 #define DEFAULT_DEFRAG_POOL_SIZE 0xffff
65 
66 /**
67  * Default timeout (in seconds) before a defragmentation tracker will
68  * be released.
69  */
70 #define TIMEOUT_DEFAULT 60
71 
72 /**
73  * Maximum allowed timeout, 24 hours.
74  */
75 #define TIMEOUT_MAX (60 * 60 * 24)
76 
77 /**
78  * Minimum allowed timeout, 1 second.
79  */
80 #define TIMEOUT_MIN 1
81 
82 /** Fragment reassembly policies. */
91 
93 };
94 
95 static uint8_t default_policy = DEFRAG_POLICY_BSD;
96 
97 /** The global DefragContext so all threads operate from the same
98  * context. */
99 static DefragContext *defrag_context;
100 
102 
103 /**
104  * \brief Reset a frag for reuse in a pool.
105  */
106 static void
107 DefragFragReset(Frag *frag)
108 {
109  if (frag->pkt != NULL)
110  SCFree(frag->pkt);
111  memset(frag, 0, sizeof(*frag));
112 }
113 
114 /**
115  * \brief Free all frags associated with a tracker.
116  */
117 void
119 {
120  Frag *frag, *tmp;
121 
122  /* Lock the frag pool as we'll be return items to it. */
123  SCMutexLock(&defrag_context->frag_pool_lock);
124 
125  RB_FOREACH_SAFE(frag, IP_FRAGMENTS, &tracker->fragment_tree, tmp) {
126  RB_REMOVE(IP_FRAGMENTS, &tracker->fragment_tree, frag);
127  DefragFragReset(frag);
128  PoolReturn(defrag_context->frag_pool, frag);
129  }
130 
131  SCMutexUnlock(&defrag_context->frag_pool_lock);
132 }
133 
134 /**
135  * \brief Create a new DefragContext.
136  *
137  * \retval On success a return an initialized DefragContext, otherwise
138  * NULL will be returned.
139  */
140 static DefragContext *
141 DefragContextNew(void)
142 {
143  DefragContext *dc;
144 
145  dc = SCCalloc(1, sizeof(*dc));
146  if (unlikely(dc == NULL))
147  return NULL;
148 
149  /* Initialize the pool of trackers. */
150  intmax_t tracker_pool_size;
151  if (!SCConfGetInt("defrag.trackers", &tracker_pool_size) || tracker_pool_size == 0) {
152  tracker_pool_size = DEFAULT_DEFRAG_HASH_SIZE;
153  }
154 
155  /* Initialize the pool of frags. */
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) {
159  frag_pool_size = DEFAULT_DEFRAG_POOL_SIZE;
160  }
161  uint32_t frag_pool_prealloc = (uint32_t)frag_pool_size / 2;
162  dc->frag_pool =
163  PoolInit((uint32_t)frag_pool_size, frag_pool_prealloc, sizeof(Frag), NULL, NULL, NULL);
164  if (dc->frag_pool == NULL) {
165  FatalError("Defrag: Failed to initialize fragment pool.");
166  }
167  if (SCMutexInit(&dc->frag_pool_lock, NULL) != 0) {
168  FatalError("Defrag: Failed to initialize frag pool mutex.");
169  }
170 
171  /* Set the default timeout. */
172  intmax_t timeout;
173  if (!SCConfGetInt("defrag.timeout", &timeout)) {
174  dc->timeout = TIMEOUT_DEFAULT;
175  } else {
176  if (timeout < TIMEOUT_MIN) {
177  FatalError("defrag: Timeout less than minimum allowed value.");
178  }
179  else if (timeout > TIMEOUT_MAX) {
180  FatalError("defrag: Timeout greater than maximum allowed value.");
181  }
182  dc->timeout = (uint32_t)timeout;
183  }
184 
185  SCLogDebug("Defrag Initialized:");
186  SCLogDebug("\tTimeout: %"PRIuMAX, (uintmax_t)dc->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);
191 
192  return dc;
193 }
194 
195 static void
196 DefragContextDestroy(DefragContext *dc)
197 {
198  if (dc == NULL)
199  return;
200 
201  PoolFree(dc->frag_pool);
202  SCFree(dc);
203 }
204 
205 /**
206  * Attempt to re-assemble a packet.
207  *
208  * \param tracker The defragmentation tracker to reassemble from.
209  */
210 static Packet *
211 Defrag4Reassemble(ThreadVars *tv, DefragTracker *tracker, Packet *p)
212 {
213  Packet *rp = NULL;
214 
215  /* Should not be here unless we have seen the last fragment. */
216  if (!tracker->seen_last) {
217  return NULL;
218  }
219 
220  /* Check that we have the first fragment and its of a valid size. */
221  Frag *first = RB_MIN(IP_FRAGMENTS, &tracker->fragment_tree);
222  if (first == NULL) {
223  goto done;
224  } else if (first->offset != 0) {
225  /* Still waiting for the first fragment. */
226  goto done;
227  } else if (first->len < sizeof(IPV4Hdr)) {
228  /* First fragment isn't enough for an IPv6 header. */
229  goto error_remove_tracker;
230  }
231 
232  /* Check that we have all the data. Relies on the fact that
233  * fragments are inserted in frag_offset order. */
234  Frag *frag = NULL;
235  size_t len = 0;
236  RB_FOREACH_FROM(frag, IP_FRAGMENTS, first) {
237  if (frag->offset > len) {
238  /* This fragment starts after the end of the previous
239  * fragment. We have a hole. */
240  goto done;
241  }
242  else {
243  /* Update the packet length to the largest known data offset. */
244  len = MAX(len, frag->offset + frag->data_len);
245  }
246  }
247 
248  const IPV4Hdr *oip4h = PacketGetIPv4(p);
249 
250  /* Allocate a Packet for the reassembled packet. On failure we
251  * SCFree all the resources held by this tracker. */
252  rp = PacketDefragPktSetup(p, NULL, 0, IPV4_GET_RAW_IPPROTO(oip4h));
253  if (rp == NULL) {
254  goto error_remove_tracker;
255  }
258  rp->datalink = tracker->datalink;
259 
260  int fragmentable_offset = 0;
261  uint16_t fragmentable_len = 0;
262  uint16_t hlen = 0;
263  int ip_hdr_offset = 0;
264 
265  /* Assume more frags. */
266  uint16_t prev_offset = 0;
267  bool more_frags = 1;
268 
269  RB_FOREACH(frag, IP_FRAGMENTS, &tracker->fragment_tree) {
270  SCLogDebug("frag %p, data_len %u, offset %u, pcap_cnt %"PRIu64,
271  frag, frag->data_len, frag->offset, frag->pcap_cnt);
272 
273  /* Previous fragment has no more fragments, and this packet
274  * doesn't overlap. We're done. */
275  if (!more_frags && frag->offset > prev_offset) {
276  break;
277  }
278 
279  if (frag->skip)
280  continue;
281  if (frag->ltrim >= frag->data_len)
282  continue;
283  if (frag->offset == 0) {
284 
285  if (PacketCopyData(rp, frag->pkt, frag->len) == -1)
286  goto error_remove_tracker;
287 
288  hlen = frag->hlen;
289  ip_hdr_offset = tracker->ip_hdr_offset;
290 
291  /* This is the start of the fragmentable portion of the
292  * first packet. All fragment offsets are relative to
293  * this. */
294  fragmentable_offset = tracker->ip_hdr_offset + frag->hlen;
295  fragmentable_len = frag->data_len;
296  }
297  else {
298  int pkt_end = fragmentable_offset + frag->offset + frag->data_len;
299  if (pkt_end > (int)MAX_PAYLOAD_SIZE) {
300  SCLogDebug("Failed re-assemble "
301  "fragmented packet, exceeds size of packet buffer.");
302  goto error_remove_tracker;
303  }
304  if (PacketCopyDataOffset(rp,
305  fragmentable_offset + frag->offset + frag->ltrim,
306  frag->pkt + frag->data_offset + frag->ltrim,
307  frag->data_len - frag->ltrim) == -1) {
308  goto error_remove_tracker;
309  }
310  if (frag->offset > UINT16_MAX - frag->data_len) {
311  SCLogDebug("Failed re-assemble "
312  "fragmentable_len exceeds UINT16_MAX");
313  goto error_remove_tracker;
314  }
315  if (frag->offset + frag->data_len > fragmentable_len)
316  fragmentable_len = frag->offset + frag->data_len;
317  }
318 
319  /* Even if this fragment is flagged as having no more
320  * fragments, still continue. The next fragment may have the
321  * same offset with data that is preferred.
322  *
323  * For example, DefragBsdFragmentAfterNoMfIpv{4,6}Test
324  *
325  * This is due to not all fragments being completely trimmed,
326  * but relying on the copy ordering. */
327  more_frags = frag->more_frags;
328  prev_offset = frag->offset;
329  }
330 
331  SCLogDebug("ip_hdr_offset %u, hlen %" PRIu16 ", fragmentable_len %" PRIu16, ip_hdr_offset, hlen,
332  fragmentable_len);
333 
334  const uint32_t packet_len = (uint32_t)hlen + fragmentable_len;
335  if (packet_len > IPV4_MAXPACKET_LEN) {
337  goto error_remove_tracker;
338  }
339 
340  IPV4Hdr *ip4h = (IPV4Hdr *)(GET_PKT_DATA(rp) + ip_hdr_offset);
341  uint16_t old = ip4h->ip_len + ip4h->ip_off;
342  ip4h->ip_len = htons((uint16_t)packet_len);
343  ip4h->ip_off = 0;
344  ip4h->ip_csum = FixChecksum(ip4h->ip_csum, old, ip4h->ip_len + ip4h->ip_off);
345  SET_PKT_LEN(rp, ip_hdr_offset + packet_len);
346 
347  tracker->remove = 1;
348  DefragTrackerFreeFrags(tracker);
349 done:
350  return rp;
351 
352 error_remove_tracker:
353  tracker->remove = 1;
354  DefragTrackerFreeFrags(tracker);
355  if (rp != NULL)
357  return NULL;
358 }
359 
360 /**
361  * Attempt to re-assemble a packet.
362  *
363  * \param tracker The defragmentation tracker to reassemble from.
364  */
365 static Packet *
366 Defrag6Reassemble(ThreadVars *tv, DefragTracker *tracker, Packet *p)
367 {
368  Packet *rp = NULL;
369 
370  /* Should not be here unless we have seen the last fragment. */
371  if (!tracker->seen_last)
372  return NULL;
373 
374  /* Check that we have the first fragment and its of a valid size. */
375  Frag *first = RB_MIN(IP_FRAGMENTS, &tracker->fragment_tree);
376  if (first == NULL) {
377  goto done;
378  } else if (first->offset != 0) {
379  /* Still waiting for the first fragment. */
380  goto done;
381  } else if (first->len < sizeof(IPV6Hdr)) {
382  /* First fragment isn't enough for an IPv6 header. */
383  goto error_remove_tracker;
384  }
385 
386  /* Check that we have all the data. Relies on the fact that
387  * fragments are inserted if frag_offset order. */
388  size_t len = 0;
389  Frag *frag = NULL;
390  RB_FOREACH_FROM(frag, IP_FRAGMENTS, first) {
391  if (frag->skip) {
392  continue;
393  }
394 
395  if (frag == first) {
396  if (frag->offset != 0) {
397  goto done;
398  }
399  len = frag->data_len;
400  }
401  else {
402  if (frag->offset > len) {
403  /* This fragment starts after the end of the previous
404  * fragment. We have a hole. */
405  goto done;
406  }
407  else {
408  len = MAX(len, frag->offset + frag->data_len);
409  }
410  }
411  }
412 
413  const IPV6Hdr *oip6h = PacketGetIPv6(p);
414 
415  /* Allocate a Packet for the reassembled packet. On failure we
416  * SCFree all the resources held by this tracker. */
418  p, (const uint8_t *)oip6h, IPV6_GET_RAW_PLEN(oip6h) + sizeof(IPV6Hdr), 0);
419  if (rp == NULL) {
420  goto error_remove_tracker;
421  }
424  rp->datalink = tracker->datalink;
425 
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;
431 
432  /* Assume more frags. */
433  uint16_t prev_offset = 0;
434  bool more_frags = 1;
435 
436  RB_FOREACH(frag, IP_FRAGMENTS, &tracker->fragment_tree) {
437  if (!more_frags && frag->offset > prev_offset) {
438  break;
439  }
440  if (frag->skip)
441  continue;
442  if (frag->data_len - frag->ltrim <= 0)
443  continue;
444  if (frag->offset == 0) {
445  IPV6FragHdr *frag_hdr = (IPV6FragHdr *)(frag->pkt +
446  frag->frag_hdr_offset);
447  next_hdr = frag_hdr->ip6fh_nxt;
448 
449  /* This is the first packet, we use this packets link and
450  * IPv6 headers. We also copy in its data, but remove the
451  * fragmentation header. */
452  if (PacketCopyData(rp, frag->pkt, frag->frag_hdr_offset) == -1)
453  goto error_remove_tracker;
455  frag->pkt + frag->frag_hdr_offset + sizeof(IPV6FragHdr),
456  frag->data_len) == -1)
457  goto error_remove_tracker;
458  ip_hdr_offset = tracker->ip_hdr_offset;
459 
460  /* This is the start of the fragmentable portion of the
461  * first packet. All fragment offsets are relative to
462  * this. */
463  fragmentable_offset = frag->frag_hdr_offset;
464  fragmentable_len = frag->data_len;
465 
466  /* unfragmentable part is the part between the ipv6 header
467  * and the frag header. */
468  DEBUG_VALIDATE_BUG_ON(fragmentable_offset < ip_hdr_offset + IPV6_HEADER_LEN);
470  fragmentable_offset - ip_hdr_offset - IPV6_HEADER_LEN > UINT16_MAX);
471  unfragmentable_len = (uint16_t)(fragmentable_offset - ip_hdr_offset - IPV6_HEADER_LEN);
472  if (unfragmentable_len >= fragmentable_offset)
473  goto error_remove_tracker;
474  }
475  else {
476  if (PacketCopyDataOffset(rp, fragmentable_offset + frag->offset + frag->ltrim,
477  frag->pkt + frag->data_offset + frag->ltrim,
478  frag->data_len - frag->ltrim) == -1)
479  goto error_remove_tracker;
480  if (frag->offset + frag->data_len > fragmentable_len)
481  fragmentable_len = frag->offset + frag->data_len;
482  }
483 
484  /* Even if this fragment is flagged as having no more
485  * fragments, still continue. The next fragment may have the
486  * same offset with data that is preferred.
487  *
488  * For example, DefragBsdFragmentAfterNoMfIpv{4,6}Test
489  *
490  * This is due to not all fragments being completely trimmed,
491  * but relying on the copy ordering. */
492  more_frags = frag->more_frags;
493  prev_offset = frag->offset;
494  }
495 
496  const uint32_t payload_len = (uint32_t)unfragmentable_len + fragmentable_len;
497  if (payload_len > IPV6_MAXPACKET) {
499  goto error_remove_tracker;
500  }
501 
502  IPV6Hdr *ip6h = (IPV6Hdr *)(GET_PKT_DATA(rp) + tracker->ip_hdr_offset);
503  ip6h->s_ip6_plen = htons((uint16_t)payload_len);
504  /* if we have no unfragmentable part, so no ext hdrs before the frag
505  * header, we need to update the ipv6 headers next header field. This
506  * points to the frag header, and we will make it point to the layer
507  * directly after the frag header. */
508  if (unfragmentable_len == 0)
509  ip6h->s_ip6_nxt = next_hdr;
510  SET_PKT_LEN(rp, ip_hdr_offset + sizeof(IPV6Hdr) + payload_len);
511 
512  tracker->remove = 1;
513  DefragTrackerFreeFrags(tracker);
514 done:
515  return rp;
516 
517 error_remove_tracker:
518  tracker->remove = 1;
519  DefragTrackerFreeFrags(tracker);
520  if (rp != NULL)
522  return NULL;
523 }
524 
525 /**
526  * The RB_TREE compare function for fragments.
527  *
528  * When it comes to adding fragments, we want subsequent ones with the
529  * same offset to be treated as greater than, so we don't have an
530  * equal return value here.
531  */
532 int DefragRbFragCompare(struct Frag_ *a, struct Frag_ *b) {
533  if (a->offset < b->offset) {
534  return -1;
535  }
536  return 1;
537 }
538 
539 /**
540  * \brief Trim following fragments overlapped by a BSD-preferred fragment.
541  *
542  * Only fragments starting after the new one are trimmed. Fully covered
543  * fragments are removed, partially covered fragments have their left
544  * trim increased.
545  */
546 static void DefragBsdTrimFollowing(
547  DefragTracker *tracker, Frag *next, uint16_t frag_offset, uint16_t frag_end)
548 {
549  while ((next != NULL) && (frag_end > next->offset)) {
550  Frag *following = IP_FRAGMENTS_RB_NEXT(next);
551  if (next->offset <= frag_offset) {
552  /* Starts at or before the new fragment, its data is preferred. */
553  next = following;
554  continue;
555  }
556  uint16_t next_ltrim = frag_end - next->offset;
557  if (next_ltrim >= next->data_len) {
558  RB_REMOVE(IP_FRAGMENTS, &tracker->fragment_tree, next);
559  DefragFragReset(next);
560  SCMutexLock(&defrag_context->frag_pool_lock);
561  PoolReturn(defrag_context->frag_pool, next);
562  SCMutexUnlock(&defrag_context->frag_pool_lock);
563  } else if (next_ltrim > next->ltrim) {
564  next->ltrim = next_ltrim;
565  }
566  next = following;
567  }
568 }
569 
570 /**
571  * Insert a new IPv4/IPv6 fragment into a tracker.
572  *
573  * \todo Allocate packet buffers from a pool.
574  */
575 static Packet *
576 DefragInsertFrag(ThreadVars *tv, DecodeThreadVars *dtv, DefragTracker *tracker, Packet *p)
577 {
578  Packet *r = NULL;
579  uint16_t ltrim = 0;
580 
581  bool more_frags;
582  uint16_t frag_offset;
583 
584  /* IPv4 header length - IPv4 only. */
585  uint8_t hlen = 0;
586 
587  /* This is the offset of the start of the data in the packet that
588  * falls after the IP header. */
589  uint16_t data_offset;
590 
591  /* The length of the (fragmented) data. This is the length of the
592  * data that falls after the IP header. */
593  uint16_t data_len;
594 
595  /* Where the fragment ends. */
596  uint16_t frag_end;
597 
598  /* Offset in the packet to the IPv6 header. */
599  uint16_t ip_hdr_offset;
600 
601  /* Offset in the packet to the IPv6 frag header. IPv6 only. */
602  uint16_t frag_hdr_offset = 0;
603 
604  /* Address family */
605  int af = tracker->af;
606 
607  /* settings for updating a payload when an ip6 fragment with
608  * unfragmentable exthdrs are encountered. */
609  uint32_t ip6_nh_set_offset = 0;
610  uint8_t ip6_nh_set_value = 0;
611 
612 #ifdef DEBUG
613  uint64_t pcap_cnt = PcapPacketCntGet(p);
614 #endif
615 
616  if (tracker->af == AF_INET) {
617  const IPV4Hdr *ip4h = PacketGetIPv4(p);
618  more_frags = IPV4_GET_RAW_FLAG_MF(ip4h);
619  frag_offset = (uint16_t)((uint16_t)IPV4_GET_RAW_FRAGOFFSET(ip4h) << (uint16_t)3);
620  hlen = IPV4_GET_RAW_HLEN(ip4h);
621  data_offset = (uint16_t)((uint8_t *)ip4h + hlen - GET_PKT_DATA(p));
622  data_len = IPV4_GET_RAW_IPLEN(ip4h) - hlen;
623  ip_hdr_offset = (uint16_t)((uint8_t *)ip4h - GET_PKT_DATA(p));
624 
625  /* Ignore fragment if the end of packet extends past the
626  * maximum size of a packet. */
627  if (IPV4_HEADER_LEN + frag_offset + data_len > IPV4_MAXPACKET_LEN) {
629  return NULL;
630  }
631  /* the check above ensures the sum fits in frag_end */
632  frag_end = (uint16_t)(frag_offset + data_len);
633  }
634  else if (tracker->af == AF_INET6) {
635  const IPV6Hdr *ip6h = PacketGetIPv6(p);
636  more_frags = IPV6_EXTHDR_GET_FH_FLAG(p);
637  frag_offset = IPV6_EXTHDR_GET_FH_OFFSET(p);
638  data_offset = p->l3.vars.ip6.eh.fh_data_offset;
639  data_len = p->l3.vars.ip6.eh.fh_data_len;
640 
641  /* Ignore fragment if the end of packet extends past the
642  * maximum size of a packet. */
643  if (frag_offset + data_len > IPV6_MAXPACKET) {
645  return NULL;
646  }
647  /* the check above ensures the sum fits in frag_end */
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;
651 
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);
656 
657  /* handle unfragmentable exthdrs */
658  if (ip_hdr_offset + IPV6_HEADER_LEN < frag_hdr_offset) {
659  SCLogDebug("we have exthdrs before fraghdr %u bytes",
660  (uint32_t)(frag_hdr_offset - (ip_hdr_offset + IPV6_HEADER_LEN)));
661 
662  /* get the offset of the 'next' field in exthdr before the FH,
663  * relative to the buffer start */
664 
665  /* store offset and FH 'next' value for updating frag buffer below */
666  ip6_nh_set_offset = p->l3.vars.ip6.eh.fh_prev_hdr_offset;
667  ip6_nh_set_value = IPV6_EXTHDR_GET_FH_NH(p);
668  SCLogDebug("offset %d, value %u", ip6_nh_set_offset, ip6_nh_set_value);
669  }
670  }
671  else {
673  return NULL;
674  }
675 
676  /* Update timeout. */
677  tracker->timeout = SCTIME_FROM_SECS(SCTIME_SECS(p->ts) + tracker->host_timeout);
678 
679  Frag *prev = NULL, *next = NULL;
680  bool overlap = false;
681  ltrim = 0;
682 
683  if (!RB_EMPTY(&tracker->fragment_tree)) {
684  Frag key = {
685  .offset = frag_offset ? frag_offset - 1 : 0,
686  };
687  next = RB_NFIND(IP_FRAGMENTS, &tracker->fragment_tree, &key);
688  if (next == NULL) {
689  prev = RB_MIN(IP_FRAGMENTS, &tracker->fragment_tree);
690  next = IP_FRAGMENTS_RB_NEXT(prev);
691  } else {
692  prev = IP_FRAGMENTS_RB_PREV(next);
693  if (prev == NULL) {
694  prev = next;
695  next = IP_FRAGMENTS_RB_NEXT(prev);
696  }
697  }
698  while (prev != NULL) {
699  if (prev->skip) {
700  goto next;
701  }
702  if (frag_offset < prev->offset + prev->data_len && prev->offset < frag_end) {
703  overlap = true;
704  }
705 
706  switch (tracker->policy) {
707  case DEFRAG_POLICY_BSD:
708  if (frag_offset < prev->offset + prev->data_len) {
709  if (prev->offset <= frag_offset) {
710  /* We prefer the data from the previous
711  * fragment, so trim off the data in the new
712  * fragment that exists in the previous
713  * fragment. */
714  uint16_t prev_end = prev->offset + prev->data_len;
715  if (prev_end > frag_end) {
716  /* Just skip. */
717  /* TODO: Set overlap flag. */
718  goto done;
719  }
720  ltrim = prev_end - frag_offset;
721 
722  DefragBsdTrimFollowing(tracker, next, frag_offset, frag_end);
723 
724  goto insert;
725  }
726 
727  /* If the end of this fragment overlaps the start
728  * of the previous fragment, then trim up the
729  * start of previous fragment so this fragment is
730  * used.
731  *
732  * See:
733  * DefragBsdSubsequentOverlapsStartOfOriginal.
734  */
735  if (frag_offset <= prev->offset && frag_end > prev->offset + prev->ltrim) {
736  uint16_t prev_ltrim = frag_end - prev->offset;
737  if (prev_ltrim > prev->ltrim) {
738  prev->ltrim = prev_ltrim;
739  }
740  }
741 
742  DefragBsdTrimFollowing(tracker, next, frag_offset, frag_end);
743 
744  goto insert;
745  }
746  break;
747  case DEFRAG_POLICY_LINUX:
748  /* Check if new fragment overlaps the end of previous
749  * fragment, if it does, trim the new fragment.
750  *
751  * Old: AAAAAAAA AAAAAAAA AAAAAAAA
752  * New: BBBBBBBB BBBBBBBB BBBBBBBB
753  * Res: AAAAAAAA AAAAAAAA AAAAAAAA BBBBBBBB
754  */
755  if (prev->offset + prev->ltrim < frag_offset + ltrim &&
756  prev->offset + prev->data_len > frag_offset + ltrim) {
757  ltrim += prev->offset + prev->data_len - frag_offset;
758  }
759 
760  /* Check if new fragment overlaps the beginning of
761  * previous fragment, if it does, tim the previous
762  * fragment.
763  *
764  * Old: AAAAAAAA AAAAAAAA
765  * New: BBBBBBBB BBBBBBBB BBBBBBBB
766  * Res: BBBBBBBB BBBBBBBB BBBBBBBB
767  */
768  if (frag_offset + ltrim < prev->offset + prev->ltrim &&
769  frag_end > prev->offset + prev->ltrim) {
770  prev->ltrim += frag_end - (prev->offset + prev->ltrim);
771  goto insert;
772  }
773 
774  /* If the new fragment completely overlaps the
775  * previous fragment, mark the previous to be
776  * skipped. Re-assembly would succeed without doing
777  * this, but this will prevent the bytes from being
778  * copied just to be overwritten. */
779  if (frag_offset + ltrim <= prev->offset + prev->ltrim &&
780  frag_end >= prev->offset + prev->data_len) {
781  prev->skip = 1;
782  goto insert;
783  }
784 
785  break;
787  /* If new fragment fits inside a previous fragment, drop it. */
788  if (frag_offset + ltrim >= prev->offset + ltrim &&
789  frag_end <= prev->offset + prev->data_len) {
790  goto done;
791  }
792 
793  /* If new fragment starts before and ends after
794  * previous fragment, drop the previous fragment. */
795  if (frag_offset + ltrim < prev->offset + ltrim &&
796  frag_end > prev->offset + prev->data_len) {
797  prev->skip = 1;
798  goto insert;
799  }
800 
801  /* Check if new fragment overlaps the end of previous
802  * fragment, if it does, trim the new fragment.
803  *
804  * Old: AAAAAAAA AAAAAAAA AAAAAAAA
805  * New: BBBBBBBB BBBBBBBB BBBBBBBB
806  * Res: AAAAAAAA AAAAAAAA AAAAAAAA BBBBBBBB
807  */
808  if (frag_offset + ltrim > prev->offset + prev->ltrim &&
809  frag_offset + ltrim < prev->offset + prev->data_len) {
810  ltrim += prev->offset + prev->data_len - frag_offset;
811  goto insert;
812  }
813 
814  /* If new fragment starts at same offset as an
815  * existing fragment, but ends after it, trim the new
816  * fragment. */
817  if (frag_offset + ltrim == prev->offset + ltrim &&
818  frag_end > prev->offset + prev->data_len) {
819  ltrim += prev->offset + prev->data_len - frag_offset;
820  goto insert;
821  }
822  break;
824  if (frag_offset < prev->offset + prev->data_len) {
825  if (frag_offset >= prev->offset) {
826  ltrim = prev->offset + prev->data_len - frag_offset;
827  }
828  if ((frag_offset < prev->offset) &&
829  (frag_end >= prev->offset + prev->data_len)) {
830  prev->skip = 1;
831  }
832  goto insert;
833  }
834  break;
835  case DEFRAG_POLICY_FIRST:
836  if ((frag_offset >= prev->offset) &&
837  (frag_end <= prev->offset + prev->data_len)) {
838  goto done;
839  }
840  if (frag_offset < prev->offset) {
841  goto insert;
842  }
843  if (frag_offset < prev->offset + prev->data_len) {
844  ltrim = prev->offset + prev->data_len - frag_offset;
845  goto insert;
846  }
847  break;
848  case DEFRAG_POLICY_LAST:
849  if (frag_offset <= prev->offset) {
850  if (frag_end > prev->offset) {
851  prev->ltrim = frag_end - prev->offset;
852  }
853  goto insert;
854  }
855  break;
856  default:
857  break;
858  }
859 
860  next:
861  prev = next;
862  if (next != NULL) {
863  next = IP_FRAGMENTS_RB_NEXT(next);
864  }
865  continue;
866 
867  insert:
868  /* If existing fragment has been trimmed up completely
869  * (complete overlap), remove it now instead of holding
870  * onto it. */
871  if (prev->skip || prev->ltrim >= prev->data_len) {
872  RB_REMOVE(IP_FRAGMENTS, &tracker->fragment_tree, prev);
873  DefragFragReset(prev);
874  SCMutexLock(&defrag_context->frag_pool_lock);
875  PoolReturn(defrag_context->frag_pool, prev);
876  SCMutexUnlock(&defrag_context->frag_pool_lock);
877  }
878  break;
879  }
880  }
881 
882  if (ltrim >= data_len) {
883  /* Full packet has been trimmed due to the overlap policy. Overlap
884  * already set. */
885  goto done;
886  }
887 
888  /* Allocate fragment and insert. */
889  SCMutexLock(&defrag_context->frag_pool_lock);
890  Frag *new = PoolGet(defrag_context->frag_pool);
891  SCMutexUnlock(&defrag_context->frag_pool_lock);
892  if (new == NULL) {
893  if (af == AF_INET) {
895  } else {
897  }
898  if (tv != NULL && dtv != NULL) {
900  }
901  goto error_remove_tracker;
902  }
903  new->pkt = SCMalloc(GET_PKT_LEN(p));
904  if (new->pkt == NULL) {
905  SCMutexLock(&defrag_context->frag_pool_lock);
906  PoolReturn(defrag_context->frag_pool, new);
907  SCMutexUnlock(&defrag_context->frag_pool_lock);
908  if (af == AF_INET) {
910  } else {
912  }
913  goto error_remove_tracker;
914  }
915  memcpy(new->pkt, GET_PKT_DATA(p) + ltrim, GET_PKT_LEN(p) - ltrim);
916  new->len = (GET_PKT_LEN(p) - ltrim);
917  /* in case of unfragmentable exthdrs, update the 'next hdr' field
918  * in the raw buffer so the reassembled packet will point to the
919  * correct next header after stripping the frag header */
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;
925  }
926  }
927 
928  new->hlen = hlen;
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;
934 #ifdef DEBUG
935  new->pcap_cnt = pcap_cnt;
936 #endif
937  if (new->offset == 0) {
938  tracker->ip_hdr_offset = ip_hdr_offset;
939  tracker->datalink = p->datalink;
940  }
941 
942  IP_FRAGMENTS_RB_INSERT(&tracker->fragment_tree, new);
943 
944  if (!more_frags) {
945  tracker->seen_last = 1;
946  }
947 
948  if (tracker->seen_last) {
949  if (tracker->af == AF_INET) {
950  r = Defrag4Reassemble(tv, tracker, p);
951  if (r != NULL && tv != NULL && dtv != NULL) {
953  }
954  }
955  else if (tracker->af == AF_INET6) {
956  r = Defrag6Reassemble(tv, tracker, p);
957  if (r != NULL && tv != NULL && dtv != NULL) {
959  }
960  }
961  }
962 
963 
964 done:
965  if (overlap) {
966  if (af == AF_INET) {
968  }
969  else {
971  }
972  }
973  return r;
974 error_remove_tracker:
975  tracker->remove = 1;
976  DefragTrackerFreeFrags(tracker);
977  return NULL;
978 }
979 
980 /**
981  * \brief Get the defrag policy based on the destination address of
982  * the packet.
983  *
984  * \param p The packet used to get the destination address.
985  *
986  * \retval The defrag policy to use.
987  */
988 uint8_t
990 {
991  int policy = -1;
992 
993  if (PacketIsIPv4(p)) {
995  } else if (PacketIsIPv6(p)) {
996  policy = SCHInfoGetIPv6HostOSFlavour((uint8_t *)GET_IPV6_DST_ADDR(p));
997  }
998 
999  if (policy == -1) {
1000  return default_policy;
1001  }
1002 
1003  /* Map the OS policies returned from the configured host info to
1004  * defrag specific policies. */
1005  switch (policy) {
1006  /* BSD. */
1007  case OS_POLICY_BSD:
1008  case OS_POLICY_HPUX10:
1009  case OS_POLICY_IRIX:
1010  return DEFRAG_POLICY_BSD;
1011 
1012  /* BSD-Right. */
1013  case OS_POLICY_BSD_RIGHT:
1014  return DEFRAG_POLICY_BSD_RIGHT;
1015 
1016  /* Linux. */
1017  case OS_POLICY_OLD_LINUX:
1018  case OS_POLICY_LINUX:
1019  return DEFRAG_POLICY_LINUX;
1020 
1021  /* First. */
1022  case OS_POLICY_OLD_SOLARIS:
1023  case OS_POLICY_HPUX11:
1024  case OS_POLICY_MACOS:
1025  case OS_POLICY_FIRST:
1026  return DEFRAG_POLICY_FIRST;
1027 
1028  /* Solaris. */
1029  case OS_POLICY_SOLARIS:
1030  return DEFRAG_POLICY_SOLARIS;
1031 
1032  /* Windows. */
1033  case OS_POLICY_WINDOWS:
1034  case OS_POLICY_VISTA:
1035  case OS_POLICY_WINDOWS2K3:
1036  return DEFRAG_POLICY_WINDOWS;
1037 
1038  /* Last. */
1039  case OS_POLICY_LAST:
1040  return DEFRAG_POLICY_LAST;
1041 
1042  default:
1043  return default_policy;
1044  }
1045 }
1046 
1047 /** \internal
1048  *
1049  * \retval NULL or a *LOCKED* tracker */
1050 static DefragTracker *
1051 DefragGetTracker(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p)
1052 {
1053  return DefragGetTrackerFromHash(tv, dtv, p);
1054 }
1055 
1056 /**
1057  * \brief Entry point for IPv4 and IPv6 fragments.
1058  *
1059  * \param tv ThreadVars for the calling decoder.
1060  * \param p The packet fragment.
1061  *
1062  * \retval A new Packet resembling the re-assembled packet if the most
1063  * recent fragment allowed the packet to be re-assembled, otherwise
1064  * NULL is returned.
1065  */
1066 Packet *
1068 {
1069  uint16_t frag_offset;
1070  uint8_t more_frags;
1071  DefragTracker *tracker;
1072  int af;
1073 
1074  if (PacketIsIPv4(p)) {
1075  const IPV4Hdr *ip4h = PacketGetIPv4(p);
1076  af = AF_INET;
1077  more_frags = IPV4_GET_RAW_FLAG_MF(ip4h);
1078  frag_offset = IPV4_GET_RAW_FRAGOFFSET(ip4h);
1079  } else if (PacketIsIPv6(p)) {
1080  af = AF_INET6;
1081  frag_offset = IPV6_EXTHDR_GET_FH_OFFSET(p);
1082  more_frags = IPV6_EXTHDR_GET_FH_FLAG(p);
1083  } else {
1084  return NULL;
1085  }
1086 
1087  if (frag_offset == 0 && more_frags == 0) {
1088  return NULL;
1089  }
1090 
1091  if (af == AF_INET) {
1093  } else if (af == AF_INET6) {
1095  }
1096 
1097  /* return a locked tracker or NULL */
1098  tracker = DefragGetTracker(tv, dtv, p);
1099  if (tracker == NULL) {
1100  if (tv != NULL && dtv != NULL) {
1102  }
1103  return NULL;
1104  }
1105 
1106  Packet *rp = DefragInsertFrag(tv, dtv, tracker, p);
1107 
1108  /* Capture tracker fields while still holding the lock. ip_hdr_offset is set
1109  * inside DefragInsertFrag when the first fragment (offset 0) is inserted, so
1110  * it must be read after that call returns. */
1111  int tracker_af = tracker->af;
1112  uint16_t tracker_ip_hdr_offset = tracker->ip_hdr_offset;
1113 
1114  /* Release the tracker lock BEFORE decoding the reassembled packet.
1115  * This prevents re-entrant Defrag() calls (via tunnel decode) from
1116  * deadlocking on tracker locks held by other threads. */
1117  DefragTrackerRelease(tracker);
1118 
1119  if (rp != NULL) {
1120  const uint32_t len = GET_PKT_LEN(rp) - (uint32_t)tracker_ip_hdr_offset;
1121  int decode_rc;
1122  if (tracker_af == AF_INET) {
1123  DEBUG_VALIDATE_BUG_ON(len > UINT16_MAX);
1124  decode_rc = DecodeIPV4(
1125  tv, dtv, rp, GET_PKT_DATA(rp) + tracker_ip_hdr_offset, (uint16_t)len);
1126  } else {
1127  decode_rc = DecodeIPV6(tv, dtv, rp, GET_PKT_DATA(rp) + tracker_ip_hdr_offset, len);
1128  }
1129  if (decode_rc != TM_ECODE_OK) {
1130  rp->root = NULL;
1131  TmqhOutputPacketpool(tv, rp);
1132  rp = NULL;
1133  } else {
1135  }
1136  }
1137 
1138  return rp;
1139 }
1140 
1141 void
1143 {
1144  intmax_t tracker_pool_size;
1145  if (!SCConfGetInt("defrag.trackers", &tracker_pool_size)) {
1146  tracker_pool_size = DEFAULT_DEFRAG_HASH_SIZE;
1147  }
1148 
1149  /* Load the defrag-per-host lookup. */
1151 
1152  /* Allocate the DefragContext. */
1153  defrag_context = DefragContextNew();
1154  if (defrag_context == NULL) {
1155  FatalError("Failed to allocate memory for the Defrag module.");
1156  }
1157 
1158  DefragSetDefaultTimeout(defrag_context->timeout);
1159  DefragInitConfig(false);
1160 }
1161 
1162 void DefragDestroy(void)
1163 {
1165  DefragContextDestroy(defrag_context);
1166  defrag_context = NULL;
1168 }
1169 
1170 #ifdef UNITTESTS
1171 #include "util-unittest-helper.h"
1172 #include "packet.h"
1173 
1174 #define IP_MF 0x2000
1178 
1179 /**
1180  * Allocate a test packet. Nothing to fancy, just a simple IP packet
1181  * with some payload of no particular protocol.
1182  */
1183 static Packet *BuildIpv4TestPacket(
1184  uint8_t proto, uint16_t id, uint16_t off, int mf, const char content, int content_len)
1185 {
1186  Packet *p = NULL;
1187  int hlen = 20;
1188  int ttl = 64;
1189  uint8_t *pcontent;
1190  IPV4Hdr ip4h;
1191 
1192  p = SCCalloc(1, sizeof(*p) + default_packet_size);
1193  if (unlikely(p == NULL))
1194  return NULL;
1195 
1196  if (!PacketInit(p)) {
1197  SCFree(p);
1198  return NULL;
1199  }
1200 
1201  struct timeval tval;
1202  gettimeofday(&tval, NULL);
1203  p->ts = SCTIME_FROM_TIMEVAL(&tval);
1204  //p->ip4h = (IPV4Hdr *)GET_PKT_DATA(p);
1205  ip4h.ip_verhl = 4 << 4;
1206  ip4h.ip_verhl |= hlen >> 2;
1207  ip4h.ip_len = htons(hlen + content_len);
1208  ip4h.ip_id = htons(id);
1209  if (mf)
1210  ip4h.ip_off = htons(IP_MF | off);
1211  else
1212  ip4h.ip_off = htons(off);
1213  ip4h.ip_ttl = ttl;
1214  ip4h.ip_proto = proto;
1215 
1216  ip4h.s_ip_src.s_addr = 0x01010101; /* 1.1.1.1 */
1217  ip4h.s_ip_dst.s_addr = 0x02020202; /* 2.2.2.2 */
1218 
1219  /* copy content_len crap, we need full length */
1220  PacketCopyData(p, (uint8_t *)&ip4h, sizeof(ip4h));
1221  IPV4Hdr *ip4p = PacketSetIPV4(p, GET_PKT_DATA(p));
1222  SET_IPV4_SRC_ADDR(ip4p, &p->src);
1223  SET_IPV4_DST_ADDR(ip4p, &p->dst);
1224 
1225  pcontent = SCCalloc(1, content_len);
1226  if (unlikely(pcontent == NULL))
1227  return NULL;
1228  memset(pcontent, content, content_len);
1229  PacketCopyDataOffset(p, hlen, pcontent, content_len);
1230  SET_PKT_LEN(p, hlen + content_len);
1231  SCFree(pcontent);
1232 
1233  ip4p->ip_csum = IPV4Checksum((uint16_t *)GET_PKT_DATA(p), hlen, 0);
1234 
1235  /* Self test. */
1236  FAIL_IF(IPV4_GET_RAW_VER(ip4p) != 4);
1237  FAIL_IF(IPV4_GET_RAW_HLEN(ip4p) != hlen);
1238  FAIL_IF(IPV4_GET_RAW_IPLEN(ip4p) != hlen + content_len);
1239  FAIL_IF(IPV4_GET_RAW_IPID(ip4p) != id);
1240  FAIL_IF(IPV4_GET_RAW_FRAGOFFSET(ip4p) != off);
1241  FAIL_IF(IPV4_GET_RAW_FLAG_MF(ip4p) != mf);
1242  FAIL_IF(IPV4_GET_RAW_IPTTL(ip4p) != ttl);
1244 
1245  return p;
1246 }
1247 
1248 /**
1249  * Allocate a test packet, much like BuildIpv4TestPacket, but with
1250  * the full content provided by the caller.
1251  */
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)
1254 {
1255  Packet *p = NULL;
1256  int hlen = 20;
1257  int ttl = 64;
1258  IPV4Hdr ip4h;
1259 
1260  p = SCCalloc(1, sizeof(*p) + default_packet_size);
1261  FAIL_IF_NULL(p);
1262 
1263  FAIL_IF(!PacketInit(p));
1264 
1265  struct timeval tval;
1266  gettimeofday(&tval, NULL);
1267  p->ts = SCTIME_FROM_TIMEVAL(&tval);
1268  ip4h.ip_verhl = 4 << 4;
1269  ip4h.ip_verhl |= hlen >> 2;
1270  ip4h.ip_len = htons(hlen + content_len);
1271  ip4h.ip_id = htons(id);
1272  if (mf)
1273  ip4h.ip_off = htons(IP_MF | off);
1274  else
1275  ip4h.ip_off = htons(off);
1276  ip4h.ip_ttl = ttl;
1277  ip4h.ip_proto = proto;
1278 
1279  ip4h.s_ip_src.s_addr = 0x01010101; /* 1.1.1.1 */
1280  ip4h.s_ip_dst.s_addr = 0x02020202; /* 2.2.2.2 */
1281 
1282  /* copy content_len crap, we need full length */
1283  PacketCopyData(p, (uint8_t *)&ip4h, sizeof(ip4h));
1284  IPV4Hdr *ip4p = PacketSetIPV4(p, GET_PKT_DATA(p));
1285  SET_IPV4_SRC_ADDR(ip4p, &p->src);
1286  SET_IPV4_DST_ADDR(ip4p, &p->dst);
1287 
1288  PacketCopyDataOffset(p, hlen, content, content_len);
1289  SET_PKT_LEN(p, hlen + content_len);
1290 
1291  ip4p->ip_csum = IPV4Checksum((uint16_t *)GET_PKT_DATA(p), hlen, 0);
1292 
1293  /* Self test. */
1294  FAIL_IF(IPV4_GET_RAW_VER(ip4p) != 4);
1295  FAIL_IF(IPV4_GET_RAW_HLEN(ip4p) != hlen);
1296  FAIL_IF(IPV4_GET_RAW_IPLEN(ip4p) != hlen + content_len);
1297  FAIL_IF(IPV4_GET_RAW_IPID(ip4p) != id);
1298  FAIL_IF(IPV4_GET_RAW_FRAGOFFSET(ip4p) != off);
1299  FAIL_IF(IPV4_GET_RAW_FLAG_MF(ip4p) != mf);
1300  FAIL_IF(IPV4_GET_RAW_IPTTL(ip4p) != ttl);
1302 
1303  *packet = p;
1304  PASS;
1305 }
1306 
1307 static Packet *BuildIpv6TestPacket(
1308  uint8_t proto, uint32_t id, uint16_t off, int mf, const uint8_t content, int content_len)
1309 {
1310  Packet *p = NULL;
1311  uint8_t *pcontent;
1312  IPV6Hdr ip6h;
1313 
1314  p = SCCalloc(1, sizeof(*p) + default_packet_size);
1315  if (unlikely(p == NULL))
1316  return NULL;
1317 
1318  if (!PacketInit(p)) {
1319  SCFree(p);
1320  return NULL;
1321  }
1322 
1323  struct timeval tval;
1324  gettimeofday(&tval, NULL);
1325  p->ts = SCTIME_FROM_TIMEVAL(&tval);
1326 
1327  ip6h.s_ip6_nxt = 44;
1328  ip6h.s_ip6_hlim = 2;
1329 
1330  /* Source and dest address - very bogus addresses. */
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;
1339 
1340  /* copy content_len crap, we need full length */
1341  PacketCopyData(p, (uint8_t *)&ip6h, sizeof(IPV6Hdr));
1342 
1343  IPV6Hdr *ip6p = PacketSetIPV6(p, GET_PKT_DATA(p));
1344  IPV6_SET_RAW_VER(ip6p, 6);
1345  /* Fragmentation header. */
1346  IPV6FragHdr *fh = (IPV6FragHdr *)(GET_PKT_DATA(p) + sizeof(IPV6Hdr));
1347  fh->ip6fh_nxt = proto;
1348  fh->ip6fh_ident = htonl(id);
1349  fh->ip6fh_offlg = htons((off << 3) | mf);
1350 
1351  DecodeIPV6FragHeader(p, (uint8_t *)fh, 8, 8 + content_len, 0);
1352 
1353  pcontent = SCCalloc(1, content_len);
1354  if (unlikely(pcontent == NULL))
1355  return NULL;
1356  memset(pcontent, content, content_len);
1357  PacketCopyDataOffset(p, sizeof(IPV6Hdr) + sizeof(IPV6FragHdr), pcontent, content_len);
1358  SET_PKT_LEN(p, sizeof(IPV6Hdr) + sizeof(IPV6FragHdr) + content_len);
1359  SCFree(pcontent);
1360 
1361  ip6p->s_ip6_plen = htons(sizeof(IPV6FragHdr) + content_len);
1362 
1363  SET_IPV6_SRC_ADDR(ip6p, &p->src);
1364  SET_IPV6_DST_ADDR(ip6p, &p->dst);
1365 
1366  /* Self test. */
1367  if (IPV6_GET_RAW_VER(ip6p) != 6)
1368  goto error;
1369  if (IPV6_GET_RAW_NH(ip6p) != 44)
1370  goto error;
1371  if (IPV6_GET_RAW_PLEN(ip6p) != sizeof(IPV6FragHdr) + content_len)
1372  goto error;
1373 
1374  return p;
1375 error:
1376  if (p != NULL)
1377  PacketFree(p);
1378  return NULL;
1379 }
1380 
1381 static Packet *BuildIpv6TestPacketWithContent(
1382  uint8_t proto, uint32_t id, uint16_t off, int mf, const uint8_t *content, int content_len)
1383 {
1384  Packet *p = NULL;
1385  IPV6Hdr ip6h;
1386 
1387  p = SCCalloc(1, sizeof(*p) + default_packet_size);
1388  if (unlikely(p == NULL))
1389  return NULL;
1390 
1391  if (!PacketInit(p)) {
1392  SCFree(p);
1393  return NULL;
1394  }
1395 
1396  struct timeval tval;
1397  gettimeofday(&tval, NULL);
1398  p->ts = SCTIME_FROM_TIMEVAL(&tval);
1399 
1400  ip6h.s_ip6_nxt = 44;
1401  ip6h.s_ip6_hlim = 2;
1402 
1403  /* Source and dest address - very bogus addresses. */
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;
1412 
1413  /* copy content_len crap, we need full length */
1414  PacketCopyData(p, (uint8_t *)&ip6h, sizeof(IPV6Hdr));
1415 
1416  IPV6Hdr *ip6p = PacketSetIPV6(p, GET_PKT_DATA(p));
1417  IPV6_SET_RAW_VER(ip6p, 6);
1418  /* Fragmentation header. */
1419  IPV6FragHdr *fh = (IPV6FragHdr *)(GET_PKT_DATA(p) + sizeof(IPV6Hdr));
1420  fh->ip6fh_nxt = proto;
1421  fh->ip6fh_ident = htonl(id);
1422  fh->ip6fh_offlg = htons((off << 3) | mf);
1423 
1424  DecodeIPV6FragHeader(p, (uint8_t *)fh, 8, 8 + content_len, 0);
1425 
1426  PacketCopyDataOffset(p, sizeof(IPV6Hdr) + sizeof(IPV6FragHdr), content, content_len);
1427  SET_PKT_LEN(p, sizeof(IPV6Hdr) + sizeof(IPV6FragHdr) + content_len);
1428 
1429  ip6p->s_ip6_plen = htons(sizeof(IPV6FragHdr) + content_len);
1430 
1431  SET_IPV6_SRC_ADDR(ip6p, &p->src);
1432  SET_IPV6_DST_ADDR(ip6p, &p->dst);
1433 
1434  /* Self test. */
1435  if (IPV6_GET_RAW_VER(ip6p) != 6)
1436  goto error;
1437  if (IPV6_GET_RAW_NH(ip6p) != 44)
1438  goto error;
1439  if (IPV6_GET_RAW_PLEN(ip6p) != sizeof(IPV6FragHdr) + content_len)
1440  goto error;
1441 
1442  return p;
1443 error:
1444  if (p != NULL)
1445  PacketFree(p);
1446  return NULL;
1447 }
1448 
1449 /**
1450  * Test the simplest possible re-assembly scenario. All packet in
1451  * order and no overlaps.
1452  */
1453 static int DefragInOrderSimpleTest(void)
1454 {
1455  Packet *p1 = NULL, *p2 = NULL, *p3 = NULL;
1456  Packet *reassembled = NULL;
1457  int id = 12;
1458 
1459  DefragInit();
1460 
1461  p1 = BuildIpv4TestPacket(IPPROTO_ICMP, id, 0, 1, 'A', 8);
1462  FAIL_IF_NULL(p1);
1463  p2 = BuildIpv4TestPacket(IPPROTO_ICMP, id, 1, 1, 'B', 8);
1464  FAIL_IF_NULL(p2);
1465  p3 = BuildIpv4TestPacket(IPPROTO_ICMP, id, 2, 0, 'C', 3);
1466  FAIL_IF_NULL(p3);
1467 
1468  FAIL_IF(Defrag(&test_tv, &test_dtv, p1) != NULL);
1469  FAIL_IF(Defrag(&test_tv, &test_dtv, p2) != NULL);
1470 
1471  reassembled = Defrag(&test_tv, &test_dtv, p3);
1472  FAIL_IF_NULL(reassembled);
1473 
1474  FAIL_IF(IPV4_GET_RAW_HLEN(PacketGetIPv4(reassembled)) != 20);
1475  FAIL_IF(IPV4_GET_RAW_IPLEN(PacketGetIPv4(reassembled)) != 39);
1476 
1477  /* 20 bytes in we should find 8 bytes of A. */
1478  for (int i = 20; i < 20 + 8; i++) {
1479  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'A');
1480  }
1481 
1482  /* 28 bytes in we should find 8 bytes of B. */
1483  for (int i = 28; i < 28 + 8; i++) {
1484  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'B');
1485  }
1486 
1487  /* And 36 bytes in we should find 3 bytes of C. */
1488  for (int i = 36; i < 36 + 3; i++) {
1489  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'C');
1490  }
1491 
1492  PacketFree(p1);
1493  PacketFree(p2);
1494  PacketFree(p3);
1495  PacketFree(reassembled);
1496 
1497  DefragDestroy();
1498  PASS;
1499 }
1500 
1501 /**
1502  * Simple fragmented packet in reverse order.
1503  */
1504 static int DefragReverseSimpleTest(void)
1505 {
1506  Packet *p1 = NULL, *p2 = NULL, *p3 = NULL;
1507  Packet *reassembled = NULL;
1508  int id = 12;
1509 
1510  DefragInit();
1511 
1512  p1 = BuildIpv4TestPacket(IPPROTO_ICMP, id, 0, 1, 'A', 8);
1513  FAIL_IF_NULL(p1);
1514  p2 = BuildIpv4TestPacket(IPPROTO_ICMP, id, 1, 1, 'B', 8);
1515  FAIL_IF_NULL(p2);
1516  p3 = BuildIpv4TestPacket(IPPROTO_ICMP, id, 2, 0, 'C', 3);
1517  FAIL_IF_NULL(p3);
1518 
1519  FAIL_IF(Defrag(&test_tv, &test_dtv, p3) != NULL);
1520  FAIL_IF(Defrag(&test_tv, &test_dtv, p2) != NULL);
1521  reassembled = Defrag(&test_tv, &test_dtv, p1);
1522  FAIL_IF_NULL(reassembled);
1523 
1524  FAIL_IF(IPV4_GET_RAW_HLEN(PacketGetIPv4(reassembled)) != 20);
1525  FAIL_IF(IPV4_GET_RAW_IPLEN(PacketGetIPv4(reassembled)) != 39);
1526 
1527  /* 20 bytes in we should find 8 bytes of A. */
1528  for (int i = 20; i < 20 + 8; i++) {
1529  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'A');
1530  }
1531 
1532  /* 28 bytes in we should find 8 bytes of B. */
1533  for (int i = 28; i < 28 + 8; i++) {
1534  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'B');
1535  }
1536 
1537  /* And 36 bytes in we should find 3 bytes of C. */
1538  for (int i = 36; i < 36 + 3; i++) {
1539  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'C');
1540  }
1541 
1542  PacketFree(p1);
1543  PacketFree(p2);
1544  PacketFree(p3);
1545  PacketFree(reassembled);
1546 
1547  DefragDestroy();
1548  PASS;
1549 }
1550 
1551 /**
1552  * Test the simplest possible re-assembly scenario. All packet in
1553  * order and no overlaps.
1554  */
1555 static int DefragInOrderSimpleIpv6Test(void)
1556 {
1557  Packet *p1 = NULL, *p2 = NULL, *p3 = NULL;
1558  Packet *reassembled = NULL;
1559  int id = 12;
1560 
1561  DefragInit();
1562 
1563  p1 = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 0, 1, 'A', 8);
1564  FAIL_IF_NULL(p1);
1565  p2 = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 1, 1, 'B', 8);
1566  FAIL_IF_NULL(p2);
1567  p3 = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 2, 0, 'C', 3);
1568  FAIL_IF_NULL(p3);
1569 
1570  FAIL_IF(Defrag(&test_tv, &test_dtv, p1) != NULL);
1571  FAIL_IF(Defrag(&test_tv, &test_dtv, p2) != NULL);
1572  reassembled = Defrag(&test_tv, &test_dtv, p3);
1573  FAIL_IF_NULL(reassembled);
1574 
1575  const IPV6Hdr *ip6h = PacketGetIPv6(reassembled);
1576  FAIL_IF(IPV6_GET_RAW_PLEN(ip6h) != 19);
1577 
1578  /* 40 bytes in we should find 8 bytes of A. */
1579  for (int i = 40; i < 40 + 8; i++) {
1580  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'A');
1581  }
1582 
1583  /* 28 bytes in we should find 8 bytes of B. */
1584  for (int i = 48; i < 48 + 8; i++) {
1585  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'B');
1586  }
1587 
1588  /* And 36 bytes in we should find 3 bytes of C. */
1589  for (int i = 56; i < 56 + 3; i++) {
1590  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'C');
1591  }
1592 
1593  PacketFree(p1);
1594  PacketFree(p2);
1595  PacketFree(p3);
1596  PacketFree(reassembled);
1597 
1598  DefragDestroy();
1599  PASS;
1600 }
1601 
1602 static int DefragReverseSimpleIpv6Test(void)
1603 {
1604  DefragContext *dc = NULL;
1605  Packet *p1 = NULL, *p2 = NULL, *p3 = NULL;
1606  Packet *reassembled = NULL;
1607  int id = 12;
1608 
1609  DefragInit();
1610 
1611  dc = DefragContextNew();
1612  FAIL_IF_NULL(dc);
1613 
1614  p1 = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 0, 1, 'A', 8);
1615  FAIL_IF_NULL(p1);
1616  p2 = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 1, 1, 'B', 8);
1617  FAIL_IF_NULL(p2);
1618  p3 = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 2, 0, 'C', 3);
1619  FAIL_IF_NULL(p3);
1620 
1621  FAIL_IF(Defrag(&test_tv, &test_dtv, p3) != NULL);
1622  FAIL_IF(Defrag(&test_tv, &test_dtv, p2) != NULL);
1623  reassembled = Defrag(&test_tv, &test_dtv, p1);
1624  FAIL_IF_NULL(reassembled);
1625 
1626  /* 40 bytes in we should find 8 bytes of A. */
1627  for (int i = 40; i < 40 + 8; i++) {
1628  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'A');
1629  }
1630 
1631  /* 28 bytes in we should find 8 bytes of B. */
1632  for (int i = 48; i < 48 + 8; i++) {
1633  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'B');
1634  }
1635 
1636  /* And 36 bytes in we should find 3 bytes of C. */
1637  for (int i = 56; i < 56 + 3; i++) {
1638  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'C');
1639  }
1640 
1641  DefragContextDestroy(dc);
1642  PacketFree(p1);
1643  PacketFree(p2);
1644  PacketFree(p3);
1645  PacketFree(reassembled);
1646 
1647  DefragDestroy();
1648  PASS;
1649 }
1650 
1651 static int DefragDoSturgesNovakTest(int policy, uint8_t *expected, size_t expected_len)
1652 {
1653  int i;
1654 
1655  DefragInit();
1656 
1657  /*
1658  * Build the packets.
1659  */
1660 
1661  int id = 1;
1662  Packet *packets[17];
1663  memset(packets, 0x00, sizeof(packets));
1664 
1665  /*
1666  * Original fragments.
1667  */
1668 
1669  /* <1> A*24 at 0. */
1670  packets[0] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 0, 1, 'A', 24);
1671 
1672  /* <2> B*16 at 32. */
1673  packets[1] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 32 >> 3, 1, 'B', 16);
1674 
1675  /* <3> C*24 at 48. */
1676  packets[2] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 48 >> 3, 1, 'C', 24);
1677 
1678  /* <3_1> D*8 at 80. */
1679  packets[3] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 80 >> 3, 1, 'D', 8);
1680 
1681  /* <3_2> E*16 at 104. */
1682  packets[4] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 104 >> 3, 1, 'E', 16);
1683 
1684  /* <3_3> F*24 at 120. */
1685  packets[5] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 120 >> 3, 1, 'F', 24);
1686 
1687  /* <3_4> G*16 at 144. */
1688  packets[6] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 144 >> 3, 1, 'G', 16);
1689 
1690  /* <3_5> H*16 at 160. */
1691  packets[7] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 160 >> 3, 1, 'H', 16);
1692 
1693  /* <3_6> I*8 at 176. */
1694  packets[8] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 176 >> 3, 1, 'I', 8);
1695 
1696  /*
1697  * Overlapping subsequent fragments.
1698  */
1699 
1700  /* <4> J*32 at 8. */
1701  packets[9] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 8 >> 3, 1, 'J', 32);
1702 
1703  /* <5> K*24 at 48. */
1704  packets[10] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 48 >> 3, 1, 'K', 24);
1705 
1706  /* <6> L*24 at 72. */
1707  packets[11] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 72 >> 3, 1, 'L', 24);
1708 
1709  /* <7> M*24 at 96. */
1710  packets[12] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 96 >> 3, 1, 'M', 24);
1711 
1712  /* <8> N*8 at 128. */
1713  packets[13] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 128 >> 3, 1, 'N', 8);
1714 
1715  /* <9> O*8 at 152. */
1716  packets[14] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 152 >> 3, 1, 'O', 8);
1717 
1718  /* <10> P*8 at 160. */
1719  packets[15] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 160 >> 3, 1, 'P', 8);
1720 
1721  /* <11> Q*16 at 176. */
1722  packets[16] = BuildIpv4TestPacket(IPPROTO_ICMP, id, 176 >> 3, 0, 'Q', 16);
1723 
1724  default_policy = policy;
1725 
1726  /* Send all but the last. */
1727  for (i = 0; i < 9; i++) {
1728  Packet *tp = Defrag(&test_tv, &test_dtv, packets[i]);
1729  FAIL_IF_NOT_NULL(tp);
1731  }
1732  int overlap = 0;
1733  for (; i < 16; i++) {
1734  Packet *tp = Defrag(&test_tv, &test_dtv, packets[i]);
1735  FAIL_IF_NOT_NULL(tp);
1736  if (ENGINE_ISSET_EVENT(packets[i], IPV4_FRAG_OVERLAP)) {
1737  overlap++;
1738  }
1739  }
1740  FAIL_IF_NOT(overlap);
1741 
1742  /* And now the last one. */
1743  Packet *reassembled = Defrag(&test_tv, &test_dtv, packets[16]);
1744  FAIL_IF_NULL(reassembled);
1745 
1746  FAIL_IF(IPV4_GET_RAW_HLEN(PacketGetIPv4(reassembled)) != 20);
1747  FAIL_IF(IPV4_GET_RAW_IPLEN(PacketGetIPv4(reassembled)) != 20 + 192);
1748  FAIL_IF(expected_len != 192);
1749 
1750  if (memcmp(expected, GET_PKT_DATA(reassembled) + 20, expected_len) != 0) {
1751  printf("Expected:\n");
1752  PrintRawDataFp(stdout, expected, expected_len);
1753  printf("Got:\n");
1754  PrintRawDataFp(stdout, GET_PKT_DATA(reassembled) + 20, GET_PKT_LEN(reassembled) - 20);
1755  FAIL;
1756  }
1757  PacketFree(reassembled);
1758 
1759  /* Make sure all frags were returned back to the pool. */
1760  FAIL_IF(defrag_context->frag_pool->outstanding != 0);
1761 
1762  for (i = 0; i < 17; i++) {
1763  PacketFree(packets[i]);
1764  }
1765  DefragDestroy();
1766  PASS;
1767 }
1768 
1769 static int DefragDoSturgesNovakIpv6Test(int policy, uint8_t *expected, size_t expected_len)
1770 {
1771  int i;
1772 
1773  DefragInit();
1774 
1775  /*
1776  * Build the packets.
1777  */
1778 
1779  int id = 1;
1780  Packet *packets[17];
1781  memset(packets, 0x00, sizeof(packets));
1782 
1783  /*
1784  * Original fragments.
1785  */
1786 
1787  /* <1> A*24 at 0. */
1788  packets[0] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 0, 1, 'A', 24);
1789 
1790  /* <2> B*16 at 32. */
1791  packets[1] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 32 >> 3, 1, 'B', 16);
1792 
1793  /* <3> C*24 at 48. */
1794  packets[2] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 48 >> 3, 1, 'C', 24);
1795 
1796  /* <3_1> D*8 at 80. */
1797  packets[3] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 80 >> 3, 1, 'D', 8);
1798 
1799  /* <3_2> E*16 at 104. */
1800  packets[4] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 104 >> 3, 1, 'E', 16);
1801 
1802  /* <3_3> F*24 at 120. */
1803  packets[5] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 120 >> 3, 1, 'F', 24);
1804 
1805  /* <3_4> G*16 at 144. */
1806  packets[6] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 144 >> 3, 1, 'G', 16);
1807 
1808  /* <3_5> H*16 at 160. */
1809  packets[7] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 160 >> 3, 1, 'H', 16);
1810 
1811  /* <3_6> I*8 at 176. */
1812  packets[8] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 176 >> 3, 1, 'I', 8);
1813 
1814  /*
1815  * Overlapping subsequent fragments.
1816  */
1817 
1818  /* <4> J*32 at 8. */
1819  packets[9] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 8 >> 3, 1, 'J', 32);
1820 
1821  /* <5> K*24 at 48. */
1822  packets[10] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 48 >> 3, 1, 'K', 24);
1823 
1824  /* <6> L*24 at 72. */
1825  packets[11] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 72 >> 3, 1, 'L', 24);
1826 
1827  /* <7> M*24 at 96. */
1828  packets[12] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 96 >> 3, 1, 'M', 24);
1829 
1830  /* <8> N*8 at 128. */
1831  packets[13] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 128 >> 3, 1, 'N', 8);
1832 
1833  /* <9> O*8 at 152. */
1834  packets[14] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 152 >> 3, 1, 'O', 8);
1835 
1836  /* <10> P*8 at 160. */
1837  packets[15] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 160 >> 3, 1, 'P', 8);
1838 
1839  /* <11> Q*16 at 176. */
1840  packets[16] = BuildIpv6TestPacket(IPPROTO_ICMPV6, id, 176 >> 3, 0, 'Q', 16);
1841 
1842  default_policy = policy;
1843 
1844  /* Send all but the last. */
1845  for (i = 0; i < 9; i++) {
1846  Packet *tp = Defrag(&test_tv, &test_dtv, packets[i]);
1847  FAIL_IF_NOT_NULL(tp);
1849  }
1850  int overlap = 0;
1851  for (; i < 16; i++) {
1852  Packet *tp = Defrag(&test_tv, &test_dtv, packets[i]);
1853  FAIL_IF_NOT_NULL(tp);
1854  if (ENGINE_ISSET_EVENT(packets[i], IPV6_FRAG_OVERLAP)) {
1855  overlap++;
1856  }
1857  }
1858  FAIL_IF_NOT(overlap);
1859 
1860  /* And now the last one. */
1861  Packet *reassembled = Defrag(&test_tv, &test_dtv, packets[16]);
1862  FAIL_IF_NULL(reassembled);
1863  FAIL_IF(memcmp(GET_PKT_DATA(reassembled) + 40, expected, expected_len) != 0);
1864 
1865  FAIL_IF(IPV6_GET_RAW_PLEN(PacketGetIPv6(reassembled)) != 192);
1866 
1867  PacketFree(reassembled);
1868 
1869  /* Make sure all frags were returned to the pool. */
1870  FAIL_IF(defrag_context->frag_pool->outstanding != 0);
1871 
1872  for (i = 0; i < 17; i++) {
1873  PacketFree(packets[i]);
1874  }
1875  DefragDestroy();
1876  PASS;
1877 }
1878 
1879 /* Define data that matches the naming "Target-Based Fragmentation
1880  * Reassembly".
1881  *
1882  * For example, the data refers to a fragment of data as <1>, or <3_6>
1883  * and uses these to diagram the input fragments and the resulting
1884  * policies. We build test cases for the papers scenario but assign
1885  * specific values to each segment.
1886  */
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'
1905 static int
1906 DefragSturgesNovakBsdTest(void)
1907 {
1908  /* Expected data. */
1909  uint8_t expected[] = {
1910  D_1,
1911  D_1,
1912  D_1,
1913  D_4,
1914  D_4,
1915  D_2,
1916  D_3,
1917  D_3,
1918  D_3,
1919  D_6,
1920  D_6,
1921  D_6,
1922  D_7,
1923  D_7,
1924  D_7,
1925  D_3_3,
1926  D_3_3,
1927  D_3_3,
1928  D_3_4,
1929  D_3_4,
1930  D_3_5,
1931  D_3_5,
1932  D_3_6,
1933  D_11,
1934  };
1935 
1936  FAIL_IF_NOT(DefragDoSturgesNovakTest(DEFRAG_POLICY_BSD, expected,
1937  sizeof(expected)));
1938  PASS;
1939 }
1940 
1941 static int DefragSturgesNovakBsdIpv6Test(void)
1942 {
1943  /* Expected data. */
1944  uint8_t expected[] = {
1945  D_1,
1946  D_1,
1947  D_1,
1948  D_4,
1949  D_4,
1950  D_2,
1951  D_3,
1952  D_3,
1953  D_3,
1954  D_6,
1955  D_6,
1956  D_6,
1957  D_7,
1958  D_7,
1959  D_7,
1960  D_3_3,
1961  D_3_3,
1962  D_3_3,
1963  D_3_4,
1964  D_3_4,
1965  D_3_5,
1966  D_3_5,
1967  D_3_6,
1968  D_11,
1969  };
1970 
1971  FAIL_IF_NOT(DefragDoSturgesNovakIpv6Test(DEFRAG_POLICY_BSD, expected, sizeof(expected)));
1972  PASS;
1973 }
1974 
1975 static int DefragSturgesNovakLinuxIpv4Test(void)
1976 {
1977  /* Expected data. */
1978  uint8_t expected[] = {
1979  D_1,
1980  D_1,
1981  D_1,
1982  D_4,
1983  D_4,
1984  D_2,
1985  D_5,
1986  D_5,
1987  D_5,
1988  D_6,
1989  D_6,
1990  D_6,
1991  D_7,
1992  D_7,
1993  D_7,
1994  D_3_3,
1995  D_3_3,
1996  D_3_3,
1997  D_3_4,
1998  D_3_4,
1999  D_10,
2000  D_3_5,
2001  D_11,
2002  D_11,
2003  };
2004 
2005  FAIL_IF_NOT(DefragDoSturgesNovakTest(DEFRAG_POLICY_LINUX, expected,
2006  sizeof(expected)));
2007  PASS;
2008 }
2009 
2010 static int DefragSturgesNovakLinuxIpv6Test(void)
2011 {
2012  /* Expected data. */
2013  uint8_t expected[] = {
2014  D_1,
2015  D_1,
2016  D_1,
2017  D_4,
2018  D_4,
2019  D_2,
2020  D_5,
2021  D_5,
2022  D_5,
2023  D_6,
2024  D_6,
2025  D_6,
2026  D_7,
2027  D_7,
2028  D_7,
2029  D_3_3,
2030  D_3_3,
2031  D_3_3,
2032  D_3_4,
2033  D_3_4,
2034  D_10,
2035  D_3_5,
2036  D_11,
2037  D_11,
2038  };
2039 
2040  FAIL_IF_NOT(DefragDoSturgesNovakIpv6Test(DEFRAG_POLICY_LINUX, expected, sizeof(expected)));
2041  PASS;
2042 }
2043 
2044 static int DefragSturgesNovakWindowsIpv4Test(void)
2045 {
2046  /* Expected data. */
2047  uint8_t expected[] = {
2048  D_1,
2049  D_1,
2050  D_1,
2051  D_4,
2052  D_2,
2053  D_2,
2054  D_3,
2055  D_3,
2056  D_3,
2057  D_6,
2058  D_6,
2059  D_6,
2060  D_7,
2061  D_3_2,
2062  D_3_2,
2063  D_3_3,
2064  D_3_3,
2065  D_3_3,
2066  D_3_4,
2067  D_3_4,
2068  D_3_5,
2069  D_3_5,
2070  D_3_6,
2071  D_11,
2072  };
2073 
2074  FAIL_IF_NOT(DefragDoSturgesNovakTest(DEFRAG_POLICY_WINDOWS, expected,
2075  sizeof(expected)));
2076  PASS;
2077 }
2078 
2079 static int DefragSturgesNovakWindowsIpv6Test(void)
2080 {
2081  /* Expected data. */
2082  uint8_t expected[] = {
2083  D_1,
2084  D_1,
2085  D_1,
2086  D_4,
2087  D_2,
2088  D_2,
2089  D_3,
2090  D_3,
2091  D_3,
2092  D_6,
2093  D_6,
2094  D_6,
2095  D_7,
2096  D_3_2,
2097  D_3_2,
2098  D_3_3,
2099  D_3_3,
2100  D_3_3,
2101  D_3_4,
2102  D_3_4,
2103  D_3_5,
2104  D_3_5,
2105  D_3_6,
2106  D_11,
2107  };
2108 
2109  FAIL_IF_NOT(DefragDoSturgesNovakIpv6Test(DEFRAG_POLICY_WINDOWS, expected, sizeof(expected)));
2110  PASS;
2111 }
2112 
2113 static int DefragSturgesNovakSolarisTest(void)
2114 {
2115  /* Expected data. */
2116  uint8_t expected[] = {
2117  D_1,
2118  D_1,
2119  D_1,
2120  D_4,
2121  D_2,
2122  D_2,
2123  D_3,
2124  D_3,
2125  D_3,
2126  D_6,
2127  D_6,
2128  D_6,
2129  D_7,
2130  D_7,
2131  D_7,
2132  D_3_3,
2133  D_3_3,
2134  D_3_3,
2135  D_3_4,
2136  D_3_4,
2137  D_3_5,
2138  D_3_5,
2139  D_3_6,
2140  D_11,
2141  };
2142 
2143  FAIL_IF_NOT(DefragDoSturgesNovakTest(DEFRAG_POLICY_SOLARIS, expected,
2144  sizeof(expected)));
2145  PASS;
2146 }
2147 
2148 static int DefragSturgesNovakSolarisIpv6Test(void)
2149 {
2150  /* Expected data. */
2151  uint8_t expected[] = {
2152  D_1,
2153  D_1,
2154  D_1,
2155  D_4,
2156  D_2,
2157  D_2,
2158  D_3,
2159  D_3,
2160  D_3,
2161  D_6,
2162  D_6,
2163  D_6,
2164  D_7,
2165  D_7,
2166  D_7,
2167  D_3_3,
2168  D_3_3,
2169  D_3_3,
2170  D_3_4,
2171  D_3_4,
2172  D_3_5,
2173  D_3_5,
2174  D_3_6,
2175  D_11,
2176  };
2177 
2178  FAIL_IF_NOT(DefragDoSturgesNovakIpv6Test(DEFRAG_POLICY_SOLARIS, expected, sizeof(expected)));
2179  PASS;
2180 }
2181 
2182 static int DefragSturgesNovakFirstTest(void)
2183 {
2184  /* Expected data. */
2185  uint8_t expected[] = {
2186  D_1,
2187  D_1,
2188  D_1,
2189  D_4,
2190  D_2,
2191  D_2,
2192  D_3,
2193  D_3,
2194  D_3,
2195  D_6,
2196  D_3_1,
2197  D_6,
2198  D_7,
2199  D_3_2,
2200  D_3_2,
2201  D_3_3,
2202  D_3_3,
2203  D_3_3,
2204  D_3_4,
2205  D_3_4,
2206  D_3_5,
2207  D_3_5,
2208  D_3_6,
2209  D_11,
2210  };
2211 
2212  FAIL_IF_NOT(DefragDoSturgesNovakTest(DEFRAG_POLICY_FIRST, expected,
2213  sizeof(expected)));
2214  PASS;
2215 }
2216 
2217 static int DefragSturgesNovakFirstIpv6Test(void)
2218 {
2219  /* Expected data. */
2220  uint8_t expected[] = {
2221  D_1,
2222  D_1,
2223  D_1,
2224  D_4,
2225  D_2,
2226  D_2,
2227  D_3,
2228  D_3,
2229  D_3,
2230  D_6,
2231  D_3_1,
2232  D_6,
2233  D_7,
2234  D_3_2,
2235  D_3_2,
2236  D_3_3,
2237  D_3_3,
2238  D_3_3,
2239  D_3_4,
2240  D_3_4,
2241  D_3_5,
2242  D_3_5,
2243  D_3_6,
2244  D_11,
2245  };
2246 
2247  return DefragDoSturgesNovakIpv6Test(DEFRAG_POLICY_FIRST, expected, sizeof(expected));
2248 }
2249 
2250 static int
2251 DefragSturgesNovakLastTest(void)
2252 {
2253  /* Expected data. */
2254  uint8_t expected[] = {
2255  D_1,
2256  D_4,
2257  D_4,
2258  D_4,
2259  D_4,
2260  D_2,
2261  D_5,
2262  D_5,
2263  D_5,
2264  D_6,
2265  D_6,
2266  D_6,
2267  D_7,
2268  D_7,
2269  D_7,
2270  D_3_3,
2271  D_8,
2272  D_3_3,
2273  D_3_4,
2274  D_9,
2275  D_10,
2276  D_3_5,
2277  D_11,
2278  D_11,
2279  };
2280 
2281  FAIL_IF_NOT(DefragDoSturgesNovakTest(DEFRAG_POLICY_LAST, expected,
2282  sizeof(expected)));
2283  PASS;
2284 }
2285 
2286 static int DefragSturgesNovakLastIpv6Test(void)
2287 {
2288  /* Expected data. */
2289  uint8_t expected[] = {
2290  D_1,
2291  D_4,
2292  D_4,
2293  D_4,
2294  D_4,
2295  D_2,
2296  D_5,
2297  D_5,
2298  D_5,
2299  D_6,
2300  D_6,
2301  D_6,
2302  D_7,
2303  D_7,
2304  D_7,
2305  D_3_3,
2306  D_8,
2307  D_3_3,
2308  D_3_4,
2309  D_9,
2310  D_10,
2311  D_3_5,
2312  D_11,
2313  D_11,
2314  };
2315 
2316  FAIL_IF_NOT(DefragDoSturgesNovakIpv6Test(DEFRAG_POLICY_LAST, expected, sizeof(expected)));
2317  PASS;
2318 }
2319 
2320 static int DefragTimeoutTest(void)
2321 {
2322  int i;
2323 
2324  /* Setup a small number of trackers. */
2325  FAIL_IF_NOT(SCConfSet("defrag.trackers", "16"));
2326 
2327  DefragInit();
2328 
2329  /* Load in 16 packets. */
2330  for (i = 0; i < 16; i++) {
2331  Packet *p = BuildIpv4TestPacket(IPPROTO_ICMP, i, 0, 1, 'A' + i, 16);
2332  FAIL_IF_NULL(p);
2333 
2334  Packet *tp = Defrag(&test_tv, &test_dtv, p);
2335  PacketFree(p);
2336  FAIL_IF_NOT_NULL(tp);
2337  }
2338 
2339  /* Build a new packet but push the timestamp out by our timeout.
2340  * This should force our previous fragments to be timed out. */
2341  Packet *p = BuildIpv4TestPacket(IPPROTO_ICMP, 99, 0, 1, 'A' + i, 16);
2342  FAIL_IF_NULL(p);
2343 
2344  p->ts = SCTIME_ADD_SECS(p->ts, defrag_context->timeout + 1);
2345  Packet *tp = Defrag(&test_tv, &test_dtv, p);
2346  FAIL_IF_NOT_NULL(tp);
2347 
2349  FAIL_IF_NULL(tracker);
2350 
2351  FAIL_IF(tracker->id != 99);
2352 
2353  SCMutexUnlock(&tracker->lock);
2354  PacketFree(p);
2355 
2356  DefragDestroy();
2357  PASS;
2358 }
2359 
2360 /**
2361  * QA found that if you send a packet where more frags is 0, offset is
2362  * > 0 and there is no data in the packet that the re-assembler will
2363  * fail. The fix was simple, but this unit test is just to make sure
2364  * its not introduced.
2365  */
2366 static int DefragNoDataIpv4Test(void)
2367 {
2368  DefragContext *dc = NULL;
2369  Packet *p = NULL;
2370  int id = 12;
2371 
2372  DefragInit();
2373 
2374  dc = DefragContextNew();
2375  FAIL_IF_NULL(dc);
2376 
2377  /* This packet has an offset > 0, more frags set to 0 and no data. */
2378  p = BuildIpv4TestPacket(IPPROTO_ICMP, id, 1, 0, 'A', 0);
2379  FAIL_IF_NULL(p);
2380 
2381  /* We do not expect a packet returned. */
2382  FAIL_IF(Defrag(&test_tv, &test_dtv, p) != NULL);
2383 
2384  /* The fragment should have been ignored so no fragments should
2385  * have been allocated from the pool. */
2386  FAIL_IF(dc->frag_pool->outstanding != 0);
2387 
2388  DefragContextDestroy(dc);
2389  PacketFree(p);
2390 
2391  DefragDestroy();
2392  PASS;
2393 }
2394 
2395 static int DefragTooLargeIpv4Test(void)
2396 {
2397  DefragContext *dc = NULL;
2398  Packet *p = NULL;
2399 
2400  DefragInit();
2401 
2402  dc = DefragContextNew();
2403  FAIL_IF_NULL(dc);
2404 
2405  /* Create a fragment that would extend past the max allowable size
2406  * for an IPv4 packet. */
2407  p = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 8183, 0, 'A', 71);
2408  FAIL_IF_NULL(p);
2409 
2410  /* We do not expect a packet returned. */
2411  FAIL_IF(Defrag(&test_tv, &test_dtv, p) != NULL);
2412 
2413  /* We do expect an event. */
2415 
2416  /* The fragment should have been ignored so no fragments should have
2417  * been allocated from the pool. */
2418  FAIL_IF(dc->frag_pool->outstanding != 0);
2419 
2420  DefragContextDestroy(dc);
2421  PacketFree(p);
2422 
2423  DefragDestroy();
2424  PASS;
2425 }
2426 
2427 /**
2428  * Test that fragments in different VLANs that would otherwise be
2429  * re-assembled, are not re-assembled. Just use simple in-order
2430  * fragments.
2431  */
2432 static int DefragVlanTest(void)
2433 {
2434  Packet *p1 = NULL, *p2 = NULL, *r = NULL;
2435 
2436  DefragInit();
2437 
2438  p1 = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 0, 1, 'A', 8);
2439  FAIL_IF_NULL(p1);
2440  p2 = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 1, 0, 'B', 8);
2441  FAIL_IF_NULL(p2);
2442 
2443  /* With no VLAN IDs set, packets should re-assemble. */
2444  FAIL_IF((r = Defrag(&test_tv, &test_dtv, p1)) != NULL);
2445  FAIL_IF((r = Defrag(&test_tv, &test_dtv, p2)) == NULL);
2446  PacketFree(r);
2447 
2448  /* With mismatched VLANs, packets should not re-assemble. */
2449  p1->vlan_id[0] = 1;
2450  p2->vlan_id[0] = 2;
2451  FAIL_IF((r = Defrag(&test_tv, &test_dtv, p1)) != NULL);
2452  FAIL_IF((r = Defrag(&test_tv, &test_dtv, p2)) != NULL);
2453 
2454  PacketFree(p1);
2455  PacketFree(p2);
2456  DefragDestroy();
2457 
2458  PASS;
2459 }
2460 
2461 /**
2462  * Like DefragVlanTest, but for QinQ, testing the second level VLAN ID.
2463  */
2464 static int DefragVlanQinQTest(void)
2465 {
2466  Packet *p1 = NULL, *p2 = NULL, *r = NULL;
2467 
2468  DefragInit();
2469 
2470  p1 = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 0, 1, 'A', 8);
2471  FAIL_IF_NULL(p1);
2472  p2 = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 1, 0, 'B', 8);
2473  FAIL_IF_NULL(p2);
2474 
2475  /* With no VLAN IDs set, packets should re-assemble. */
2476  FAIL_IF((r = Defrag(&test_tv, &test_dtv, p1)) != NULL);
2477  FAIL_IF((r = Defrag(&test_tv, &test_dtv, p2)) == NULL);
2478  PacketFree(r);
2479 
2480  /* With mismatched VLANs, packets should not re-assemble. */
2481  p1->vlan_id[0] = 1;
2482  p2->vlan_id[0] = 1;
2483  p1->vlan_id[1] = 1;
2484  p2->vlan_id[1] = 2;
2485  FAIL_IF((r = Defrag(&test_tv, &test_dtv, p1)) != NULL);
2486  FAIL_IF((r = Defrag(&test_tv, &test_dtv, p2)) != NULL);
2487 
2488  PacketFree(p1);
2489  PacketFree(p2);
2490  DefragDestroy();
2491 
2492  PASS;
2493 }
2494 
2495 /**
2496  * Like DefragVlanTest, but for QinQinQ, testing the third level VLAN ID.
2497  */
2498 static int DefragVlanQinQinQTest(void)
2499 {
2500  Packet *r = NULL;
2501 
2502  DefragInit();
2503 
2504  Packet *p1 = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 0, 1, 'A', 8);
2505  FAIL_IF_NULL(p1);
2506  Packet *p2 = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 1, 0, 'B', 8);
2507  FAIL_IF_NULL(p2);
2508 
2509  /* With no VLAN IDs set, packets should re-assemble. */
2510  FAIL_IF((r = Defrag(&test_tv, &test_dtv, p1)) != NULL);
2511  FAIL_IF((r = Defrag(&test_tv, &test_dtv, p2)) == NULL);
2512  PacketFree(r);
2513 
2514  /* With mismatched VLANs, packets should not re-assemble. */
2515  p1->vlan_id[0] = 1;
2516  p2->vlan_id[0] = 1;
2517  p1->vlan_id[1] = 2;
2518  p2->vlan_id[1] = 2;
2519  p1->vlan_id[2] = 3;
2520  p2->vlan_id[2] = 4;
2521  FAIL_IF((r = Defrag(&test_tv, &test_dtv, p1)) != NULL);
2522  FAIL_IF((r = Defrag(&test_tv, &test_dtv, p2)) != NULL);
2523 
2524  PacketFree(p1);
2525  PacketFree(p2);
2526  DefragDestroy();
2527 
2528  PASS;
2529 }
2530 static int DefragTrackerReuseTest(void)
2531 {
2532  int id = 1;
2533  Packet *p1 = NULL;
2534  DefragTracker *tracker1 = NULL, *tracker2 = NULL;
2535 
2536  DefragInit();
2537 
2538  /* Build a packet, its not a fragment but shouldn't matter for
2539  * this test. */
2540  p1 = BuildIpv4TestPacket(IPPROTO_ICMP, id, 0, 0, 'A', 8);
2541  FAIL_IF_NULL(p1);
2542 
2543  /* Get a tracker. It shouldn't look like its already in use. */
2544  tracker1 = DefragGetTracker(&test_tv, &test_dtv, p1);
2545  FAIL_IF_NULL(tracker1);
2546  FAIL_IF(tracker1->seen_last);
2547  FAIL_IF(tracker1->remove);
2548  DefragTrackerRelease(tracker1);
2549 
2550  /* Get a tracker again, it should be the same one. */
2551  tracker2 = DefragGetTracker(&test_tv, &test_dtv, p1);
2552  FAIL_IF_NULL(tracker2);
2553  FAIL_IF(tracker2 != tracker1);
2554  DefragTrackerRelease(tracker1);
2555 
2556  /* Now mark the tracker for removal. It should not be returned
2557  * when we get a tracker for a packet that may have the same
2558  * attributes. */
2559  tracker1->remove = 1;
2560 
2561  tracker2 = DefragGetTracker(&test_tv, &test_dtv, p1);
2562  FAIL_IF_NULL(tracker2);
2563  /* DefragGetTracker will have returned tracker1 to the stack,
2564  * the set up a new tracker. Since it pops the stack, it got
2565  * tracker1. */
2566  FAIL_IF(tracker2 != tracker1);
2567  FAIL_IF(tracker2->remove);
2568 
2569  PacketFree(p1);
2570  DefragDestroy();
2571  PASS;
2572 }
2573 
2574 /**
2575  * IPV4: Test the case where you have a packet fragmented in 3 parts
2576  * and send like:
2577  * - Offset: 2; MF: 1
2578  * - Offset: 0; MF: 1
2579  * - Offset: 1; MF: 0
2580  *
2581  * Only the fragments with offset 0 and 1 should be reassembled.
2582  */
2583 static int DefragMfIpv4Test(void)
2584 {
2585  int ip_id = 9;
2586  Packet *p = NULL;
2587 
2588  DefragInit();
2589 
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);
2594 
2595  p = Defrag(&test_tv, &test_dtv, p1);
2597 
2598  p = Defrag(&test_tv, &test_dtv, p2);
2600 
2601  /* This should return a packet as MF=0. */
2602  p = Defrag(&test_tv, &test_dtv, p3);
2603  FAIL_IF_NULL(p);
2604 
2605  /* Expected IP length is 20 + 8 + 8 = 36 as only 2 of the
2606  * fragments should be in the re-assembled packet. */
2607  FAIL_IF(IPV4_GET_RAW_IPLEN(PacketGetIPv4(p)) != 36);
2608 
2609  /* Verify the payload of the IPv4 packet. */
2610  uint8_t expected_payload[] = "AAAAAAAABBBBBBBB";
2611  FAIL_IF(memcmp(GET_PKT_DATA(p) + sizeof(IPV4Hdr), expected_payload, sizeof(expected_payload)));
2612 
2613  PacketFree(p1);
2614  PacketFree(p2);
2615  PacketFree(p3);
2616  PacketFree(p);
2617  DefragDestroy();
2618  PASS;
2619 }
2620 
2621 /**
2622  * IPV6: Test the case where you have a packet fragmented in 3 parts
2623  * and send like:
2624  * - Offset: 2; MF: 1
2625  * - Offset: 0; MF: 1
2626  * - Offset: 1; MF: 0
2627  *
2628  * Only the fragments with offset 0 and 1 should be reassembled.
2629  */
2630 static int DefragMfIpv6Test(void)
2631 {
2632  int ip_id = 9;
2633  Packet *p = NULL;
2634 
2635  DefragInit();
2636 
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);
2641 
2642  p = Defrag(&test_tv, &test_dtv, p1);
2644 
2645  p = Defrag(&test_tv, &test_dtv, p2);
2647 
2648  /* This should return a packet as MF=0. */
2649  p = Defrag(&test_tv, &test_dtv, p3);
2650  FAIL_IF_NULL(p);
2651 
2652  /* For IPv6 the expected length is just the length of the payload
2653  * of 2 fragments, so 16. */
2654  FAIL_IF(IPV6_GET_RAW_PLEN(PacketGetIPv6(p)) != 16);
2655 
2656  /* Verify the payload of the IPv4 packet. */
2657  uint8_t expected_payload[] = "AAAAAAAABBBBBBBB";
2658  FAIL_IF(memcmp(GET_PKT_DATA(p) + sizeof(IPV6Hdr), expected_payload, sizeof(expected_payload)));
2659 
2660  PacketFree(p1);
2661  PacketFree(p2);
2662  PacketFree(p3);
2663  PacketFree(p);
2664  DefragDestroy();
2665  PASS;
2666 }
2667 
2668 /**
2669  * \brief Test that fragments that match other than the proto don't
2670  * actually get matched.
2671  */
2672 static int DefragTestBadProto(void)
2673 {
2674  Packet *p1 = NULL, *p2 = NULL, *p3 = NULL;
2675  int id = 12;
2676 
2677  DefragInit();
2678 
2679  p1 = BuildIpv4TestPacket(IPPROTO_ICMP, id, 0, 1, 'A', 8);
2680  FAIL_IF_NULL(p1);
2681  p2 = BuildIpv4TestPacket(IPPROTO_UDP, id, 1, 1, 'B', 8);
2682  FAIL_IF_NULL(p2);
2683  p3 = BuildIpv4TestPacket(IPPROTO_ICMP, id, 2, 0, 'C', 3);
2684  FAIL_IF_NULL(p3);
2685 
2689 
2690  PacketFree(p1);
2691  PacketFree(p2);
2692  PacketFree(p3);
2693 
2694  DefragDestroy();
2695  PASS;
2696 }
2697 
2698 /**
2699  * \test Test a report Linux overlap issue that doesn't appear to be
2700  * covered by the Sturges/Novak tests above.
2701  */
2702 static int DefragTestJeremyLinux(void)
2703 {
2704 
2705  uint8_t expected[] = "AAAAAAAA"
2706  "AAAAAAAA"
2707  "AAAAAAAA"
2708  "CCCCCCCC"
2709  "CCCCCCCC"
2710  "CCCCCCCC"
2711  "CCCCCCCC"
2712  "CCCCCCCC"
2713  "CCCCCCCC"
2714  "BBBBBBBB"
2715  "BBBBBBBB"
2716  "DDDDDDDD"
2717  "DDDDDD";
2718 
2719  DefragInit();
2720  default_policy = DEFRAG_POLICY_LINUX;
2721 
2722  int id = 1;
2723  Packet *packets[4];
2724  int i = 0;
2725 
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);
2730 
2731  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
2732  FAIL_IF_NOT_NULL(r);
2733 
2734  r = Defrag(&test_tv, &test_dtv, packets[1]);
2735  FAIL_IF_NOT_NULL(r);
2736 
2737  r = Defrag(&test_tv, &test_dtv, packets[2]);
2738  FAIL_IF_NOT_NULL(r);
2739 
2740  r = Defrag(&test_tv, &test_dtv, packets[3]);
2741  FAIL_IF_NULL(r);
2742 
2743  FAIL_IF(memcmp(expected, GET_PKT_DATA(r) + 20, sizeof(expected)) != 0);
2744 
2745  for (i = 0; i < 4; i++) {
2746  PacketFree(packets[i]);
2747  }
2748  PacketFree(r);
2749 
2750  DefragDestroy();
2751  PASS;
2752 }
2753 
2754 /**
2755  * | 0 | 8 | 16 | 24 | 32 |
2756  * |----------|----------|----------|----------|----------|
2757  * | AAAAAAAA | AAAAAAAA |
2758  * | | BBBBBBBB | BBBBBBBB | | |
2759  * | | | CCCCCCCC | CCCCCCCC | |
2760  * | DDDDDDDD | | | | |
2761  *
2762  * | DDDDDDDD | BBBBBBBB | BBBBBBBB | CCCCCCCC | AAAAAAAA |
2763  */
2764 static int DefragBsdFragmentAfterNoMfIpv4Test(void)
2765 {
2766  DefragInit();
2767  default_policy = DEFRAG_POLICY_BSD;
2768  Packet *packets[4];
2769 
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);
2774 
2775  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
2776  FAIL_IF_NOT_NULL(r);
2777 
2778  r = Defrag(&test_tv, &test_dtv, packets[1]);
2779  FAIL_IF_NOT_NULL(r);
2780 
2781  r = Defrag(&test_tv, &test_dtv, packets[2]);
2782  FAIL_IF_NOT_NULL(r);
2783 
2784  r = Defrag(&test_tv, &test_dtv, packets[3]);
2785  FAIL_IF_NULL(r);
2786 
2787  // clang-format off
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',
2794  };
2795  // clang-format on
2796 
2797  if (memcmp(expected, GET_PKT_DATA(r) + 20, sizeof(expected)) != 0) {
2798  printf("Expected:\n");
2799  PrintRawDataFp(stdout, expected, sizeof(expected));
2800  printf("Got:\n");
2801  PrintRawDataFp(stdout, GET_PKT_DATA(r) + 20, GET_PKT_LEN(r) - 20);
2802  FAIL;
2803  }
2804 
2805  for (int i = 0; i < 4; i++) {
2806  PacketFree(packets[i]);
2807  }
2808  PacketFree(r);
2809  DefragDestroy();
2810  PASS;
2811 }
2812 
2813 static int DefragBsdFragmentAfterNoMfIpv6Test(void)
2814 {
2815  DefragInit();
2816  default_policy = DEFRAG_POLICY_BSD;
2817  Packet *packets[4];
2818 
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);
2823 
2824  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
2825  FAIL_IF_NOT_NULL(r);
2826 
2827  r = Defrag(&test_tv, &test_dtv, packets[1]);
2828  FAIL_IF_NOT_NULL(r);
2829 
2830  r = Defrag(&test_tv, &test_dtv, packets[2]);
2831  FAIL_IF_NOT_NULL(r);
2832 
2833  r = Defrag(&test_tv, &test_dtv, packets[3]);
2834  FAIL_IF_NULL(r);
2835 
2836  // clang-format off
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',
2843  };
2844  // clang-format on
2845 
2846  if (memcmp(expected, GET_PKT_DATA(r) + 40, sizeof(expected)) != 0) {
2847  printf("Expected:\n");
2848  PrintRawDataFp(stdout, expected, sizeof(expected));
2849  printf("Got:\n");
2850  PrintRawDataFp(stdout, GET_PKT_DATA(r) + 40, GET_PKT_LEN(r) - 40);
2851  FAIL;
2852  }
2853 
2854  for (int i = 0; i < 4; i++) {
2855  PacketFree(packets[i]);
2856  }
2857  PacketFree(r);
2858  DefragDestroy();
2859  PASS;
2860 }
2861 
2862 static int DefragBsdSubsequentOverlapsStartOfOriginalIpv4Test_2(void)
2863 {
2864  DefragInit();
2865  default_policy = DEFRAG_POLICY_BSD;
2866  Packet *packets[4];
2867 
2868  /* Packet 1: off=16, mf=1 */
2869  FAIL_IF_NOT(BuildIpv4TestPacketWithContent(
2870  &packets[0], IPPROTO_ICMP, 6, 16 >> 3, 1, (uint8_t *)"AABBCCDDAABBDDCC", 16));
2871 
2872  /* Packet 2: off=8, mf=1 */
2873  FAIL_IF_NOT(BuildIpv4TestPacketWithContent(
2874  &packets[1], IPPROTO_ICMP, 6, 8 >> 3, 1, (uint8_t *)"AACCBBDDAACCDDBB", 16));
2875 
2876  /* Packet 3: off=0, mf=1: IP and ICMP header. */
2877  FAIL_IF_NOT(BuildIpv4TestPacketWithContent(
2878  &packets[2], IPPROTO_ICMP, 6, 0, 1, (uint8_t *)"ZZZZZZZZ", 8));
2879 
2880  /* Packet 4: off=8, mf=1 */
2881  FAIL_IF_NOT(BuildIpv4TestPacketWithContent(
2882  &packets[3], IPPROTO_ICMP, 6, 32 >> 3, 0, (uint8_t *)"DDCCBBAA", 8));
2883 
2884  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
2885  FAIL_IF_NOT_NULL(r);
2886 
2887  r = Defrag(&test_tv, &test_dtv, packets[1]);
2888  FAIL_IF_NOT_NULL(r);
2889 
2890  r = Defrag(&test_tv, &test_dtv, packets[2]);
2891  FAIL_IF_NOT_NULL(r);
2892 
2893  r = Defrag(&test_tv, &test_dtv, packets[3]);
2894  FAIL_IF_NULL(r);
2895 
2896  // clang-format off
2897  const uint8_t expected[] = {
2898  // AACCBBDD
2899  // AACCDDBB
2900  // AABBDDCC
2901  // DDCCBBAA
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',
2906  };
2907  // clang-format on
2908 
2909  FAIL_IF(memcmp(expected, GET_PKT_DATA(r) + 20 + 8, sizeof(expected)) != 0);
2910 
2911  for (int i = 0; i < 4; i++) {
2912  PacketFree(packets[i]);
2913  }
2914  PacketFree(r);
2915  DefragDestroy();
2916  PASS;
2917 }
2918 
2919 static int DefragBsdSubsequentOverlapsStartOfOriginalIpv6Test_2(void)
2920 {
2921  DefragInit();
2922  default_policy = DEFRAG_POLICY_BSD;
2923  Packet *packets[4];
2924 
2925  /* Packet 1: off=16, mf=1 */
2926  packets[0] = BuildIpv6TestPacketWithContent(
2927  IPPROTO_ICMP, 6, 16 >> 3, 1, (uint8_t *)"AABBCCDDAABBDDCC", 16);
2928 
2929  /* Packet 2: off=8, mf=1 */
2930  packets[1] = BuildIpv6TestPacketWithContent(
2931  IPPROTO_ICMP, 6, 8 >> 3, 1, (uint8_t *)"AACCBBDDAACCDDBB", 16);
2932 
2933  /* Packet 3: off=0, mf=1: IP and ICMP header. */
2934  packets[2] = BuildIpv6TestPacketWithContent(IPPROTO_ICMP, 6, 0, 1, (uint8_t *)"ZZZZZZZZ", 8);
2935 
2936  /* Packet 4: off=8, mf=1 */
2937  packets[3] =
2938  BuildIpv6TestPacketWithContent(IPPROTO_ICMP, 6, 32 >> 3, 0, (uint8_t *)"DDCCBBAA", 8);
2939 
2940  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
2941  FAIL_IF_NOT_NULL(r);
2942 
2943  r = Defrag(&test_tv, &test_dtv, packets[1]);
2944  FAIL_IF_NOT_NULL(r);
2945 
2946  r = Defrag(&test_tv, &test_dtv, packets[2]);
2947  FAIL_IF_NOT_NULL(r);
2948 
2949  r = Defrag(&test_tv, &test_dtv, packets[3]);
2950  FAIL_IF_NULL(r);
2951 
2952  // clang-format off
2953  const uint8_t expected[] = {
2954  // AACCBBDD
2955  // AACCDDBB
2956  // AABBDDCC
2957  // DDCCBBAA
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',
2962  };
2963  // clang-format on
2964 
2965  FAIL_IF(memcmp(expected, GET_PKT_DATA(r) + 40 + 8, sizeof(expected)) != 0);
2966 
2967  for (int i = 0; i < 4; i++) {
2968  PacketFree(packets[i]);
2969  }
2970  PacketFree(r);
2971  DefragDestroy();
2972  PASS;
2973 }
2974 
2975 /**
2976  * #### Input
2977  *
2978  * | 96 (0) | 104 (8) | 112 (16) | 120 (24) |
2979  * |----------|----------|----------|----------|
2980  * | | EEEEEEEE | EEEEEEEE | EEEEEEEE |
2981  * | MMMMMMMM | MMMMMMMM | MMMMMMMM | |
2982  *
2983  * #### Expected Output
2984  *
2985  * | MMMMMMMM | MMMMMMMM | MMMMMMMM | EEEEEEEE |
2986  */
2987 static int DefragBsdSubsequentOverlapsStartOfOriginalIpv4Test(void)
2988 {
2989  DefragInit();
2990  default_policy = DEFRAG_POLICY_BSD;
2991  Packet *packets[2];
2992 
2993  packets[0] = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 8 >> 3, 0, 'E', 24);
2994  packets[1] = BuildIpv4TestPacket(IPPROTO_ICMP, 1, 0, 1, 'M', 24);
2995 
2996  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
2997  FAIL_IF_NOT_NULL(r);
2998 
2999  r = Defrag(&test_tv, &test_dtv, packets[1]);
3000  FAIL_IF_NULL(r);
3001 
3002  // clang-format off
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',
3008  };
3009  // clang-format on
3010 
3011  if (memcmp(expected, GET_PKT_DATA(r) + 20, sizeof(expected)) != 0) {
3012  printf("Expected:\n");
3013  PrintRawDataFp(stdout, expected, sizeof(expected));
3014  printf("Got:\n");
3015  PrintRawDataFp(stdout, GET_PKT_DATA(r) + 20, GET_PKT_LEN(r) - 20);
3016  FAIL;
3017  }
3018 
3019  for (int i = 0; i < 2; i++) {
3020  PacketFree(packets[i]);
3021  }
3022  PacketFree(r);
3023  DefragDestroy();
3024  PASS;
3025 }
3026 
3027 static int DefragBsdSubsequentOverlapsStartOfOriginalIpv6Test(void)
3028 {
3029  DefragInit();
3030  default_policy = DEFRAG_POLICY_BSD;
3031  Packet *packets[2];
3032 
3033  packets[0] = BuildIpv6TestPacket(IPPROTO_ICMP, 1, 8 >> 3, 0, 'E', 24);
3034  packets[1] = BuildIpv6TestPacket(IPPROTO_ICMP, 1, 0, 1, 'M', 24);
3035 
3036  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
3037  FAIL_IF_NOT_NULL(r);
3038 
3039  r = Defrag(&test_tv, &test_dtv, packets[1]);
3040  FAIL_IF_NULL(r);
3041 
3042  // clang-format off
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',
3048  };
3049  // clang-format on
3050 
3051  if (memcmp(expected, GET_PKT_DATA(r) + 40, sizeof(expected)) != 0) {
3052  printf("Expected:\n");
3053  PrintRawDataFp(stdout, expected, sizeof(expected));
3054  printf("Got:\n");
3055  PrintRawDataFp(stdout, GET_PKT_DATA(r) + 40, GET_PKT_LEN(r) - 40);
3056  FAIL;
3057  }
3058 
3059  for (int i = 0; i < 2; i++) {
3060  PacketFree(packets[i]);
3061  }
3062  PacketFree(r);
3063  DefragDestroy();
3064  PASS;
3065 }
3066 
3067 /**
3068  * Reassembly should fail.
3069  *
3070  * |0 |8 |16 |24 |32 |40 |48 |
3071  * |========|========|========|========|========|========|========|
3072  * | | |AABBCCDD|AABBDDCC| | | |
3073  * | | | | | |AACCBBDD| |
3074  * | |AACCDDBB|AADDBBCC| | | | |
3075  * |ZZZZZZZZ| | | | | | |
3076  * | | | | | | |DDCCBBAA|
3077  */
3078 static int DefragBsdMissingFragmentIpv4Test(void)
3079 {
3080  DefragInit();
3081  default_policy = DEFRAG_POLICY_BSD;
3082  Packet *packets[5];
3083 
3084  FAIL_IF_NOT(BuildIpv4TestPacketWithContent(
3085  &packets[0], IPPROTO_ICMP, 189, 16 >> 3, 1, (uint8_t *)"AABBCCDDAABBDDCC", 16));
3086 
3087  FAIL_IF_NOT(BuildIpv4TestPacketWithContent(
3088  &packets[1], IPPROTO_ICMP, 189, 40 >> 3, 1, (uint8_t *)"AACCBBDD", 8));
3089 
3090  FAIL_IF_NOT(BuildIpv4TestPacketWithContent(
3091  &packets[2], IPPROTO_ICMP, 189, 8 >> 3, 1, (uint8_t *)"AACCDDBBAADDBBCC", 16));
3092 
3093  /* ICMP header. */
3094  FAIL_IF_NOT(BuildIpv4TestPacketWithContent(
3095  &packets[3], IPPROTO_ICMP, 189, 0, 1, (uint8_t *)"ZZZZZZZZ", 8));
3096 
3097  FAIL_IF_NOT(BuildIpv4TestPacketWithContent(
3098  &packets[4], IPPROTO_ICMP, 189, 48 >> 3, 0, (uint8_t *)"DDCCBBAA", 8));
3099 
3100  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
3101  FAIL_IF_NOT_NULL(r);
3102 
3103  r = Defrag(&test_tv, &test_dtv, packets[1]);
3104  FAIL_IF_NOT_NULL(r);
3105 
3106  r = Defrag(&test_tv, &test_dtv, packets[2]);
3107  FAIL_IF_NOT_NULL(r);
3108 
3109  r = Defrag(&test_tv, &test_dtv, packets[3]);
3110  FAIL_IF_NOT_NULL(r);
3111 
3112  r = Defrag(&test_tv, &test_dtv, packets[4]);
3113  FAIL_IF_NOT_NULL(r);
3114 
3115 #if 0
3116  PrintRawDataFp(stdout, GET_PKT_DATA(r) + 20, GET_PKT_LEN(r) - 20);
3117 #endif
3118 
3119  for (int i = 0; i < 5; i++) {
3120  PacketFree(packets[i]);
3121  }
3122  DefragDestroy();
3123  PASS;
3124 }
3125 
3126 static int DefragBsdMissingFragmentIpv6Test(void)
3127 {
3128  DefragInit();
3129  default_policy = DEFRAG_POLICY_BSD;
3130  Packet *packets[5];
3131 
3132  packets[0] = BuildIpv6TestPacketWithContent(
3133  IPPROTO_ICMP, 189, 16 >> 3, 1, (uint8_t *)"AABBCCDDAABBDDCC", 16);
3134 
3135  packets[1] =
3136  BuildIpv6TestPacketWithContent(IPPROTO_ICMP, 189, 40 >> 3, 1, (uint8_t *)"AACCBBDD", 8);
3137 
3138  packets[2] = BuildIpv6TestPacketWithContent(
3139  IPPROTO_ICMP, 189, 8 >> 3, 1, (uint8_t *)"AACCDDBBAADDBBCC", 16);
3140 
3141  /* ICMP header. */
3142  packets[3] = BuildIpv6TestPacketWithContent(IPPROTO_ICMP, 189, 0, 1, (uint8_t *)"ZZZZZZZZ", 8);
3143 
3144  packets[4] =
3145  BuildIpv6TestPacketWithContent(IPPROTO_ICMP, 189, 48 >> 3, 0, (uint8_t *)"DDCCBBAA", 8);
3146 
3147  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
3148  FAIL_IF_NOT_NULL(r);
3149 
3150  r = Defrag(&test_tv, &test_dtv, packets[1]);
3151  FAIL_IF_NOT_NULL(r);
3152 
3153  r = Defrag(&test_tv, &test_dtv, packets[2]);
3154  FAIL_IF_NOT_NULL(r);
3155 
3156  r = Defrag(&test_tv, &test_dtv, packets[3]);
3157  FAIL_IF_NOT_NULL(r);
3158 
3159  r = Defrag(&test_tv, &test_dtv, packets[4]);
3160  FAIL_IF_NOT_NULL(r);
3161 
3162 #if 0
3163  PrintRawDataFp(stdout, GET_PKT_DATA(r) + 40, GET_PKT_LEN(r) - 40);
3164 #endif
3165 
3166  for (int i = 0; i < 5; i++) {
3167  PacketFree(packets[i]);
3168  }
3169  DefragDestroy();
3170  PASS;
3171 }
3172 
3173 /**
3174  * \test A BSD-preferred fragment that starts within an earlier fragment
3175  * and fully covers a later fragment. A subsequent fragment then
3176  * overlaps the end of the preferred fragment and must be trimmed.
3177  *
3178  * Arrival:
3179  * A: 0..16
3180  * B: 24..40
3181  * C: 48..56 (last)
3182  * D: 8..40 (stored as 16..40, fully covers B)
3183  * E: 32..48 (must be trimmed to 40..48)
3184  *
3185  * Expected: A*16 D*24 E*8 C*8
3186  */
3187 static int DefragBsdOverlapAfterCoveredStartsInsidePrevIpv4Test(void)
3188 {
3189  DefragInit();
3190  default_policy = DEFRAG_POLICY_BSD;
3191  Packet *packets[5];
3192 
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);
3198 
3199  Packet *rp = Defrag(&test_tv, &test_dtv, packets[0]);
3200  FAIL_IF_NOT_NULL(rp);
3201 
3202  rp = Defrag(&test_tv, &test_dtv, packets[1]);
3203  FAIL_IF_NOT_NULL(rp);
3204 
3205  rp = Defrag(&test_tv, &test_dtv, packets[2]);
3206  FAIL_IF_NOT_NULL(rp);
3207 
3208  rp = Defrag(&test_tv, &test_dtv, packets[3]);
3209  FAIL_IF_NOT_NULL(rp);
3211 
3212  rp = Defrag(&test_tv, &test_dtv, packets[4]);
3213  FAIL_IF_NULL(rp);
3215 
3216  // clang-format off
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',
3225  };
3226  // clang-format on
3227 
3228  FAIL_IF(GET_PKT_LEN(rp) != 20 + sizeof(expected));
3229  if (memcmp(expected, GET_PKT_DATA(rp) + 20, sizeof(expected)) != 0) {
3230  printf("Expected:\n");
3231  PrintRawDataFp(stdout, expected, sizeof(expected));
3232  printf("Got:\n");
3233  PrintRawDataFp(stdout, GET_PKT_DATA(rp) + 20, GET_PKT_LEN(rp) - 20);
3234  FAIL;
3235  }
3236 
3237  /* Make sure all frags were returned back to the pool. */
3238  FAIL_IF(defrag_context->frag_pool->outstanding != 0);
3239 
3240  for (int i = 0; i < 5; i++) {
3241  PacketFree(packets[i]);
3242  }
3243  PacketFree(rp);
3244  DefragDestroy();
3245  PASS;
3246 }
3247 
3248 /** IPv6 variant of DefragBsdOverlapAfterCoveredStartsInsidePrevIpv4Test. */
3249 static int DefragBsdOverlapAfterCoveredStartsInsidePrevIpv6Test(void)
3250 {
3251  DefragInit();
3252  default_policy = DEFRAG_POLICY_BSD;
3253  Packet *packets[5];
3254 
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);
3260 
3261  Packet *rp = Defrag(&test_tv, &test_dtv, packets[0]);
3262  FAIL_IF_NOT_NULL(rp);
3263 
3264  rp = Defrag(&test_tv, &test_dtv, packets[1]);
3265  FAIL_IF_NOT_NULL(rp);
3266 
3267  rp = Defrag(&test_tv, &test_dtv, packets[2]);
3268  FAIL_IF_NOT_NULL(rp);
3269 
3270  rp = Defrag(&test_tv, &test_dtv, packets[3]);
3271  FAIL_IF_NOT_NULL(rp);
3273 
3274  rp = Defrag(&test_tv, &test_dtv, packets[4]);
3275  FAIL_IF_NULL(rp);
3277 
3278  // clang-format off
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',
3287  };
3288  // clang-format on
3289 
3290  FAIL_IF(GET_PKT_LEN(rp) != 40 + sizeof(expected));
3291  if (memcmp(expected, GET_PKT_DATA(rp) + 40, sizeof(expected)) != 0) {
3292  printf("Expected:\n");
3293  PrintRawDataFp(stdout, expected, sizeof(expected));
3294  printf("Got:\n");
3295  PrintRawDataFp(stdout, GET_PKT_DATA(rp) + 40, GET_PKT_LEN(rp) - 40);
3296  FAIL;
3297  }
3298 
3299  /* Make sure all frags were returned back to the pool. */
3300  FAIL_IF(defrag_context->frag_pool->outstanding != 0);
3301 
3302  for (int i = 0; i < 5; i++) {
3303  PacketFree(packets[i]);
3304  }
3305  PacketFree(rp);
3306  DefragDestroy();
3307  PASS;
3308 }
3309 
3310 /**
3311  * \test A BSD-preferred fragment that starts before an earlier fragment
3312  * and fully covers a later fragment. A subsequent fragment then
3313  * overlaps the end of the preferred fragment and must be trimmed.
3314  *
3315  * Arrival:
3316  * A: 0..16
3317  * B: 24..32
3318  * C: 40..56
3319  * D: 64..72 (last)
3320  * E: 16..56 (fully covers B and C)
3321  * F: 48..64 (must be trimmed to 56..64)
3322  *
3323  * Expected: A*16 E*40 F*8 D*8
3324  */
3325 static int DefragBsdOverlapAfterCoveredStartsBeforeIpv4Test(void)
3326 {
3327  DefragInit();
3328  default_policy = DEFRAG_POLICY_BSD;
3329  Packet *packets[6];
3330 
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);
3337 
3338  Packet *rp = Defrag(&test_tv, &test_dtv, packets[0]);
3339  FAIL_IF_NOT_NULL(rp);
3340 
3341  rp = Defrag(&test_tv, &test_dtv, packets[1]);
3342  FAIL_IF_NOT_NULL(rp);
3343 
3344  rp = Defrag(&test_tv, &test_dtv, packets[2]);
3345  FAIL_IF_NOT_NULL(rp);
3346 
3347  rp = Defrag(&test_tv, &test_dtv, packets[3]);
3348  FAIL_IF_NOT_NULL(rp);
3349 
3350  rp = Defrag(&test_tv, &test_dtv, packets[4]);
3351  FAIL_IF_NOT_NULL(rp);
3353 
3354  rp = Defrag(&test_tv, &test_dtv, packets[5]);
3355  FAIL_IF_NULL(rp);
3357 
3358  // clang-format off
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',
3369  };
3370  // clang-format on
3371 
3372  FAIL_IF(GET_PKT_LEN(rp) != 20 + sizeof(expected));
3373  if (memcmp(expected, GET_PKT_DATA(rp) + 20, sizeof(expected)) != 0) {
3374  printf("Expected:\n");
3375  PrintRawDataFp(stdout, expected, sizeof(expected));
3376  printf("Got:\n");
3377  PrintRawDataFp(stdout, GET_PKT_DATA(rp) + 20, GET_PKT_LEN(rp) - 20);
3378  FAIL;
3379  }
3380 
3381  /* Make sure all frags were returned back to the pool. */
3382  FAIL_IF(defrag_context->frag_pool->outstanding != 0);
3383 
3384  for (int i = 0; i < 6; i++) {
3385  PacketFree(packets[i]);
3386  }
3387  PacketFree(rp);
3388  DefragDestroy();
3389  PASS;
3390 }
3391 
3392 /** IPv6 variant of DefragBsdOverlapAfterCoveredStartsBeforeIpv4Test. */
3393 static int DefragBsdOverlapAfterCoveredStartsBeforeIpv6Test(void)
3394 {
3395  DefragInit();
3396  default_policy = DEFRAG_POLICY_BSD;
3397  Packet *packets[6];
3398 
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);
3405 
3406  Packet *rp = Defrag(&test_tv, &test_dtv, packets[0]);
3407  FAIL_IF_NOT_NULL(rp);
3408 
3409  rp = Defrag(&test_tv, &test_dtv, packets[1]);
3410  FAIL_IF_NOT_NULL(rp);
3411 
3412  rp = Defrag(&test_tv, &test_dtv, packets[2]);
3413  FAIL_IF_NOT_NULL(rp);
3414 
3415  rp = Defrag(&test_tv, &test_dtv, packets[3]);
3416  FAIL_IF_NOT_NULL(rp);
3417 
3418  rp = Defrag(&test_tv, &test_dtv, packets[4]);
3419  FAIL_IF_NOT_NULL(rp);
3421 
3422  rp = Defrag(&test_tv, &test_dtv, packets[5]);
3423  FAIL_IF_NULL(rp);
3425 
3426  // clang-format off
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',
3437  };
3438  // clang-format on
3439 
3440  FAIL_IF(GET_PKT_LEN(rp) != 40 + sizeof(expected));
3441  if (memcmp(expected, GET_PKT_DATA(rp) + 40, sizeof(expected)) != 0) {
3442  printf("Expected:\n");
3443  PrintRawDataFp(stdout, expected, sizeof(expected));
3444  printf("Got:\n");
3445  PrintRawDataFp(stdout, GET_PKT_DATA(rp) + 40, GET_PKT_LEN(rp) - 40);
3446  FAIL;
3447  }
3448 
3449  /* Make sure all frags were returned back to the pool. */
3450  FAIL_IF(defrag_context->frag_pool->outstanding != 0);
3451 
3452  for (int i = 0; i < 6; i++) {
3453  PacketFree(packets[i]);
3454  }
3455  PacketFree(rp);
3456  DefragDestroy();
3457  PASS;
3458 }
3459 
3460 /**
3461  * \test A BSD fragment must only trim the fragments that start after
3462  * it. E follows D in the fragment tree, but D starts before E and
3463  * must be left alone.
3464  *
3465  * Arrival:
3466  * A: 0..32
3467  * B: 16..56 (stored as 32..56)
3468  * C: 24..40 (stored as 32..40, trims B to 40..56)
3469  * D: 0..40 (stored as 32..40, fully covers C)
3470  * E: 40..56 (fully covered by B, must not trim D)
3471  * F: 56..64 (last)
3472  *
3473  * Expected: A*32 D*8 B*16 F*8
3474  */
3475 static int DefragBsdFollowingStartsBeforeNewIpv4Test(void)
3476 {
3477  DefragInit();
3478  default_policy = DEFRAG_POLICY_BSD;
3479  Packet *packets[6];
3480 
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);
3487 
3488  for (int i = 0; i < 5; i++) {
3489  Packet *rp = Defrag(&test_tv, &test_dtv, packets[i]);
3490  FAIL_IF_NOT_NULL(rp);
3491  }
3493 
3494  Packet *rp = Defrag(&test_tv, &test_dtv, packets[5]);
3495  FAIL_IF_NULL(rp);
3496 
3497  // clang-format off
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',
3507  };
3508  // clang-format on
3509 
3510  FAIL_IF(GET_PKT_LEN(rp) != 20 + sizeof(expected));
3511  if (memcmp(expected, GET_PKT_DATA(rp) + 20, sizeof(expected)) != 0) {
3512  printf("Expected:\n");
3513  PrintRawDataFp(stdout, expected, sizeof(expected));
3514  printf("Got:\n");
3515  PrintRawDataFp(stdout, GET_PKT_DATA(rp) + 20, GET_PKT_LEN(rp) - 20);
3516  FAIL;
3517  }
3518 
3519  /* Make sure all frags were returned back to the pool. */
3520  FAIL_IF(defrag_context->frag_pool->outstanding != 0);
3521 
3522  for (int i = 0; i < 6; i++) {
3523  PacketFree(packets[i]);
3524  }
3525  PacketFree(rp);
3526  DefragDestroy();
3527  PASS;
3528 }
3529 
3530 /** IPv6 variant of DefragBsdFollowingStartsBeforeNewIpv4Test. */
3531 static int DefragBsdFollowingStartsBeforeNewIpv6Test(void)
3532 {
3533  DefragInit();
3534  default_policy = DEFRAG_POLICY_BSD;
3535  Packet *packets[6];
3536 
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);
3543 
3544  for (int i = 0; i < 5; i++) {
3545  Packet *rp = Defrag(&test_tv, &test_dtv, packets[i]);
3546  FAIL_IF_NOT_NULL(rp);
3547  }
3549 
3550  Packet *rp = Defrag(&test_tv, &test_dtv, packets[5]);
3551  FAIL_IF_NULL(rp);
3552 
3553  // clang-format off
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',
3563  };
3564  // clang-format on
3565 
3566  FAIL_IF(GET_PKT_LEN(rp) != 40 + sizeof(expected));
3567  if (memcmp(expected, GET_PKT_DATA(rp) + 40, sizeof(expected)) != 0) {
3568  printf("Expected:\n");
3569  PrintRawDataFp(stdout, expected, sizeof(expected));
3570  printf("Got:\n");
3571  PrintRawDataFp(stdout, GET_PKT_DATA(rp) + 40, GET_PKT_LEN(rp) - 40);
3572  FAIL;
3573  }
3574 
3575  /* Make sure all frags were returned back to the pool. */
3576  FAIL_IF(defrag_context->frag_pool->outstanding != 0);
3577 
3578  for (int i = 0; i < 6; i++) {
3579  PacketFree(packets[i]);
3580  }
3581  PacketFree(rp);
3582  DefragDestroy();
3583  PASS;
3584 }
3585 
3586 /**
3587  * \test A later BSD overlap must not lower the left trim already set on the
3588  * next fragment.
3589  *
3590  * 'B' (16..48) starts before 'A' (24..56) and trims it to 48..56. 'C' (0..40)
3591  * then starts before 'B' and must not lower the trim of 'A' back to 40, or
3592  * 'A' overwrites the 40..48 bytes preferred from 'B'.
3593  *
3594  * |0 |8 |16 |24 |32 |40 |48 |56 |
3595  * |========|========|========|========|========|========|========|========|
3596  * | | | |AAAAAAAA|AAAAAAAA|AAAAAAAA|AAAAAAAA| |
3597  * | | |BBBBBBBB|BBBBBBBB|BBBBBBBB|BBBBBBBB| | |
3598  * |CCCCCCCC|CCCCCCCC|CCCCCCCC|CCCCCCCC|CCCCCCCC| | | |
3599  * | | | | | | | |DDDDDDDD|
3600  *
3601  * |CCCCCCCC|CCCCCCCC|CCCCCCCC|CCCCCCCC|CCCCCCCC|BBBBBBBB|AAAAAAAA|DDDDDDDD|
3602  */
3603 static int DefragBsdNextLtrimNotLoweredIpv4Test(void)
3604 {
3605  DefragInit();
3606  default_policy = DEFRAG_POLICY_BSD;
3607  Packet *packets[4];
3608 
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);
3613 
3614  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
3615  FAIL_IF_NOT_NULL(r);
3616 
3617  r = Defrag(&test_tv, &test_dtv, packets[1]);
3618  FAIL_IF_NOT_NULL(r);
3619 
3620  r = Defrag(&test_tv, &test_dtv, packets[2]);
3621  FAIL_IF_NOT_NULL(r);
3622 
3623  r = Defrag(&test_tv, &test_dtv, packets[3]);
3624  FAIL_IF_NULL(r);
3625 
3626  // clang-format off
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',
3636  };
3637  // clang-format on
3638 
3639  FAIL_IF(GET_PKT_LEN(r) != 20 + sizeof(expected));
3640  if (memcmp(expected, GET_PKT_DATA(r) + 20, sizeof(expected)) != 0) {
3641  printf("Expected:\n");
3642  PrintRawDataFp(stdout, expected, sizeof(expected));
3643  printf("Got:\n");
3644  PrintRawDataFp(stdout, GET_PKT_DATA(r) + 20, GET_PKT_LEN(r) - 20);
3645  FAIL;
3646  }
3647 
3648  for (int i = 0; i < 4; i++) {
3649  PacketFree(packets[i]);
3650  }
3651  PacketFree(r);
3652  DefragDestroy();
3653  PASS;
3654 }
3655 
3656 /** IPv6 variant of DefragBsdNextLtrimNotLoweredIpv4Test. */
3657 static int DefragBsdNextLtrimNotLoweredIpv6Test(void)
3658 {
3659  DefragInit();
3660  default_policy = DEFRAG_POLICY_BSD;
3661  Packet *packets[4];
3662 
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);
3667 
3668  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
3669  FAIL_IF_NOT_NULL(r);
3670 
3671  r = Defrag(&test_tv, &test_dtv, packets[1]);
3672  FAIL_IF_NOT_NULL(r);
3673 
3674  r = Defrag(&test_tv, &test_dtv, packets[2]);
3675  FAIL_IF_NOT_NULL(r);
3676 
3677  r = Defrag(&test_tv, &test_dtv, packets[3]);
3678  FAIL_IF_NULL(r);
3679 
3680  // clang-format off
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',
3690  };
3691  // clang-format on
3692 
3693  FAIL_IF(GET_PKT_LEN(r) != 40 + sizeof(expected));
3694  if (memcmp(expected, GET_PKT_DATA(r) + 40, sizeof(expected)) != 0) {
3695  printf("Expected:\n");
3696  PrintRawDataFp(stdout, expected, sizeof(expected));
3697  printf("Got:\n");
3698  PrintRawDataFp(stdout, GET_PKT_DATA(r) + 40, GET_PKT_LEN(r) - 40);
3699  FAIL;
3700  }
3701 
3702  for (int i = 0; i < 4; i++) {
3703  PacketFree(packets[i]);
3704  }
3705  PacketFree(r);
3706  DefragDestroy();
3707  PASS;
3708 }
3709 
3710 /**
3711  * \test A BSD-preferred fragment that starts within an earlier fragment trims
3712  * all of the following fragments it overlaps.
3713  *
3714  * 'D' (8..48) starts inside 'A' (0..16), so 'A' is preferred for 8..16. 'D'
3715  * starts before both 'B' (16..32) and 'C' (32..48), so it is preferred over
3716  * both of them, not just the immediate right-hand neighbour 'B'.
3717  *
3718  * |0 |8 |16 |24 |32 |40 |48 |
3719  * |========|========|========|========|========|========|========|
3720  * |AAAAAAAA|AAAAAAAA| | | | | |
3721  * | | |BBBBBBBB|BBBBBBBB| | | |
3722  * | | | | |CCCCCCCC|CCCCCCCC| |
3723  * | |DDDDDDDD|DDDDDDDD|DDDDDDDD|DDDDDDDD|DDDDDDDD| |
3724  * | | | | | | |EEEEEEEE|
3725  *
3726  * |AAAAAAAA|AAAAAAAA|DDDDDDDD|DDDDDDDD|DDDDDDDD|DDDDDDDD|EEEEEEEE|
3727  */
3728 static int DefragBsdTrimAllOverlappedStartsInsidePrevIpv4Test(void)
3729 {
3730  DefragInit();
3731  default_policy = DEFRAG_POLICY_BSD;
3732  Packet *packets[5];
3733 
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);
3739 
3740  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
3741  FAIL_IF_NOT_NULL(r);
3742 
3743  r = Defrag(&test_tv, &test_dtv, packets[1]);
3744  FAIL_IF_NOT_NULL(r);
3745 
3746  r = Defrag(&test_tv, &test_dtv, packets[2]);
3747  FAIL_IF_NOT_NULL(r);
3748 
3749  r = Defrag(&test_tv, &test_dtv, packets[3]);
3750  FAIL_IF_NOT_NULL(r);
3751 
3752  r = Defrag(&test_tv, &test_dtv, packets[4]);
3753  FAIL_IF_NULL(r);
3754 
3755  // clang-format off
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',
3764  };
3765  // clang-format on
3766 
3767  FAIL_IF(GET_PKT_LEN(r) != 20 + sizeof(expected));
3768  if (memcmp(expected, GET_PKT_DATA(r) + 20, sizeof(expected)) != 0) {
3769  printf("Expected:\n");
3770  PrintRawDataFp(stdout, expected, sizeof(expected));
3771  printf("Got:\n");
3772  PrintRawDataFp(stdout, GET_PKT_DATA(r) + 20, GET_PKT_LEN(r) - 20);
3773  FAIL;
3774  }
3775 
3776  for (int i = 0; i < 5; i++) {
3777  PacketFree(packets[i]);
3778  }
3779  PacketFree(r);
3780  DefragDestroy();
3781  PASS;
3782 }
3783 
3784 /** IPv6 variant of DefragBsdTrimAllOverlappedStartsInsidePrevIpv4Test. */
3785 static int DefragBsdTrimAllOverlappedStartsInsidePrevIpv6Test(void)
3786 {
3787  DefragInit();
3788  default_policy = DEFRAG_POLICY_BSD;
3789  Packet *packets[5];
3790 
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);
3796 
3797  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
3798  FAIL_IF_NOT_NULL(r);
3799 
3800  r = Defrag(&test_tv, &test_dtv, packets[1]);
3801  FAIL_IF_NOT_NULL(r);
3802 
3803  r = Defrag(&test_tv, &test_dtv, packets[2]);
3804  FAIL_IF_NOT_NULL(r);
3805 
3806  r = Defrag(&test_tv, &test_dtv, packets[3]);
3807  FAIL_IF_NOT_NULL(r);
3808 
3809  r = Defrag(&test_tv, &test_dtv, packets[4]);
3810  FAIL_IF_NULL(r);
3811 
3812  // clang-format off
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',
3821  };
3822  // clang-format on
3823 
3824  FAIL_IF(GET_PKT_LEN(r) != 40 + sizeof(expected));
3825  if (memcmp(expected, GET_PKT_DATA(r) + 40, sizeof(expected)) != 0) {
3826  printf("Expected:\n");
3827  PrintRawDataFp(stdout, expected, sizeof(expected));
3828  printf("Got:\n");
3829  PrintRawDataFp(stdout, GET_PKT_DATA(r) + 40, GET_PKT_LEN(r) - 40);
3830  FAIL;
3831  }
3832 
3833  for (int i = 0; i < 5; i++) {
3834  PacketFree(packets[i]);
3835  }
3836  PacketFree(r);
3837  DefragDestroy();
3838  PASS;
3839 }
3840 
3841 /**
3842  * \test A BSD-preferred fragment that starts before the first stored fragment
3843  * trims all of the following fragments it overlaps.
3844  *
3845  * 'D' (0..56) starts before 'A' (8..24), 'B' (24..40) and 'C' (40..56), so it
3846  * is preferred over all of them, not just 'A' and the immediate right-hand
3847  * neighbour 'B'.
3848  *
3849  * |0 |8 |16 |24 |32 |40 |48 |56 |
3850  * |========|========|========|========|========|========|========|========|
3851  * | |AAAAAAAA|AAAAAAAA| | | | | |
3852  * | | | |BBBBBBBB|BBBBBBBB| | | |
3853  * | | | | | |CCCCCCCC|CCCCCCCC| |
3854  * |DDDDDDDD|DDDDDDDD|DDDDDDDD|DDDDDDDD|DDDDDDDD|DDDDDDDD|DDDDDDDD| |
3855  * | | | | | | | |EEEEEEEE|
3856  *
3857  * |DDDDDDDD|DDDDDDDD|DDDDDDDD|DDDDDDDD|DDDDDDDD|DDDDDDDD|DDDDDDDD|EEEEEEEE|
3858  */
3859 static int DefragBsdTrimAllOverlappedStartsBeforeIpv4Test(void)
3860 {
3861  DefragInit();
3862  default_policy = DEFRAG_POLICY_BSD;
3863  Packet *packets[5];
3864 
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);
3870 
3871  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
3872  FAIL_IF_NOT_NULL(r);
3873 
3874  r = Defrag(&test_tv, &test_dtv, packets[1]);
3875  FAIL_IF_NOT_NULL(r);
3876 
3877  r = Defrag(&test_tv, &test_dtv, packets[2]);
3878  FAIL_IF_NOT_NULL(r);
3879 
3880  r = Defrag(&test_tv, &test_dtv, packets[3]);
3881  FAIL_IF_NOT_NULL(r);
3882 
3883  r = Defrag(&test_tv, &test_dtv, packets[4]);
3884  FAIL_IF_NULL(r);
3885 
3886  // clang-format off
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',
3896  };
3897  // clang-format on
3898 
3899  FAIL_IF(GET_PKT_LEN(r) != 20 + sizeof(expected));
3900  if (memcmp(expected, GET_PKT_DATA(r) + 20, sizeof(expected)) != 0) {
3901  printf("Expected:\n");
3902  PrintRawDataFp(stdout, expected, sizeof(expected));
3903  printf("Got:\n");
3904  PrintRawDataFp(stdout, GET_PKT_DATA(r) + 20, GET_PKT_LEN(r) - 20);
3905  FAIL;
3906  }
3907 
3908  for (int i = 0; i < 5; i++) {
3909  PacketFree(packets[i]);
3910  }
3911  PacketFree(r);
3912  DefragDestroy();
3913  PASS;
3914 }
3915 
3916 /** IPv6 variant of DefragBsdTrimAllOverlappedStartsBeforeIpv4Test. */
3917 static int DefragBsdTrimAllOverlappedStartsBeforeIpv6Test(void)
3918 {
3919  DefragInit();
3920  default_policy = DEFRAG_POLICY_BSD;
3921  Packet *packets[5];
3922 
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);
3928 
3929  Packet *r = Defrag(&test_tv, &test_dtv, packets[0]);
3930  FAIL_IF_NOT_NULL(r);
3931 
3932  r = Defrag(&test_tv, &test_dtv, packets[1]);
3933  FAIL_IF_NOT_NULL(r);
3934 
3935  r = Defrag(&test_tv, &test_dtv, packets[2]);
3936  FAIL_IF_NOT_NULL(r);
3937 
3938  r = Defrag(&test_tv, &test_dtv, packets[3]);
3939  FAIL_IF_NOT_NULL(r);
3940 
3941  r = Defrag(&test_tv, &test_dtv, packets[4]);
3942  FAIL_IF_NULL(r);
3943 
3944  // clang-format off
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',
3954  };
3955  // clang-format on
3956 
3957  FAIL_IF(GET_PKT_LEN(r) != 40 + sizeof(expected));
3958  if (memcmp(expected, GET_PKT_DATA(r) + 40, sizeof(expected)) != 0) {
3959  printf("Expected:\n");
3960  PrintRawDataFp(stdout, expected, sizeof(expected));
3961  printf("Got:\n");
3962  PrintRawDataFp(stdout, GET_PKT_DATA(r) + 40, GET_PKT_LEN(r) - 40);
3963  FAIL;
3964  }
3965 
3966  for (int i = 0; i < 5; i++) {
3967  PacketFree(packets[i]);
3968  }
3969  PacketFree(r);
3970  DefragDestroy();
3971  PASS;
3972 }
3973 
3974 /**
3975  * \test Reassemble a datagram where the fragment at offset 0 comes in last,
3976  * with the other fragments already in the tree. This is the RB_NFIND
3977  * search key case from ticket 8232.
3978  */
3979 static int DefragOutOfOrderFirstFragmentTest(void)
3980 {
3981  Packet *p1 = NULL, *p2 = NULL, *p3 = NULL, *p4 = NULL;
3982  Packet *reassembled = NULL;
3983  int id = 8232;
3984 
3985  DefragInit();
3986  default_policy = DEFRAG_POLICY_BSD;
3987 
3988  /* four fragments, no overlaps, offset 0 delivered last */
3989  p1 = BuildIpv4TestPacket(IPPROTO_ICMP, id, 24 >> 3, 0, 'D', 8);
3990  FAIL_IF_NULL(p1);
3991  p2 = BuildIpv4TestPacket(IPPROTO_ICMP, id, 8 >> 3, 1, 'B', 8);
3992  FAIL_IF_NULL(p2);
3993  p3 = BuildIpv4TestPacket(IPPROTO_ICMP, id, 16 >> 3, 1, 'C', 8);
3994  FAIL_IF_NULL(p3);
3995  p4 = BuildIpv4TestPacket(IPPROTO_ICMP, id, 0, 1, 'A', 8);
3996  FAIL_IF_NULL(p4);
3997 
3998  FAIL_IF(Defrag(&test_tv, &test_dtv, p1) != NULL);
3999  FAIL_IF(Defrag(&test_tv, &test_dtv, p2) != NULL);
4000  FAIL_IF(Defrag(&test_tv, &test_dtv, p3) != NULL);
4001 
4002  reassembled = Defrag(&test_tv, &test_dtv, p4);
4003  FAIL_IF_NULL(reassembled);
4004 
4005  FAIL_IF(IPV4_GET_RAW_HLEN(PacketGetIPv4(reassembled)) != 20);
4006  FAIL_IF(IPV4_GET_RAW_IPLEN(PacketGetIPv4(reassembled)) != 20 + 32);
4007 
4008  for (int i = 20 + 0; i < 20 + 8; i++)
4009  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'A');
4010  for (int i = 20 + 8; i < 20 + 16; i++)
4011  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'B');
4012  for (int i = 20 + 16; i < 20 + 24; i++)
4013  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'C');
4014  for (int i = 20 + 24; i < 20 + 32; i++)
4015  FAIL_IF(GET_PKT_DATA(reassembled)[i] != 'D');
4016 
4017  PacketFree(p1);
4018  PacketFree(p2);
4019  PacketFree(p3);
4020  PacketFree(p4);
4021  PacketFree(reassembled);
4022 
4023  DefragDestroy();
4024  PASS;
4025 }
4026 
4027 /**
4028  * \test A fragment arrives at an offset that is already in the tree, with an
4029  * earlier fragment overlapping it from the left. Keeps the frag_offset - 1
4030  * search key honest: with frag_offset the seek skips the overlapping
4031  * fragment and 16..24 comes out as 'B' instead of 'D'.
4032  */
4033 static int DefragSameOffsetPrecedingOverlapTest(void)
4034 {
4035  Packet *packets[5] = { NULL };
4036  Packet *reassembled = NULL;
4037  int id = 8232;
4038 
4039  DefragInit();
4040  default_policy = DEFRAG_POLICY_BSD;
4041 
4042  /* B 8..24 goes in first so it keeps offset 8. A only sets its ltrim later,
4043  * otherwise BSD would bake the trim into the stored offset. */
4044  FAIL_IF_NOT(BuildIpv4TestPacketWithContent(
4045  &packets[0], IPPROTO_ICMP, id, 8 >> 3, 1, (uint8_t *)"BBBBBBBBBBBBBBBB", 16));
4046  /* A 0..16, overlaps B and D from the left */
4047  FAIL_IF_NOT(BuildIpv4TestPacketWithContent(
4048  &packets[1], IPPROTO_ICMP, id, 0, 1, (uint8_t *)"AAAAAAAAAAAAAAAA", 16));
4049  /* C 24..32, the node RB_NFIND(8) lands on */
4050  FAIL_IF_NOT(BuildIpv4TestPacketWithContent(
4051  &packets[2], IPPROTO_ICMP, id, 24 >> 3, 1, (uint8_t *)"CCCCCCCC", 8));
4052  /* D 8..24, same offset as B, has to be reconciled against A */
4053  FAIL_IF_NOT(BuildIpv4TestPacketWithContent(
4054  &packets[3], IPPROTO_ICMP, id, 8 >> 3, 1, (uint8_t *)"DDDDDDDDDDDDDDDD", 16));
4055  /* E 32..40, last fragment, kicks off reassembly */
4056  FAIL_IF_NOT(BuildIpv4TestPacketWithContent(
4057  &packets[4], IPPROTO_ICMP, id, 32 >> 3, 0, (uint8_t *)"EEEEEEEE", 8));
4058 
4059  for (int i = 0; i < 4; i++)
4060  FAIL_IF(Defrag(&test_tv, &test_dtv, packets[i]) != NULL);
4061  reassembled = Defrag(&test_tv, &test_dtv, packets[4]);
4062  FAIL_IF_NULL(reassembled);
4063 
4064  FAIL_IF(IPV4_GET_RAW_IPLEN(PacketGetIPv4(reassembled)) != 20 + 40);
4065 
4066  // clang-format off
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',
4073  };
4074  // clang-format on
4075  FAIL_IF(memcmp(expected, GET_PKT_DATA(reassembled) + 20, sizeof(expected)) != 0);
4076 
4077  for (int i = 0; i < 5; i++)
4078  PacketFree(packets[i]);
4079  PacketFree(reassembled);
4080 
4081  DefragDestroy();
4082  PASS;
4083 }
4084 
4085 #endif /* UNITTESTS */
4086 
4088 {
4089 #ifdef UNITTESTS
4090  UtRegisterTest("DefragInOrderSimpleTest", DefragInOrderSimpleTest);
4091  UtRegisterTest("DefragReverseSimpleTest", DefragReverseSimpleTest);
4092  UtRegisterTest("DefragSturgesNovakBsdTest", DefragSturgesNovakBsdTest);
4093  UtRegisterTest("DefragSturgesNovakLinuxIpv4Test",
4094  DefragSturgesNovakLinuxIpv4Test);
4095  UtRegisterTest("DefragSturgesNovakWindowsIpv4Test",
4096  DefragSturgesNovakWindowsIpv4Test);
4097  UtRegisterTest("DefragSturgesNovakSolarisTest",
4098  DefragSturgesNovakSolarisTest);
4099  UtRegisterTest("DefragSturgesNovakFirstTest", DefragSturgesNovakFirstTest);
4100  UtRegisterTest("DefragSturgesNovakLastTest", DefragSturgesNovakLastTest);
4101 
4102  UtRegisterTest("DefragNoDataIpv4Test", DefragNoDataIpv4Test);
4103  UtRegisterTest("DefragTooLargeIpv4Test", DefragTooLargeIpv4Test);
4104 
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);
4113 
4114  UtRegisterTest("DefragVlanTest", DefragVlanTest);
4115  UtRegisterTest("DefragVlanQinQTest", DefragVlanQinQTest);
4116  UtRegisterTest("DefragVlanQinQinQTest", DefragVlanQinQinQTest);
4117  UtRegisterTest("DefragTrackerReuseTest", DefragTrackerReuseTest);
4118  UtRegisterTest("DefragTimeoutTest", DefragTimeoutTest);
4119  UtRegisterTest("DefragMfIpv4Test", DefragMfIpv4Test);
4120  UtRegisterTest("DefragMfIpv6Test", DefragMfIpv6Test);
4121  UtRegisterTest("DefragTestBadProto", DefragTestBadProto);
4122 
4123  UtRegisterTest("DefragTestJeremyLinux", DefragTestJeremyLinux);
4124 
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);
4155  UtRegisterTest("DefragBsdTrimAllOverlappedStartsBeforeIpv4Test",
4156  DefragBsdTrimAllOverlappedStartsBeforeIpv4Test);
4157  UtRegisterTest("DefragBsdTrimAllOverlappedStartsBeforeIpv6Test",
4158  DefragBsdTrimAllOverlappedStartsBeforeIpv6Test);
4159  UtRegisterTest("DefragOutOfOrderFirstFragmentTest", DefragOutOfOrderFirstFragmentTest);
4160  UtRegisterTest("DefragSameOffsetPrecedingOverlapTest", DefragSameOffsetPrecedingOverlapTest);
4161 #endif /* UNITTESTS */
4162 }
ENGINE_SET_EVENT
#define ENGINE_SET_EVENT(p, e)
Definition: decode.h:1240
DEFAULT_DEFRAG_HASH_SIZE
#define DEFAULT_DEFRAG_HASH_SIZE
Definition: defrag.c:63
Frag_
Definition: defrag.h:47
DEFRAG_POLICY_LINUX
@ DEFRAG_POLICY_LINUX
Definition: defrag.c:88
DefragDestroy
void DefragDestroy(void)
Definition: defrag.c:1162
IPV4_GET_RAW_IPID
#define IPV4_GET_RAW_IPID(ip4h)
Definition: decode-ipv4.h:99
DefragTrackerFreeFrags
void DefragTrackerFreeFrags(DefragTracker *tracker)
Free all frags associated with a tracker.
Definition: defrag.c:118
DefragLookupTrackerFromHash
DefragTracker * DefragLookupTrackerFromHash(Packet *p)
look up a tracker in the hash
Definition: defrag-hash.c:625
len
uint8_t len
Definition: app-layer-dnp3.h:2
DecodeThreadVars_::counter_defrag_ipv6_fragments
StatsCounterId counter_defrag_ipv6_fragments
Definition: decode.h:1080
D_7
#define D_7
Definition: defrag.c:1899
FAIL_IF_NULL
#define FAIL_IF_NULL(expr)
Fail a test if expression evaluates to NULL.
Definition: util-unittest.h:89
IPV6_GET_RAW_PLEN
#define IPV6_GET_RAW_PLEN(ip6h)
Definition: decode-ipv6.h:66
TIMEOUT_MIN
#define TIMEOUT_MIN
Definition: defrag.c:80
OS_POLICY_FIRST
@ OS_POLICY_FIRST
Definition: stream-tcp-reassemble.h:50
IPV6_GET_RAW_VER
#define IPV6_GET_RAW_VER(ip6h)
Definition: decode-ipv6.h:62
OS_POLICY_WINDOWS
@ OS_POLICY_WINDOWS
Definition: stream-tcp-reassemble.h:47
offset
uint64_t offset
Definition: util-streaming-buffer.h:0
IPV4Hdr_::ip_ttl
uint8_t ip_ttl
Definition: decode-ipv4.h:78
PacketFreeOrRelease
void PacketFreeOrRelease(Packet *p)
Return a packet to where it was allocated.
Definition: decode.c:291
D_11
#define D_11
Definition: defrag.c:1903
util-hashlist.h
IPV4_GET_RAW_IPPROTO
#define IPV4_GET_RAW_IPPROTO(ip4h)
Definition: decode-ipv4.h:103
D_3_4
#define D_3_4
Definition: defrag.c:1893
OS_POLICY_OLD_SOLARIS
@ OS_POLICY_OLD_SOLARIS
Definition: stream-tcp-reassemble.h:41
IPV6_EXTHDR_GET_FH_OFFSET
#define IPV6_EXTHDR_GET_FH_OFFSET(p)
Definition: decode-ipv6.h:101
IPV6_GET_RAW_NH
#define IPV6_GET_RAW_NH(ip6h)
Definition: decode-ipv6.h:65
test_tv
ThreadVars test_tv
Definition: defrag.c:1176
PacketCopyData
int PacketCopyData(Packet *p, const uint8_t *pktdata, uint32_t pktlen)
Copy data to Packet payload and set packet length.
Definition: decode.c:396
D_3_3
#define D_3_3
Definition: defrag.c:1892
RB_REMOVE
#define RB_REMOVE(name, x, y)
Definition: tree.h:773
IPV4_GET_RAW_FLAG_MF
#define IPV4_GET_RAW_FLAG_MF(ip4h)
Definition: decode-ipv4.h:112
unlikely
#define unlikely(expr)
Definition: util-optimize.h:35
PacketL3::vars
union PacketL3::@30 vars
UtRegisterTest
void UtRegisterTest(const char *name, int(*TestFn)(void))
Register unit test.
Definition: util-unittest.c:101
D_4
#define D_4
Definition: defrag.c:1896
ENGINE_ISSET_EVENT
#define ENGINE_ISSET_EVENT(p, e)
Definition: decode.h:1253
PcapPacketCntGet
uint64_t PcapPacketCntGet(const Packet *p)
Definition: decode.c:1244
SCLogDebug
#define SCLogDebug(...)
Definition: util-debug.h:282
DecodeThreadVars_::counter_defrag_no_frags
StatsCounterId counter_defrag_no_frags
Definition: decode.h:1083
OS_POLICY_VISTA
@ OS_POLICY_VISTA
Definition: stream-tcp-reassemble.h:48
next
struct HtpBodyChunk_ * next
Definition: app-layer-htp.h:0
TIMEOUT_MAX
#define TIMEOUT_MAX
Definition: defrag.c:75
PacketDefragPktSetup
Packet * PacketDefragPktSetup(Packet *parent, const uint8_t *pkt, uint32_t len, uint8_t proto)
Setup a pseudo packet (reassembled frags)
Definition: decode.c:522
OS_POLICY_HPUX11
@ OS_POLICY_HPUX11
Definition: stream-tcp-reassemble.h:44
Packet_::flags
uint32_t flags
Definition: decode.h:582
IPV6_SET_RAW_VER
#define IPV6_SET_RAW_VER(ip6h, value)
Definition: decode-ipv6.h:69
IPV6_FRAG_OVERLAP
@ IPV6_FRAG_OVERLAP
Definition: decode-events.h:192
threads.h
DefragTracker_::ip_hdr_offset
uint16_t ip_hdr_offset
Definition: defrag.h:90
IP_MF
#define IP_MF
Definition: defrag.c:1174
OS_POLICY_BSD
@ OS_POLICY_BSD
Definition: stream-tcp-reassemble.h:37
Frag_::data_len
uint16_t data_len
Definition: defrag.h:62
PacketCopyDataOffset
int PacketCopyDataOffset(Packet *p, uint32_t offset, const uint8_t *data, uint32_t datalen)
Copy data to Packet payload at given offset.
Definition: decode.c:350
D_3_5
#define D_3_5
Definition: defrag.c:1894
IPV4Hdr_::ip_id
uint16_t ip_id
Definition: decode-ipv4.h:76
SCMutexLock
#define SCMutexLock(mut)
Definition: threads-debug.h:117
RB_MIN
#define RB_MIN(name, x)
Definition: tree.h:778
DefragContext_::frag_pool
Pool * frag_pool
Definition: defrag.h:38
D_3
#define D_3
Definition: defrag.c:1889
DefragTracker_::host_timeout
uint32_t host_timeout
Definition: defrag.h:114
stream-tcp-reassemble.h
p
Packet * p
Definition: fuzz_dataset.c:30
proto
uint8_t proto
Definition: decode-template.h:0
defrag-config.h
D_2
#define D_2
Definition: defrag.c:1888
TmqhOutputPacketpool
void TmqhOutputPacketpool(ThreadVars *t, Packet *p)
Definition: tmqh-packetpool.c:305
OS_POLICY_IRIX
@ OS_POLICY_IRIX
Definition: stream-tcp-reassemble.h:45
MAX
#define MAX(x, y)
Definition: suricata-common.h:417
DecodeThreadVars_::counter_defrag_ipv4_reassembled
StatsCounterId counter_defrag_ipv4_reassembled
Definition: decode.h:1079
DefragRbFragCompare
int DefragRbFragCompare(struct Frag_ *a, struct Frag_ *b)
Definition: defrag.c:532
OS_POLICY_WINDOWS2K3
@ OS_POLICY_WINDOWS2K3
Definition: stream-tcp-reassemble.h:49
OS_POLICY_BSD_RIGHT
@ OS_POLICY_BSD_RIGHT
Definition: stream-tcp-reassemble.h:38
GET_IPV6_DST_ADDR
#define GET_IPV6_DST_ADDR(p)
Definition: decode.h:222
tmqh-packetpool.h
D_10
#define D_10
Definition: defrag.c:1902
util-unittest-helper.h
FAIL_IF_NOT
#define FAIL_IF_NOT(expr)
Fail a test if expression evaluates to false.
Definition: util-unittest.h:82
TM_ECODE_OK
@ TM_ECODE_OK
Definition: tm-threads-common.h:81
DEFRAG_POLICY_LAST
@ DEFRAG_POLICY_LAST
Definition: defrag.c:85
Packet_::datalink
int datalink
Definition: decode.h:672
DefragTracker_::lock
SCMutex lock
Definition: defrag.h:86
PKT_SET_SRC
#define PKT_SET_SRC(p, src_val)
Definition: decode.h:1375
defrag_policies
defrag_policies
Definition: defrag.c:83
DefragGetOsPolicy
uint8_t DefragGetOsPolicy(Packet *p)
Get the defrag policy based on the destination address of the packet.
Definition: defrag.c:989
DecodeThreadVars_::counter_defrag_max_hit
StatsCounterId counter_defrag_max_hit
Definition: decode.h:1082
IPV4Hdr_::ip_len
uint16_t ip_len
Definition: decode-ipv4.h:75
util-fix_checksum.h
SET_PKT_LEN
#define SET_PKT_LEN(p, len)
Definition: decode.h:231
SCTIME_FROM_SECS
#define SCTIME_FROM_SECS(s)
Definition: util-time.h:69
IPV6_EXTHDR_GET_FH_FLAG
#define IPV6_EXTHDR_GET_FH_FLAG(p)
Definition: decode-ipv6.h:102
decode-ipv6.h
DefragContext_::frag_pool_lock
SCMutex frag_pool_lock
Definition: defrag.h:39
DefragTracker_::remove
uint8_t remove
Definition: defrag.h:105
decode.h
RB_EMPTY
#define RB_EMPTY(head)
Definition: tree.h:327
FAIL_IF_NOT_NULL
#define FAIL_IF_NOT_NULL(expr)
Fail a test if expression evaluates to non-NULL.
Definition: util-unittest.h:96
util-debug.h
RB_NFIND
#define RB_NFIND(name, x, y)
Definition: tree.h:775
SCHInfoGetIPv6HostOSFlavour
int SCHInfoGetIPv6HostOSFlavour(uint8_t *addr)
Retrieves the host os flavour, given an ipv6 address in the raw address format.
Definition: util-host-os-info.c:260
DEFRAG_POLICY_WINDOWS
@ DEFRAG_POLICY_WINDOWS
Definition: defrag.c:89
PASS
#define PASS
Pass the test.
Definition: util-unittest.h:105
GET_IPV4_DST_ADDR_PTR
#define GET_IPV4_DST_ADDR_PTR(p)
Definition: decode.h:217
OS_POLICY_LINUX
@ OS_POLICY_LINUX
Definition: stream-tcp-reassemble.h:40
OS_POLICY_SOLARIS
@ OS_POLICY_SOLARIS
Definition: stream-tcp-reassemble.h:42
IPV6_FRAG_IGNORED
@ IPV6_FRAG_IGNORED
Definition: decode-events.h:197
Packet_::ts
SCTime_t ts
Definition: decode.h:590
DefragTracker_::seen_last
uint8_t seen_last
Definition: defrag.h:103
IPV4_GET_RAW_FRAGOFFSET
#define IPV4_GET_RAW_FRAGOFFSET(ip4h)
Definition: decode-ipv4.h:101
DefragTracker_::policy
uint8_t policy
Definition: defrag.h:98
SCMutexUnlock
#define SCMutexUnlock(mut)
Definition: threads-debug.h:120
DecodeIPV6FragHeader
void DecodeIPV6FragHeader(Packet *p, const uint8_t *pkt, uint16_t hdrextlen, uint16_t plen, uint16_t prev_hdrextlen)
Definition: decode-ipv6.c:94
DefragTracker_
Definition: defrag.h:85
SCConfGetInt
int SCConfGetInt(const char *name, intmax_t *val)
Retrieve a configuration value as an integer.
Definition: conf.c:440
IPV4_FRAG_PKT_TOO_LARGE
@ IPV4_FRAG_PKT_TOO_LARGE
Definition: decode-events.h:189
util-print.h
RB_FOREACH_SAFE
#define RB_FOREACH_SAFE(x, name, head, y)
Definition: tree.h:791
GET_PKT_DATA
#define GET_PKT_DATA(p)
Definition: decode.h:227
IPV4_MAXPACKET_LEN
#define IPV4_MAXPACKET_LEN
Definition: decode-ipv4.h:30
DefragRegisterTests
void DefragRegisterTests(void)
Definition: defrag.c:4087
ThreadVars_
Per thread variable structure.
Definition: threadvars.h:57
Pool_::outstanding
uint32_t outstanding
Definition: util-pool.h:65
DefragContext_::timeout
uint32_t timeout
Definition: defrag.h:41
SCTIME_FROM_TIMEVAL
#define SCTIME_FROM_TIMEVAL(tv)
Definition: util-time.h:79
IPV4_GET_RAW_HLEN
#define IPV4_GET_RAW_HLEN(ip4h)
Definition: decode-ipv4.h:96
OS_POLICY_HPUX10
@ OS_POLICY_HPUX10
Definition: stream-tcp-reassemble.h:43
IPV6_FRAG_PKT_TOO_LARGE
@ IPV6_FRAG_PKT_TOO_LARGE
Definition: decode-events.h:190
StatsCounterIncr
void StatsCounterIncr(StatsThreadContext *stats, StatsCounterId id)
Increments the local counter.
Definition: counters.c:163
PacketFree
void PacketFree(Packet *p)
Return a malloced packet.
Definition: decode.c:231
FixChecksum
uint16_t FixChecksum(uint16_t sum, uint16_t old, uint16_t new)
Fix-up an IP checksum.
Definition: util-fix_checksum.c:51
PacketL3::ip6
struct PacketL3::@30::@31 ip6
PrintRawDataFp
void PrintRawDataFp(FILE *fp, const uint8_t *buf, uint32_t buflen)
Definition: util-print.c:112
SET_IPV4_SRC_ADDR
#define SET_IPV4_SRC_ADDR(ip4h, a)
Definition: decode.h:158
DefragSetDefaultTimeout
void DefragSetDefaultTimeout(int timeout)
Definition: defrag-config.c:132
SET_IPV6_SRC_ADDR
#define SET_IPV6_SRC_ADDR(ip6h, a)
Definition: decode.h:177
RB_FOREACH
#define RB_FOREACH(x, name, head)
Definition: tree.h:781
IPV6Hdr_
Definition: decode-ipv6.h:32
D_3_2
#define D_3_2
Definition: defrag.c:1891
Packet_
Definition: decode.h:528
DefragTracker_::id
uint32_t id
Definition: defrag.h:93
D_8
#define D_8
Definition: defrag.c:1900
IPV4_GET_RAW_IPTTL
#define IPV4_GET_RAW_IPTTL(ip4h)
Definition: decode-ipv4.h:102
DEFRAG_POLICY_FIRST
@ DEFRAG_POLICY_FIRST
Definition: defrag.c:84
GET_PKT_LEN
#define GET_PKT_LEN(p)
Definition: decode.h:226
PoolFree
void PoolFree(Pool *p)
Definition: util-pool.c:204
stream-tcp-private.h
conf.h
D_6
#define D_6
Definition: defrag.c:1898
IPV4_GET_RAW_VER
#define IPV4_GET_RAW_VER(ip4h)
Definition: decode-ipv4.h:95
Frag_::skip
uint8_t skip
Definition: defrag.h:54
DefragInitConfig
void DefragInitConfig(bool quiet)
initialize the configuration
Definition: defrag-hash.c:168
Frag_::pkt
uint8_t * pkt
Definition: defrag.h:67
Frag_::data_offset
uint16_t data_offset
Definition: defrag.h:61
queue.h
defrag.h
D_9
#define D_9
Definition: defrag.c:1901
DefragTrackerRelease
void DefragTrackerRelease(DefragTracker *t)
Definition: defrag-hash.c:151
D_3_6
#define D_3_6
Definition: defrag.c:1895
DecodeIPV6
int DecodeIPV6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, const uint8_t *pkt, uint32_t len)
Definition: decode-ipv6.c:551
SCMutexInit
#define SCMutexInit(mut, mutattrs)
Definition: threads-debug.h:116
DefragContext_
Definition: defrag.h:37
Frag_::ltrim
uint16_t ltrim
Definition: defrag.h:64
util-host-os-info.h
dtv
DecodeThreadVars * dtv
Definition: fuzz_decodepcapfile.c:35
OS_POLICY_LAST
@ OS_POLICY_LAST
Definition: stream-tcp-reassemble.h:51
IPV4Hdr_
Definition: decode-ipv4.h:72
default_packet_size
uint32_t default_packet_size
Definition: decode.c:77
PoolReturn
void PoolReturn(Pool *p, void *data)
Definition: util-pool.c:305
D_1
#define D_1
Definition: defrag.c:1887
DefragTracker_::fragment_tree
struct IP_FRAGMENTS fragment_tree
Definition: defrag.h:119
FAIL_IF
#define FAIL_IF(expr)
Fail a test if expression evaluates to true.
Definition: util-unittest.h:71
DefragTreeDestroy
void DefragTreeDestroy(void)
Definition: defrag-config.c:161
IPV6Hdr
struct IPV6Hdr_ IPV6Hdr
suricata-common.h
Frag_::len
uint32_t len
Definition: defrag.h:56
IPV4_HEADER_LEN
#define IPV4_HEADER_LEN
Definition: decode-ipv4.h:28
packet.h
DefragTracker_::timeout
SCTime_t timeout
Definition: defrag.h:113
SCTIME_SECS
#define SCTIME_SECS(t)
Definition: util-time.h:57
FatalError
#define FatalError(...)
Definition: util-debug.h:517
test_dtv
DecodeThreadVars test_dtv
Definition: defrag.c:1177
PKT_SRC_DEFRAG
@ PKT_SRC_DEFRAG
Definition: decode.h:74
DefragPolicyLoadFromConfig
void DefragPolicyLoadFromConfig(void)
Definition: defrag-config.c:138
DEFRAG_POLICY_SOLARIS
@ DEFRAG_POLICY_SOLARIS
Definition: defrag.c:90
OS_POLICY_MACOS
@ OS_POLICY_MACOS
Definition: stream-tcp-reassemble.h:46
tv
ThreadVars * tv
Definition: fuzz_decodepcapfile.c:34
Frag_::frag_hdr_offset
uint16_t frag_hdr_offset
Definition: defrag.h:58
util-validate.h
SCMalloc
#define SCMalloc(sz)
Definition: util-mem.h:47
IPV6_MAXPACKET
#define IPV6_MAXPACKET
Definition: decode-ipv6.h:28
Packet_::l3
struct PacketL3 l3
Definition: decode.h:635
Packet_::root
struct Packet_ * root
Definition: decode.h:686
PoolGet
void * PoolGet(Pool *p)
Definition: util-pool.c:250
PKT_REBUILT_FRAGMENT
#define PKT_REBUILT_FRAGMENT
Definition: decode.h:1356
SCFree
#define SCFree(p)
Definition: util-mem.h:61
DecodeThreadVars_
Structure to hold thread specific data for all decode modules.
Definition: decode.h:1015
MAX_PAYLOAD_SIZE
#define MAX_PAYLOAD_SIZE
Definition: decode.h:734
Frag_::more_frags
uint8_t more_frags
Definition: defrag.h:53
DefragTracker_::af
uint8_t af
Definition: defrag.h:100
IPV6_EXTHDR_GET_FH_NH
#define IPV6_EXTHDR_GET_FH_NH(p)
Definition: decode-ipv6.h:100
DecodeThreadVars_::counter_defrag_ipv4_fragments
StatsCounterId counter_defrag_ipv4_fragments
Definition: decode.h:1078
payload_len
uint16_t payload_len
Definition: stream-tcp-private.h:1
FAIL
#define FAIL
Fail a test.
Definition: util-unittest.h:60
DefragTracker_::datalink
int datalink
Definition: defrag.h:112
PoolInit
Pool * PoolInit(const uint32_t size, const uint32_t prealloc_size, const uint32_t elt_size, void *(*Alloc)(void), int(*Init)(void *), void(*Cleanup)(void *))
Init a Pool.
Definition: util-pool.c:81
SCConfSet
int SCConfSet(const char *name, const char *val)
Set a configuration value.
Definition: conf.c:241
util-random.h
SCHInfoGetIPv4HostOSFlavour
int SCHInfoGetIPv4HostOSFlavour(uint8_t *addr)
Retrieves the host os flavour, given an ipv4 address in the raw address format.
Definition: util-host-os-info.c:243
IPV4Hdr_::ip_csum
uint16_t ip_csum
Definition: decode-ipv4.h:80
DecodeThreadVars_::counter_defrag_ipv6_reassembled
StatsCounterId counter_defrag_ipv6_reassembled
Definition: decode.h:1081
DEFRAG_POLICY_DEFAULT
@ DEFRAG_POLICY_DEFAULT
Definition: defrag.c:92
suricata.h
defrag-hash.h
Packet_::dst
Address dst
Definition: decode.h:533
TIMEOUT_DEFAULT
#define TIMEOUT_DEFAULT
Definition: defrag.c:70
D_3_1
#define D_3_1
Definition: defrag.c:1890
D_5
#define D_5
Definition: defrag.c:1897
OS_POLICY_OLD_LINUX
@ OS_POLICY_OLD_LINUX
Definition: stream-tcp-reassemble.h:39
IPV6_HEADER_LEN
#define IPV6_HEADER_LEN
Definition: decode-ipv6.h:27
IPV4_GET_RAW_IPLEN
#define IPV4_GET_RAW_IPLEN(ip4h)
Definition: decode-ipv4.h:98
Packet_::vlan_id
uint16_t vlan_id[VLAN_MAX_LAYERS]
Definition: decode.h:560
af
uint16_t af
Definition: decode-gre.h:0
Frag_::hlen
uint8_t hlen
Definition: defrag.h:51
DEFAULT_DEFRAG_POOL_SIZE
#define DEFAULT_DEFRAG_POOL_SIZE
Definition: defrag.c:64
PacketDefragPktSetupParent
void PacketDefragPktSetupParent(Packet *parent)
inform defrag "parent" that a pseudo packet is now associated to it.
Definition: decode.c:572
DefragGetTrackerFromHash
DefragTracker * DefragGetTrackerFromHash(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p)
Definition: defrag-hash.c:530
DefragHashShutdown
void DefragHashShutdown(void)
shutdown the flow engine
Definition: defrag-hash.c:291
PacketInit
bool PacketInit(Packet *p)
Initialize a packet structure for use.
Definition: packet.c:74
RB_GENERATE
RB_GENERATE(IP_FRAGMENTS, Frag_, rb, DefragRbFragCompare)
IPV4Hdr_::ip_off
uint16_t ip_off
Definition: decode-ipv4.h:77
RB_FOREACH_FROM
#define RB_FOREACH_FROM(x, name, y)
Definition: tree.h:786
Defrag
Packet * Defrag(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p)
Entry point for IPv4 and IPv6 fragments.
Definition: defrag.c:1067
SET_IPV4_DST_ADDR
#define SET_IPV4_DST_ADDR(ip4h, a)
Definition: decode.h:167
DecodeIPV4
int DecodeIPV4(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, const uint8_t *pkt, uint16_t len)
Definition: decode-ipv4.c:515
SCTIME_ADD_SECS
#define SCTIME_ADD_SECS(ts, s)
Definition: util-time.h:64
SET_IPV6_DST_ADDR
#define SET_IPV6_DST_ADDR(ip6h, a)
Definition: decode.h:186
SCCalloc
#define SCCalloc(nm, sz)
Definition: util-mem.h:53
IPV4Hdr_::ip_proto
uint8_t ip_proto
Definition: decode-ipv4.h:79
util-pool.h
ThreadVars_::stats
StatsThreadContext stats
Definition: threadvars.h:120
IPV4_FRAG_OVERLAP
@ IPV4_FRAG_OVERLAP
Definition: decode-events.h:191
IPV4Hdr_::ip_verhl
uint8_t ip_verhl
Definition: decode-ipv4.h:73
DEFRAG_POLICY_BSD
@ DEFRAG_POLICY_BSD
Definition: defrag.c:86
DEBUG_VALIDATE_BUG_ON
#define DEBUG_VALIDATE_BUG_ON(exp)
Definition: util-validate.h:109
Frag_::offset
uint16_t offset
Definition: defrag.h:48
Packet_::src
Address src
Definition: decode.h:532
DefragInit
void DefragInit(void)
Definition: defrag.c:1142
IPV4_FRAG_IGNORED
@ IPV4_FRAG_IGNORED
Definition: decode-events.h:196
DEFRAG_POLICY_BSD_RIGHT
@ DEFRAG_POLICY_BSD_RIGHT
Definition: defrag.c:87