Move network internal code to internal package

Utilities written to be common across IPv4/IPv6 are not planned to be
available for public use.

https://golang.org/doc/go1.4#internalpackages

PiperOrigin-RevId: 356554862

5 files changed, 0 insertions, 1443 deletions

diff --git a/pkg/tcpip/network/fragmentation/BUILD b/pkg/tcpip/network/fragmentation/BUILD
deleted file mode 100644
index 429af69ee..000000000
--- a/pkg/tcpip/network/fragmentation/BUILD
+++ /dev/null
@@ -1,51 +0,0 @@
-load("//tools:defs.bzl", "go_library", "go_test")
-load("//tools/go_generics:defs.bzl", "go_template_instance")
-
-package(licenses = ["notice"])
-
-go_template_instance(
-    name = "reassembler_list",
-    out = "reassembler_list.go",
-    package = "fragmentation",
-    prefix = "reassembler",
-    template = "//pkg/ilist:generic_list",
-    types = {
-        "Element": "*reassembler",
-        "Linker": "*reassembler",
-    },
-)
-
-go_library(
-    name = "fragmentation",
-    srcs = [
-        "fragmentation.go",
-        "reassembler.go",
-        "reassembler_list.go",
-    ],
-    visibility = ["//visibility:public"],
-    deps = [
-        "//pkg/log",
-        "//pkg/sync",
-        "//pkg/tcpip",
-        "//pkg/tcpip/buffer",
-        "//pkg/tcpip/header",
-        "//pkg/tcpip/stack",
-    ],
-)
-
-go_test(
-    name = "fragmentation_test",
-    size = "small",
-    srcs = [
-        "fragmentation_test.go",
-        "reassembler_test.go",
-    ],
-    library = ":fragmentation",
-    deps = [
-        "//pkg/tcpip/buffer",
-        "//pkg/tcpip/faketime",
-        "//pkg/tcpip/network/testutil",
-        "//pkg/tcpip/stack",
-        "@com_github_google_go_cmp//cmp:go_default_library",
-    ],
-)
diff --git a/pkg/tcpip/network/fragmentation/fragmentation.go b/pkg/tcpip/network/fragmentation/fragmentation.go
deleted file mode 100644
index 243738951..000000000
--- a/pkg/tcpip/network/fragmentation/fragmentation.go
+++ /dev/null
@@ -1,339 +0,0 @@
-// Copyright 2018 The gVisor Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package fragmentation contains the implementation of IP fragmentation.
-// It is based on RFC 791, RFC 815 and RFC 8200.
-package fragmentation
-
-import (
-	"errors"
-	"fmt"
-	"log"
-	"time"
-
-	"gvisor.dev/gvisor/pkg/sync"
-	"gvisor.dev/gvisor/pkg/tcpip"
-	"gvisor.dev/gvisor/pkg/tcpip/buffer"
-	"gvisor.dev/gvisor/pkg/tcpip/stack"
-)
-
-const (
-	// HighFragThreshold is the threshold at which we start trimming old
-	// fragmented packets. Linux uses a default value of 4 MB. See
-	// net.ipv4.ipfrag_high_thresh for more information.
-	HighFragThreshold = 4 << 20 // 4MB
-
-	// LowFragThreshold is the threshold we reach to when we start dropping
-	// older fragmented packets. It's important that we keep enough room for newer
-	// packets to be re-assembled. Hence, this needs to be lower than
-	// HighFragThreshold enough. Linux uses a default value of 3 MB. See
-	// net.ipv4.ipfrag_low_thresh for more information.
-	LowFragThreshold = 3 << 20 // 3MB
-
-	// minBlockSize is the minimum block size for fragments.
-	minBlockSize = 1
-)
-
-var (
-	// ErrInvalidArgs indicates to the caller that an invalid argument was
-	// provided.
-	ErrInvalidArgs = errors.New("invalid args")
-
-	// ErrFragmentOverlap indicates that, during reassembly, a fragment overlaps
-	// with another one.
-	ErrFragmentOverlap = errors.New("overlapping fragments")
-
-	// ErrFragmentConflict indicates that, during reassembly, some fragments are
-	// in conflict with one another.
-	ErrFragmentConflict = errors.New("conflicting fragments")
-)
-
-// FragmentID is the identifier for a fragment.
-type FragmentID struct {
-	// Source is the source address of the fragment.
-	Source tcpip.Address
-
-	// Destination is the destination address of the fragment.
-	Destination tcpip.Address
-
-	// ID is the identification value of the fragment.
-	//
-	// This is a uint32 because IPv6 uses a 32-bit identification value.
-	ID uint32
-
-	// The protocol for the packet.
-	Protocol uint8
-}
-
-// Fragmentation is the main structure that other modules
-// of the stack should use to implement IP Fragmentation.
-type Fragmentation struct {
-	mu             sync.Mutex
-	highLimit      int
-	lowLimit       int
-	reassemblers   map[FragmentID]*reassembler
-	rList          reassemblerList
-	memSize        int
-	timeout        time.Duration
-	blockSize      uint16
-	clock          tcpip.Clock
-	releaseJob     *tcpip.Job
-	timeoutHandler TimeoutHandler
-}
-
-// TimeoutHandler is consulted if a packet reassembly has timed out.
-type TimeoutHandler interface {
-	// OnReassemblyTimeout will be called with the first fragment (or nil, if the
-	// first fragment has not been received) of a packet whose reassembly has
-	// timed out.
-	OnReassemblyTimeout(pkt *stack.PacketBuffer)
-}
-
-// NewFragmentation creates a new Fragmentation.
-//
-// blockSize specifies the fragment block size, in bytes.
-//
-// highMemoryLimit specifies the limit on the memory consumed
-// by the fragments stored by Fragmentation (overhead of internal data-structures
-// is not accounted). Fragments are dropped when the limit is reached.
-//
-// lowMemoryLimit specifies the limit on which we will reach by dropping
-// fragments after reaching highMemoryLimit.
-//
-// reassemblingTimeout specifies the maximum time allowed to reassemble a packet.
-// Fragments are lazily evicted only when a new a packet with an
-// already existing fragmentation-id arrives after the timeout.
-func NewFragmentation(blockSize uint16, highMemoryLimit, lowMemoryLimit int, reassemblingTimeout time.Duration, clock tcpip.Clock, timeoutHandler TimeoutHandler) *Fragmentation {
-	if lowMemoryLimit >= highMemoryLimit {
-		lowMemoryLimit = highMemoryLimit
-	}
-
-	if lowMemoryLimit < 0 {
-		lowMemoryLimit = 0
-	}
-
-	if blockSize < minBlockSize {
-		blockSize = minBlockSize
-	}
-
-	f := &Fragmentation{
-		reassemblers:   make(map[FragmentID]*reassembler),
-		highLimit:      highMemoryLimit,
-		lowLimit:       lowMemoryLimit,
-		timeout:        reassemblingTimeout,
-		blockSize:      blockSize,
-		clock:          clock,
-		timeoutHandler: timeoutHandler,
-	}
-	f.releaseJob = tcpip.NewJob(f.clock, &f.mu, f.releaseReassemblersLocked)
-
-	return f
-}
-
-// Process processes an incoming fragment belonging to an ID and returns a
-// complete packet and its protocol number when all the packets belonging to
-// that ID have been received.
-//
-// [first, last] is the range of the fragment bytes.
-//
-// first must be a multiple of the block size f is configured with. The size
-// of the fragment data must be a multiple of the block size, unless there are
-// no fragments following this fragment (more set to false).
-//
-// proto is the protocol number marked in the fragment being processed. It has
-// to be given here outside of the FragmentID struct because IPv6 should not use
-// the protocol to identify a fragment.
-func (f *Fragmentation) Process(
-	id FragmentID, first, last uint16, more bool, proto uint8, pkt *stack.PacketBuffer) (
-	*stack.PacketBuffer, uint8, bool, error) {
-	if first > last {
-		return nil, 0, false, fmt.Errorf("first=%d is greater than last=%d: %w", first, last, ErrInvalidArgs)
-	}
-
-	if first%f.blockSize != 0 {
-		return nil, 0, false, fmt.Errorf("first=%d is not a multiple of block size=%d: %w", first, f.blockSize, ErrInvalidArgs)
-	}
-
-	fragmentSize := last - first + 1
-	if more && fragmentSize%f.blockSize != 0 {
-		return nil, 0, false, fmt.Errorf("fragment size=%d bytes is not a multiple of block size=%d on non-final fragment: %w", fragmentSize, f.blockSize, ErrInvalidArgs)
-	}
-
-	if l := pkt.Data.Size(); l != int(fragmentSize) {
-		return nil, 0, false, fmt.Errorf("got fragment size=%d bytes not equal to the expected fragment size=%d bytes (first=%d last=%d): %w", l, fragmentSize, first, last, ErrInvalidArgs)
-	}
-
-	f.mu.Lock()
-	r, ok := f.reassemblers[id]
-	if !ok {
-		r = newReassembler(id, f.clock)
-		f.reassemblers[id] = r
-		wasEmpty := f.rList.Empty()
-		f.rList.PushFront(r)
-		if wasEmpty {
-			// If we have just pushed a first reassembler into an empty list, we
-			// should kickstart the release job. The release job will keep
-			// rescheduling itself until the list becomes empty.
-			f.releaseReassemblersLocked()
-		}
-	}
-	f.mu.Unlock()
-
-	resPkt, firstFragmentProto, done, memConsumed, err := r.process(first, last, more, proto, pkt)
-	if err != nil {
-		// We probably got an invalid sequence of fragments. Just
-		// discard the reassembler and move on.
-		f.mu.Lock()
-		f.release(r, false /* timedOut */)
-		f.mu.Unlock()
-		return nil, 0, false, fmt.Errorf("fragmentation processing error: %w", err)
-	}
-	f.mu.Lock()
-	f.memSize += memConsumed
-	if done {
-		f.release(r, false /* timedOut */)
-	}
-	// Evict reassemblers if we are consuming more memory than highLimit until
-	// we reach lowLimit.
-	if f.memSize > f.highLimit {
-		for f.memSize > f.lowLimit {
-			tail := f.rList.Back()
-			if tail == nil {
-				break
-			}
-			f.release(tail, false /* timedOut */)
-		}
-	}
-	f.mu.Unlock()
-	return resPkt, firstFragmentProto, done, nil
-}
-
-func (f *Fragmentation) release(r *reassembler, timedOut bool) {
-	// Before releasing a fragment we need to check if r is already marked as done.
-	// Otherwise, we would delete it twice.
-	if r.checkDoneOrMark() {
-		return
-	}
-
-	delete(f.reassemblers, r.id)
-	f.rList.Remove(r)
-	f.memSize -= r.memSize
-	if f.memSize < 0 {
-		log.Printf("memory counter < 0 (%d), this is an accounting bug that requires investigation", f.memSize)
-		f.memSize = 0
-	}
-
-	if h := f.timeoutHandler; timedOut && h != nil {
-		h.OnReassemblyTimeout(r.pkt)
-	}
-}
-
-// releaseReassemblersLocked releases already-expired reassemblers, then
-// schedules the job to call back itself for the remaining reassemblers if
-// any. This function must be called with f.mu locked.
-func (f *Fragmentation) releaseReassemblersLocked() {
-	now := f.clock.NowMonotonic()
-	for {
-		// The reassembler at the end of the list is the oldest.
-		r := f.rList.Back()
-		if r == nil {
-			// The list is empty.
-			break
-		}
-		elapsed := time.Duration(now-r.creationTime) * time.Nanosecond
-		if f.timeout > elapsed {
-			// If the oldest reassembler has not expired, schedule the release
-			// job so that this function is called back when it has expired.
-			f.releaseJob.Schedule(f.timeout - elapsed)
-			break
-		}
-		// If the oldest reassembler has already expired, release it.
-		f.release(r, true /* timedOut*/)
-	}
-}
-
-// PacketFragmenter is the book-keeping struct for packet fragmentation.
-type PacketFragmenter struct {
-	transportHeader    buffer.View
-	data               buffer.VectorisedView
-	reserve            int
-	fragmentPayloadLen int
-	fragmentCount      int
-	currentFragment    int
-	fragmentOffset     int
-}
-
-// MakePacketFragmenter prepares the struct needed for packet fragmentation.
-//
-// pkt is the packet to be fragmented.
-//
-// fragmentPayloadLen is the maximum number of bytes of fragmentable data a fragment can
-// have.
-//
-// reserve is the number of bytes that should be reserved for the headers in
-// each generated fragment.
-func MakePacketFragmenter(pkt *stack.PacketBuffer, fragmentPayloadLen uint32, reserve int) PacketFragmenter {
-	// As per RFC 8200 Section 4.5, some IPv6 extension headers should not be
-	// repeated in each fragment. However we do not currently support any header
-	// of that kind yet, so the following computation is valid for both IPv4 and
-	// IPv6.
-	// TODO(gvisor.dev/issue/3912): Once Authentication or ESP Headers are
-	// supported for outbound packets, the fragmentable data should not include
-	// these headers.
-	var fragmentableData buffer.VectorisedView
-	fragmentableData.AppendView(pkt.TransportHeader().View())
-	fragmentableData.Append(pkt.Data)
-	fragmentCount := (uint32(fragmentableData.Size()) + fragmentPayloadLen - 1) / fragmentPayloadLen
-
-	return PacketFragmenter{
-		data:               fragmentableData,
-		reserve:            reserve,
-		fragmentPayloadLen: int(fragmentPayloadLen),
-		fragmentCount:      int(fragmentCount),
-	}
-}
-
-// BuildNextFragment returns a packet with the payload of the next fragment,
-// along with the fragment's offset, the number of bytes copied and a boolean
-// indicating if there are more fragments left or not. If this function is
-// called again after it indicated that no more fragments were left, it will
-// panic.
-//
-// Note that the returned packet will not have its network and link headers
-// populated, but space for them will be reserved. The transport header will be
-// stored in the packet's data.
-func (pf *PacketFragmenter) BuildNextFragment() (*stack.PacketBuffer, int, int, bool) {
-	if pf.currentFragment >= pf.fragmentCount {
-		panic("BuildNextFragment should not be called again after the last fragment was returned")
-	}
-
-	fragPkt := stack.NewPacketBuffer(stack.PacketBufferOptions{
-		ReserveHeaderBytes: pf.reserve,
-	})
-
-	// Copy data for the fragment.
-	copied := pf.data.ReadToVV(&fragPkt.Data, pf.fragmentPayloadLen)
-
-	offset := pf.fragmentOffset
-	pf.fragmentOffset += copied
-	pf.currentFragment++
-	more := pf.currentFragment != pf.fragmentCount
-
-	return fragPkt, offset, copied, more
-}
-
-// RemainingFragmentCount returns the number of fragments left to be built.
-func (pf *PacketFragmenter) RemainingFragmentCount() int {
-	return pf.fragmentCount - pf.currentFragment
-}
diff --git a/pkg/tcpip/network/fragmentation/fragmentation_test.go b/pkg/tcpip/network/fragmentation/fragmentation_test.go
deleted file mode 100644
index 905bbc19b..000000000
--- a/pkg/tcpip/network/fragmentation/fragmentation_test.go
+++ /dev/null
@@ -1,638 +0,0 @@
-// Copyright 2018 The gVisor Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package fragmentation
-
-import (
-	"errors"
-	"testing"
-	"time"
-
-	"github.com/google/go-cmp/cmp"
-	"gvisor.dev/gvisor/pkg/tcpip/buffer"
-	"gvisor.dev/gvisor/pkg/tcpip/faketime"
-	"gvisor.dev/gvisor/pkg/tcpip/network/testutil"
-	"gvisor.dev/gvisor/pkg/tcpip/stack"
-)
-
-// reassembleTimeout is dummy timeout used for testing, where the clock never
-// advances.
-const reassembleTimeout = 1
-
-// vv is a helper to build VectorisedView from different strings.
-func vv(size int, pieces ...string) buffer.VectorisedView {
-	views := make([]buffer.View, len(pieces))
-	for i, p := range pieces {
-		views[i] = []byte(p)
-	}
-
-	return buffer.NewVectorisedView(size, views)
-}
-
-func pkt(size int, pieces ...string) *stack.PacketBuffer {
-	return stack.NewPacketBuffer(stack.PacketBufferOptions{
-		Data: vv(size, pieces...),
-	})
-}
-
-type processInput struct {
-	id    FragmentID
-	first uint16
-	last  uint16
-	more  bool
-	proto uint8
-	pkt   *stack.PacketBuffer
-}
-
-type processOutput struct {
-	vv    buffer.VectorisedView
-	proto uint8
-	done  bool
-}
-
-var processTestCases = []struct {
-	comment string
-	in      []processInput
-	out     []processOutput
-}{
-	{
-		comment: "One ID",
-		in: []processInput{
-			{id: FragmentID{ID: 0}, first: 0, last: 1, more: true, pkt: pkt(2, "01")},
-			{id: FragmentID{ID: 0}, first: 2, last: 3, more: false, pkt: pkt(2, "23")},
-		},
-		out: []processOutput{
-			{vv: buffer.VectorisedView{}, done: false},
-			{vv: vv(4, "01", "23"), done: true},
-		},
-	},
-	{
-		comment: "Next Header protocol mismatch",
-		in: []processInput{
-			{id: FragmentID{ID: 0}, first: 0, last: 1, more: true, proto: 6, pkt: pkt(2, "01")},
-			{id: FragmentID{ID: 0}, first: 2, last: 3, more: false, proto: 17, pkt: pkt(2, "23")},
-		},
-		out: []processOutput{
-			{vv: buffer.VectorisedView{}, done: false},
-			{vv: vv(4, "01", "23"), proto: 6, done: true},
-		},
-	},
-	{
-		comment: "Two IDs",
-		in: []processInput{
-			{id: FragmentID{ID: 0}, first: 0, last: 1, more: true, pkt: pkt(2, "01")},
-			{id: FragmentID{ID: 1}, first: 0, last: 1, more: true, pkt: pkt(2, "ab")},
-			{id: FragmentID{ID: 1}, first: 2, last: 3, more: false, pkt: pkt(2, "cd")},
-			{id: FragmentID{ID: 0}, first: 2, last: 3, more: false, pkt: pkt(2, "23")},
-		},
-		out: []processOutput{
-			{vv: buffer.VectorisedView{}, done: false},
-			{vv: buffer.VectorisedView{}, done: false},
-			{vv: vv(4, "ab", "cd"), done: true},
-			{vv: vv(4, "01", "23"), done: true},
-		},
-	},
-}
-
-func TestFragmentationProcess(t *testing.T) {
-	for _, c := range processTestCases {
-		t.Run(c.comment, func(t *testing.T) {
-			f := NewFragmentation(minBlockSize, 1024, 512, reassembleTimeout, &faketime.NullClock{}, nil)
-			firstFragmentProto := c.in[0].proto
-			for i, in := range c.in {
-				resPkt, proto, done, err := f.Process(in.id, in.first, in.last, in.more, in.proto, in.pkt)
-				if err != nil {
-					t.Fatalf("f.Process(%+v, %d, %d, %t, %d, %#v) failed: %s",
-						in.id, in.first, in.last, in.more, in.proto, in.pkt, err)
-				}
-				if done != c.out[i].done {
-					t.Errorf("got Process(%+v, %d, %d, %t, %d, _) = (_, _, %t, _), want = (_, _, %t, _)",
-						in.id, in.first, in.last, in.more, in.proto, done, c.out[i].done)
-				}
-				if c.out[i].done {
-					if diff := cmp.Diff(c.out[i].vv.ToOwnedView(), resPkt.Data.ToOwnedView()); diff != "" {
-						t.Errorf("got Process(%+v, %d, %d, %t, %d, %#v) result mismatch (-want, +got):\n%s",
-							in.id, in.first, in.last, in.more, in.proto, in.pkt, diff)
-					}
-					if firstFragmentProto != proto {
-						t.Errorf("got Process(%+v, %d, %d, %t, %d, _) = (_, %d, _, _), want = (_, %d, _, _)",
-							in.id, in.first, in.last, in.more, in.proto, proto, firstFragmentProto)
-					}
-					if _, ok := f.reassemblers[in.id]; ok {
-						t.Errorf("Process(%d) did not remove buffer from reassemblers", i)
-					}
-					for n := f.rList.Front(); n != nil; n = n.Next() {
-						if n.id == in.id {
-							t.Errorf("Process(%d) did not remove buffer from rList", i)
-						}
-					}
-				}
-			}
-		})
-	}
-}
-
-func TestReassemblingTimeout(t *testing.T) {
-	const (
-		reassemblyTimeout = time.Millisecond
-		protocol          = 0xff
-	)
-
-	type fragment struct {
-		first uint16
-		last  uint16
-		more  bool
-		data  string
-	}
-
-	type event struct {
-		// name is a nickname of this event.
-		name string
-
-		// clockAdvance is a duration to advance the clock. The clock advances
-		// before a fragment specified in the fragment field is processed.
-		clockAdvance time.Duration
-
-		// fragment is a fragment to process. This can be nil if there is no
-		// fragment to process.
-		fragment *fragment
-
-		// expectDone is true if the fragmentation instance should report the
-		// reassembly is done after the fragment is processd.
-		expectDone bool
-
-		// memSizeAfterEvent is the expected memory size of the fragmentation
-		// instance after the event.
-		memSizeAfterEvent int
-	}
-
-	memSizeOfFrags := func(frags ...*fragment) int {
-		var size int
-		for _, frag := range frags {
-			size += pkt(len(frag.data), frag.data).MemSize()
-		}
-		return size
-	}
-
-	half1 := &fragment{first: 0, last: 0, more: true, data: "0"}
-	half2 := &fragment{first: 1, last: 1, more: false, data: "1"}
-
-	tests := []struct {
-		name   string
-		events []event
-	}{
-		{
-			name: "half1 and half2 are reassembled successfully",
-			events: []event{
-				{
-					name:              "half1",
-					fragment:          half1,
-					expectDone:        false,
-					memSizeAfterEvent: memSizeOfFrags(half1),
-				},
-				{
-					name:              "half2",
-					fragment:          half2,
-					expectDone:        true,
-					memSizeAfterEvent: 0,
-				},
-			},
-		},
-		{
-			name: "half1 timeout, half2 timeout",
-			events: []event{
-				{
-					name:              "half1",
-					fragment:          half1,
-					expectDone:        false,
-					memSizeAfterEvent: memSizeOfFrags(half1),
-				},
-				{
-					name:              "half1 just before reassembly timeout",
-					clockAdvance:      reassemblyTimeout - 1,
-					memSizeAfterEvent: memSizeOfFrags(half1),
-				},
-				{
-					name:              "half1 reassembly timeout",
-					clockAdvance:      1,
-					memSizeAfterEvent: 0,
-				},
-				{
-					name:              "half2",
-					fragment:          half2,
-					expectDone:        false,
-					memSizeAfterEvent: memSizeOfFrags(half2),
-				},
-				{
-					name:              "half2 just before reassembly timeout",
-					clockAdvance:      reassemblyTimeout - 1,
-					memSizeAfterEvent: memSizeOfFrags(half2),
-				},
-				{
-					name:              "half2 reassembly timeout",
-					clockAdvance:      1,
-					memSizeAfterEvent: 0,
-				},
-			},
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			clock := faketime.NewManualClock()
-			f := NewFragmentation(minBlockSize, HighFragThreshold, LowFragThreshold, reassemblyTimeout, clock, nil)
-			for _, event := range test.events {
-				clock.Advance(event.clockAdvance)
-				if frag := event.fragment; frag != nil {
-					_, _, done, err := f.Process(FragmentID{}, frag.first, frag.last, frag.more, protocol, pkt(len(frag.data), frag.data))
-					if err != nil {
-						t.Fatalf("%s: f.Process failed: %s", event.name, err)
-					}
-					if done != event.expectDone {
-						t.Fatalf("%s: got done = %t, want = %t", event.name, done, event.expectDone)
-					}
-				}
-				if got, want := f.memSize, event.memSizeAfterEvent; got != want {
-					t.Errorf("%s: got f.memSize = %d, want = %d", event.name, got, want)
-				}
-			}
-		})
-	}
-}
-
-func TestMemoryLimits(t *testing.T) {
-	lowLimit := pkt(1, "0").MemSize()
-	highLimit := 3 * lowLimit // Allow at most 3 such packets.
-	f := NewFragmentation(minBlockSize, highLimit, lowLimit, reassembleTimeout, &faketime.NullClock{}, nil)
-	// Send first fragment with id = 0.
-	f.Process(FragmentID{ID: 0}, 0, 0, true, 0xFF, pkt(1, "0"))
-	// Send first fragment with id = 1.
-	f.Process(FragmentID{ID: 1}, 0, 0, true, 0xFF, pkt(1, "1"))
-	// Send first fragment with id = 2.
-	f.Process(FragmentID{ID: 2}, 0, 0, true, 0xFF, pkt(1, "2"))
-
-	// Send first fragment with id = 3. This should caused id = 0 and id = 1 to be
-	// evicted.
-	f.Process(FragmentID{ID: 3}, 0, 0, true, 0xFF, pkt(1, "3"))
-
-	if _, ok := f.reassemblers[FragmentID{ID: 0}]; ok {
-		t.Errorf("Memory limits are not respected: id=0 has not been evicted.")
-	}
-	if _, ok := f.reassemblers[FragmentID{ID: 1}]; ok {
-		t.Errorf("Memory limits are not respected: id=1 has not been evicted.")
-	}
-	if _, ok := f.reassemblers[FragmentID{ID: 3}]; !ok {
-		t.Errorf("Implementation of memory limits is wrong: id=3 is not present.")
-	}
-}
-
-func TestMemoryLimitsIgnoresDuplicates(t *testing.T) {
-	memSize := pkt(1, "0").MemSize()
-	f := NewFragmentation(minBlockSize, memSize, 0, reassembleTimeout, &faketime.NullClock{}, nil)
-	// Send first fragment with id = 0.
-	f.Process(FragmentID{}, 0, 0, true, 0xFF, pkt(1, "0"))
-	// Send the same packet again.
-	f.Process(FragmentID{}, 0, 0, true, 0xFF, pkt(1, "0"))
-
-	if got, want := f.memSize, memSize; got != want {
-		t.Errorf("Wrong size, duplicates are not handled correctly: got=%d, want=%d.", got, want)
-	}
-}
-
-func TestErrors(t *testing.T) {
-	tests := []struct {
-		name      string
-		blockSize uint16
-		first     uint16
-		last      uint16
-		more      bool
-		data      string
-		err       error
-	}{
-		{
-			name:      "exact block size without more",
-			blockSize: 2,
-			first:     2,
-			last:      3,
-			more:      false,
-			data:      "01",
-		},
-		{
-			name:      "exact block size with more",
-			blockSize: 2,
-			first:     2,
-			last:      3,
-			more:      true,
-			data:      "01",
-		},
-		{
-			name:      "exact block size with more and extra data",
-			blockSize: 2,
-			first:     2,
-			last:      3,
-			more:      true,
-			data:      "012",
-			err:       ErrInvalidArgs,
-		},
-		{
-			name:      "exact block size with more and too little data",
-			blockSize: 2,
-			first:     2,
-			last:      3,
-			more:      true,
-			data:      "0",
-			err:       ErrInvalidArgs,
-		},
-		{
-			name:      "not exact block size with more",
-			blockSize: 2,
-			first:     2,
-			last:      2,
-			more:      true,
-			data:      "0",
-			err:       ErrInvalidArgs,
-		},
-		{
-			name:      "not exact block size without more",
-			blockSize: 2,
-			first:     2,
-			last:      2,
-			more:      false,
-			data:      "0",
-		},
-		{
-			name:      "first not a multiple of block size",
-			blockSize: 2,
-			first:     3,
-			last:      4,
-			more:      true,
-			data:      "01",
-			err:       ErrInvalidArgs,
-		},
-		{
-			name:      "first more than last",
-			blockSize: 2,
-			first:     4,
-			last:      3,
-			more:      true,
-			data:      "01",
-			err:       ErrInvalidArgs,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			f := NewFragmentation(test.blockSize, HighFragThreshold, LowFragThreshold, reassembleTimeout, &faketime.NullClock{}, nil)
-			_, _, done, err := f.Process(FragmentID{}, test.first, test.last, test.more, 0, pkt(len(test.data), test.data))
-			if !errors.Is(err, test.err) {
-				t.Errorf("got Process(_, %d, %d, %t, _, %q) = (_, _, _, %v), want = (_, _, _, %v)", test.first, test.last, test.more, test.data, err, test.err)
-			}
-			if done {
-				t.Errorf("got Process(_, %d, %d, %t, _, %q) = (_, _, true, _), want = (_, _, false, _)", test.first, test.last, test.more, test.data)
-			}
-		})
-	}
-}
-
-type fragmentInfo struct {
-	remaining int
-	copied    int
-	offset    int
-	more      bool
-}
-
-func TestPacketFragmenter(t *testing.T) {
-	const (
-		reserve = 60
-		proto   = 0
-	)
-
-	tests := []struct {
-		name               string
-		fragmentPayloadLen uint32
-		transportHeaderLen int
-		payloadSize        int
-		wantFragments      []fragmentInfo
-	}{
-		{
-			name:               "Packet exactly fits in MTU",
-			fragmentPayloadLen: 1280,
-			transportHeaderLen: 0,
-			payloadSize:        1280,
-			wantFragments: []fragmentInfo{
-				{remaining: 0, copied: 1280, offset: 0, more: false},
-			},
-		},
-		{
-			name:               "Packet exactly does not fit in MTU",
-			fragmentPayloadLen: 1000,
-			transportHeaderLen: 0,
-			payloadSize:        1001,
-			wantFragments: []fragmentInfo{
-				{remaining: 1, copied: 1000, offset: 0, more: true},
-				{remaining: 0, copied: 1, offset: 1000, more: false},
-			},
-		},
-		{
-			name:               "Packet has a transport header",
-			fragmentPayloadLen: 560,
-			transportHeaderLen: 40,
-			payloadSize:        560,
-			wantFragments: []fragmentInfo{
-				{remaining: 1, copied: 560, offset: 0, more: true},
-				{remaining: 0, copied: 40, offset: 560, more: false},
-			},
-		},
-		{
-			name:               "Packet has a huge transport header",
-			fragmentPayloadLen: 500,
-			transportHeaderLen: 1300,
-			payloadSize:        500,
-			wantFragments: []fragmentInfo{
-				{remaining: 3, copied: 500, offset: 0, more: true},
-				{remaining: 2, copied: 500, offset: 500, more: true},
-				{remaining: 1, copied: 500, offset: 1000, more: true},
-				{remaining: 0, copied: 300, offset: 1500, more: false},
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			pkt := testutil.MakeRandPkt(test.transportHeaderLen, reserve, []int{test.payloadSize}, proto)
-			var originalPayload buffer.VectorisedView
-			originalPayload.AppendView(pkt.TransportHeader().View())
-			originalPayload.Append(pkt.Data)
-			var reassembledPayload buffer.VectorisedView
-			pf := MakePacketFragmenter(pkt, test.fragmentPayloadLen, reserve)
-			for i := 0; ; i++ {
-				fragPkt, offset, copied, more := pf.BuildNextFragment()
-				wantFragment := test.wantFragments[i]
-				if got := pf.RemainingFragmentCount(); got != wantFragment.remaining {
-					t.Errorf("(fragment #%d) got pf.RemainingFragmentCount() = %d, want = %d", i, got, wantFragment.remaining)
-				}
-				if copied != wantFragment.copied {
-					t.Errorf("(fragment #%d) got copied = %d, want = %d", i, copied, wantFragment.copied)
-				}
-				if offset != wantFragment.offset {
-					t.Errorf("(fragment #%d) got offset = %d, want = %d", i, offset, wantFragment.offset)
-				}
-				if more != wantFragment.more {
-					t.Errorf("(fragment #%d) got more = %t, want = %t", i, more, wantFragment.more)
-				}
-				if got := uint32(fragPkt.Size()); got > test.fragmentPayloadLen {
-					t.Errorf("(fragment #%d) got fragPkt.Size() = %d, want <= %d", i, got, test.fragmentPayloadLen)
-				}
-				if got := fragPkt.AvailableHeaderBytes(); got != reserve {
-					t.Errorf("(fragment #%d) got fragPkt.AvailableHeaderBytes() = %d, want = %d", i, got, reserve)
-				}
-				if got := fragPkt.TransportHeader().View().Size(); got != 0 {
-					t.Errorf("(fragment #%d) got fragPkt.TransportHeader().View().Size() = %d, want = 0", i, got)
-				}
-				reassembledPayload.Append(fragPkt.Data)
-				if !more {
-					if i != len(test.wantFragments)-1 {
-						t.Errorf("got fragment count = %d, want = %d", i, len(test.wantFragments)-1)
-					}
-					break
-				}
-			}
-			if diff := cmp.Diff(reassembledPayload.ToView(), originalPayload.ToView()); diff != "" {
-				t.Errorf("reassembledPayload mismatch (-want +got):\n%s", diff)
-			}
-		})
-	}
-}
-
-type testTimeoutHandler struct {
-	pkt *stack.PacketBuffer
-}
-
-func (h *testTimeoutHandler) OnReassemblyTimeout(pkt *stack.PacketBuffer) {
-	h.pkt = pkt
-}
-
-func TestTimeoutHandler(t *testing.T) {
-	const (
-		proto = 99
-	)
-
-	pk1 := pkt(1, "1")
-	pk2 := pkt(1, "2")
-
-	type processParam struct {
-		first uint16
-		last  uint16
-		more  bool
-		pkt   *stack.PacketBuffer
-	}
-
-	tests := []struct {
-		name      string
-		params    []processParam
-		wantError bool
-		wantPkt   *stack.PacketBuffer
-	}{
-		{
-			name: "onTimeout runs",
-			params: []processParam{
-				{
-					first: 0,
-					last:  0,
-					more:  true,
-					pkt:   pk1,
-				},
-			},
-			wantError: false,
-			wantPkt:   pk1,
-		},
-		{
-			name: "no first fragment",
-			params: []processParam{
-				{
-					first: 1,
-					last:  1,
-					more:  true,
-					pkt:   pk1,
-				},
-			},
-			wantError: false,
-			wantPkt:   nil,
-		},
-		{
-			name: "second pkt is ignored",
-			params: []processParam{
-				{
-					first: 0,
-					last:  0,
-					more:  true,
-					pkt:   pk1,
-				},
-				{
-					first: 0,
-					last:  0,
-					more:  true,
-					pkt:   pk2,
-				},
-			},
-			wantError: false,
-			wantPkt:   pk1,
-		},
-		{
-			name: "invalid args - first is greater than last",
-			params: []processParam{
-				{
-					first: 1,
-					last:  0,
-					more:  true,
-					pkt:   pk1,
-				},
-			},
-			wantError: true,
-			wantPkt:   nil,
-		},
-	}
-
-	id := FragmentID{ID: 0}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			handler := &testTimeoutHandler{pkt: nil}
-
-			f := NewFragmentation(minBlockSize, HighFragThreshold, LowFragThreshold, reassembleTimeout, &faketime.NullClock{}, handler)
-
-			for _, p := range test.params {
-				if _, _, _, err := f.Process(id, p.first, p.last, p.more, proto, p.pkt); err != nil && !test.wantError {
-					t.Errorf("f.Process error = %s", err)
-				}
-			}
-			if !test.wantError {
-				r, ok := f.reassemblers[id]
-				if !ok {
-					t.Fatal("Reassembler not found")
-				}
-				f.release(r, true)
-			}
-			switch {
-			case handler.pkt != nil && test.wantPkt == nil:
-				t.Errorf("got handler.pkt = not nil (pkt.Data = %x), want = nil", handler.pkt.Data.ToView())
-			case handler.pkt == nil && test.wantPkt != nil:
-				t.Errorf("got handler.pkt = nil, want = not nil (pkt.Data = %x)", test.wantPkt.Data.ToView())
-			case handler.pkt != nil && test.wantPkt != nil:
-				if diff := cmp.Diff(test.wantPkt.Data.ToView(), handler.pkt.Data.ToView()); diff != "" {
-					t.Errorf("pkt.Data mismatch (-want, +got):\n%s", diff)
-				}
-			}
-		})
-	}
-}
diff --git a/pkg/tcpip/network/fragmentation/reassembler.go b/pkg/tcpip/network/fragmentation/reassembler.go
deleted file mode 100644
index 933d63d32..000000000
--- a/pkg/tcpip/network/fragmentation/reassembler.go
+++ /dev/null
@@ -1,182 +0,0 @@
-// Copyright 2018 The gVisor Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package fragmentation
-
-import (
-	"math"
-	"sort"
-
-	"gvisor.dev/gvisor/pkg/sync"
-	"gvisor.dev/gvisor/pkg/tcpip"
-	"gvisor.dev/gvisor/pkg/tcpip/stack"
-)
-
-type hole struct {
-	first  uint16
-	last   uint16
-	filled bool
-	final  bool
-	// pkt is the fragment packet if hole is filled. We keep the whole pkt rather
-	// than the fragmented payload to prevent binding to specific buffer types.
-	pkt *stack.PacketBuffer
-}
-
-type reassembler struct {
-	reassemblerEntry
-	id           FragmentID
-	memSize      int
-	proto        uint8
-	mu           sync.Mutex
-	holes        []hole
-	filled       int
-	done         bool
-	creationTime int64
-	pkt          *stack.PacketBuffer
-}
-
-func newReassembler(id FragmentID, clock tcpip.Clock) *reassembler {
-	r := &reassembler{
-		id:           id,
-		creationTime: clock.NowMonotonic(),
-	}
-	r.holes = append(r.holes, hole{
-		first:  0,
-		last:   math.MaxUint16,
-		filled: false,
-		final:  true,
-	})
-	return r
-}
-
-func (r *reassembler) process(first, last uint16, more bool, proto uint8, pkt *stack.PacketBuffer) (*stack.PacketBuffer, uint8, bool, int, error) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	if r.done {
-		// A concurrent goroutine might have already reassembled
-		// the packet and emptied the heap while this goroutine
-		// was waiting on the mutex. We don't have to do anything in this case.
-		return nil, 0, false, 0, nil
-	}
-
-	var holeFound bool
-	var memConsumed int
-	for i := range r.holes {
-		currentHole := &r.holes[i]
-
-		if last < currentHole.first || currentHole.last < first {
-			continue
-		}
-		// For IPv6, overlaps with an existing fragment are explicitly forbidden by
-		// RFC 8200 section 4.5:
-		//   If any of the fragments being reassembled overlap with any other
-		//   fragments being reassembled for the same packet, reassembly of that
-		//   packet must be abandoned and all the fragments that have been received
-		//   for that packet must be discarded, and no ICMP error messages should be
-		//   sent.
-		//
-		// It is not explicitly forbidden for IPv4, but to keep parity with Linux we
-		// disallow it as well:
-		// https://github.com/torvalds/linux/blob/38525c6/net/ipv4/inet_fragment.c#L349
-		if first < currentHole.first || currentHole.last < last {
-			// Incoming fragment only partially fits in the free hole.
-			return nil, 0, false, 0, ErrFragmentOverlap
-		}
-		if !more {
-			if !currentHole.final || currentHole.filled && currentHole.last != last {
-				// We have another final fragment, which does not perfectly overlap.
-				return nil, 0, false, 0, ErrFragmentConflict
-			}
-		}
-
-		holeFound = true
-		if currentHole.filled {
-			// Incoming fragment is a duplicate.
-			continue
-		}
-
-		// We are populating the current hole with the payload and creating a new
-		// hole for any unfilled ranges on either end.
-		if first > currentHole.first {
-			r.holes = append(r.holes, hole{
-				first:  currentHole.first,
-				last:   first - 1,
-				filled: false,
-				final:  false,
-			})
-		}
-		if last < currentHole.last && more {
-			r.holes = append(r.holes, hole{
-				first:  last + 1,
-				last:   currentHole.last,
-				filled: false,
-				final:  currentHole.final,
-			})
-			currentHole.final = false
-		}
-		memConsumed = pkt.MemSize()
-		r.memSize += memConsumed
-		// Update the current hole to precisely match the incoming fragment.
-		r.holes[i] = hole{
-			first:  first,
-			last:   last,
-			filled: true,
-			final:  currentHole.final,
-			pkt:    pkt,
-		}
-		r.filled++
-		// For IPv6, it is possible to have different Protocol values between
-		// fragments of a packet (because, unlike IPv4, the Protocol is not used to
-		// identify a fragment). In this case, only the Protocol of the first
-		// fragment must be used as per RFC 8200 Section 4.5.
-		//
-		// TODO(gvisor.dev/issue/3648): During reassembly of an IPv6 packet, IP
-		// options received in the first fragment should be used - and they should
-		// override options from following fragments.
-		if first == 0 {
-			r.pkt = pkt
-			r.proto = proto
-		}
-
-		break
-	}
-	if !holeFound {
-		// Incoming fragment is beyond end.
-		return nil, 0, false, 0, ErrFragmentConflict
-	}
-
-	// Check if all the holes have been filled and we are ready to reassemble.
-	if r.filled < len(r.holes) {
-		return nil, 0, false, memConsumed, nil
-	}
-
-	sort.Slice(r.holes, func(i, j int) bool {
-		return r.holes[i].first < r.holes[j].first
-	})
-
-	resPkt := r.holes[0].pkt
-	for i := 1; i < len(r.holes); i++ {
-		fragPkt := r.holes[i].pkt
-		fragPkt.Data.ReadToVV(&resPkt.Data, fragPkt.Data.Size())
-	}
-	return resPkt, r.proto, true, memConsumed, nil
-}
-
-func (r *reassembler) checkDoneOrMark() bool {
-	r.mu.Lock()
-	prev := r.done
-	r.done = true
-	r.mu.Unlock()
-	return prev
-}
diff --git a/pkg/tcpip/network/fragmentation/reassembler_test.go b/pkg/tcpip/network/fragmentation/reassembler_test.go
deleted file mode 100644
index 214a93709..000000000
--- a/pkg/tcpip/network/fragmentation/reassembler_test.go
+++ /dev/null
@@ -1,233 +0,0 @@
-// Copyright 2018 The gVisor Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package fragmentation
-
-import (
-	"bytes"
-	"math"
-	"testing"
-
-	"github.com/google/go-cmp/cmp"
-	"gvisor.dev/gvisor/pkg/tcpip/buffer"
-	"gvisor.dev/gvisor/pkg/tcpip/faketime"
-	"gvisor.dev/gvisor/pkg/tcpip/stack"
-)
-
-type processParams struct {
-	first     uint16
-	last      uint16
-	more      bool
-	pkt       *stack.PacketBuffer
-	wantDone  bool
-	wantError error
-}
-
-func TestReassemblerProcess(t *testing.T) {
-	const proto = 99
-
-	v := func(size int) buffer.View {
-		payload := buffer.NewView(size)
-		for i := 1; i < size; i++ {
-			payload[i] = uint8(i) * 3
-		}
-		return payload
-	}
-
-	pkt := func(sizes ...int) *stack.PacketBuffer {
-		var vv buffer.VectorisedView
-		for _, size := range sizes {
-			vv.AppendView(v(size))
-		}
-		return stack.NewPacketBuffer(stack.PacketBufferOptions{
-			Data: vv,
-		})
-	}
-
-	var tests = []struct {
-		name    string
-		params  []processParams
-		want    []hole
-		wantPkt *stack.PacketBuffer
-	}{
-		{
-			name:   "No fragments",
-			params: nil,
-			want:   []hole{{first: 0, last: math.MaxUint16, filled: false, final: true}},
-		},
-		{
-			name:   "One fragment at beginning",
-			params: []processParams{{first: 0, last: 1, more: true, pkt: pkt(2), wantDone: false, wantError: nil}},
-			want: []hole{
-				{first: 0, last: 1, filled: true, final: false, pkt: pkt(2)},
-				{first: 2, last: math.MaxUint16, filled: false, final: true},
-			},
-		},
-		{
-			name:   "One fragment in the middle",
-			params: []processParams{{first: 1, last: 2, more: true, pkt: pkt(2), wantDone: false, wantError: nil}},
-			want: []hole{
-				{first: 1, last: 2, filled: true, final: false, pkt: pkt(2)},
-				{first: 0, last: 0, filled: false, final: false},
-				{first: 3, last: math.MaxUint16, filled: false, final: true},
-			},
-		},
-		{
-			name:   "One fragment at the end",
-			params: []processParams{{first: 1, last: 2, more: false, pkt: pkt(2), wantDone: false, wantError: nil}},
-			want: []hole{
-				{first: 1, last: 2, filled: true, final: true, pkt: pkt(2)},
-				{first: 0, last: 0, filled: false},
-			},
-		},
-		{
-			name:   "One fragment completing a packet",
-			params: []processParams{{first: 0, last: 1, more: false, pkt: pkt(2), wantDone: true, wantError: nil}},
-			want: []hole{
-				{first: 0, last: 1, filled: true, final: true},
-			},
-			wantPkt: pkt(2),
-		},
-		{
-			name: "Two fragments completing a packet",
-			params: []processParams{
-				{first: 0, last: 1, more: true, pkt: pkt(2), wantDone: false, wantError: nil},
-				{first: 2, last: 3, more: false, pkt: pkt(2), wantDone: true, wantError: nil},
-			},
-			want: []hole{
-				{first: 0, last: 1, filled: true, final: false},
-				{first: 2, last: 3, filled: true, final: true},
-			},
-			wantPkt: pkt(2, 2),
-		},
-		{
-			name: "Two fragments completing a packet with a duplicate",
-			params: []processParams{
-				{first: 0, last: 1, more: true, pkt: pkt(2), wantDone: false, wantError: nil},
-				{first: 0, last: 1, more: true, pkt: pkt(2), wantDone: false, wantError: nil},
-				{first: 2, last: 3, more: false, pkt: pkt(2), wantDone: true, wantError: nil},
-			},
-			want: []hole{
-				{first: 0, last: 1, filled: true, final: false},
-				{first: 2, last: 3, filled: true, final: true},
-			},
-			wantPkt: pkt(2, 2),
-		},
-		{
-			name: "Two fragments completing a packet with a partial duplicate",
-			params: []processParams{
-				{first: 0, last: 3, more: true, pkt: pkt(4), wantDone: false, wantError: nil},
-				{first: 1, last: 2, more: true, pkt: pkt(2), wantDone: false, wantError: nil},
-				{first: 4, last: 5, more: false, pkt: pkt(2), wantDone: true, wantError: nil},
-			},
-			want: []hole{
-				{first: 0, last: 3, filled: true, final: false},
-				{first: 4, last: 5, filled: true, final: true},
-			},
-			wantPkt: pkt(4, 2),
-		},
-		{
-			name: "Two overlapping fragments",
-			params: []processParams{
-				{first: 0, last: 10, more: true, pkt: pkt(11), wantDone: false, wantError: nil},
-				{first: 5, last: 15, more: false, pkt: pkt(11), wantDone: false, wantError: ErrFragmentOverlap},
-			},
-			want: []hole{
-				{first: 0, last: 10, filled: true, final: false, pkt: pkt(11)},
-				{first: 11, last: math.MaxUint16, filled: false, final: true},
-			},
-		},
-		{
-			name: "Two final fragments with different ends",
-			params: []processParams{
-				{first: 10, last: 14, more: false, pkt: pkt(5), wantDone: false, wantError: nil},
-				{first: 0, last: 9, more: false, pkt: pkt(10), wantDone: false, wantError: ErrFragmentConflict},
-			},
-			want: []hole{
-				{first: 10, last: 14, filled: true, final: true, pkt: pkt(5)},
-				{first: 0, last: 9, filled: false, final: false},
-			},
-		},
-		{
-			name: "Two final fragments - duplicate",
-			params: []processParams{
-				{first: 5, last: 14, more: false, pkt: pkt(10), wantDone: false, wantError: nil},
-				{first: 10, last: 14, more: false, pkt: pkt(5), wantDone: false, wantError: nil},
-			},
-			want: []hole{
-				{first: 5, last: 14, filled: true, final: true, pkt: pkt(10)},
-				{first: 0, last: 4, filled: false, final: false},
-			},
-		},
-		{
-			name: "Two final fragments - duplicate, with different ends",
-			params: []processParams{
-				{first: 5, last: 14, more: false, pkt: pkt(10), wantDone: false, wantError: nil},
-				{first: 10, last: 13, more: false, pkt: pkt(4), wantDone: false, wantError: ErrFragmentConflict},
-			},
-			want: []hole{
-				{first: 5, last: 14, filled: true, final: true, pkt: pkt(10)},
-				{first: 0, last: 4, filled: false, final: false},
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			r := newReassembler(FragmentID{}, &faketime.NullClock{})
-			var resPkt *stack.PacketBuffer
-			var isDone bool
-			for _, param := range test.params {
-				pkt, _, done, _, err := r.process(param.first, param.last, param.more, proto, param.pkt)
-				if done != param.wantDone || err != param.wantError {
-					t.Errorf("got r.process(%d, %d, %t, %d, _) = (_, _, %t, _, %v), want = (%t, %v)", param.first, param.last, param.more, proto, done, err, param.wantDone, param.wantError)
-				}
-				if done {
-					resPkt = pkt
-					isDone = true
-				}
-			}
-
-			ignorePkt := func(a, b *stack.PacketBuffer) bool { return true }
-			cmpPktData := func(a, b *stack.PacketBuffer) bool {
-				if a == nil || b == nil {
-					return a == b
-				}
-				return bytes.Equal(a.Data.ToOwnedView(), b.Data.ToOwnedView())
-			}
-
-			if isDone {
-				if diff := cmp.Diff(
-					test.want, r.holes,
-					cmp.AllowUnexported(hole{}),
-					// Do not compare pkt in hole. Data will be altered.
-					cmp.Comparer(ignorePkt),
-				); diff != "" {
-					t.Errorf("r.holes mismatch (-want +got):\n%s", diff)
-				}
-				if diff := cmp.Diff(test.wantPkt, resPkt, cmp.Comparer(cmpPktData)); diff != "" {
-					t.Errorf("Reassembled pkt mismatch (-want +got):\n%s", diff)
-				}
-			} else {
-				if diff := cmp.Diff(
-					test.want, r.holes,
-					cmp.AllowUnexported(hole{}),
-					cmp.Comparer(cmpPktData),
-				); diff != "" {
-					t.Errorf("r.holes mismatch (-want +got):\n%s", diff)
-				}
-			}
-		})
-	}
-}