dtls/receive_buffer_size_test.go at main · pion/dtls · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
// SPDX-FileCopyrightText: 2026 The Pion community <https://pion.ly>
// SPDX-License-Identifier: MIT

package dtls

import (
	"net"
	"testing"
	"time"

	dtlserrors "github.com/pion/dtls/v3/internal/errors"
	dtlsnet "github.com/pion/dtls/v3/internal/net"
	"github.com/pion/dtls/v3/pkg/crypto/selfsign"
	"github.com/pion/transport/v5/test"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// Datagrams larger than the default receive buffer size were silently
// truncated by both the listener demux loop and the connection read loop,
// surfacing as read timeouts or EOF instead of data.
// https://github.com/pion/dtls/issues/642
func TestReceiveBufferSizeLargeDatagram(t *testing.T) {
	lim := test.TimeOut(30 * time.Second)
	defer lim.Stop()

	report := test.CheckRoutines(t)
	defer report()

	// Larger than the 8192-byte default receive buffer, small enough that the
	// resulting datagram fits well under platform datagram limits (macOS caps
	// UDP datagrams at net.inet.udp.maxdgram, 9216 bytes by default).
	const payloadSize = 8500
	const bufferSize = 16384

	serverCert, err := selfsign.GenerateSelfSigned()
	require.NoError(t, err)

	packetConn, err := net.ListenUDP("udp",
		&net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0},
	)
	require.NoError(t, err)

	listener, err := Listen(
		packetConn,
		WithCertificates(serverCert),
		WithReceiveBufferSize(bufferSize),
	)
	require.NoError(t, err)
	defer func() {
		assert.NoError(t, listener.Close())
	}()

	payload := make([]byte, payloadSize)
	for i := range payload {
		payload[i] = byte(i)
	}

	type readResult struct {
		data []byte
		err  error
	}
	serverRead := make(chan readResult, 1)

	go func() {
		conn, acceptErr := listener.Accept()
		if acceptErr != nil {
			serverRead <- readResult{err: acceptErr}

			return
		}

		_ = conn.SetReadDeadline(time.Now().Add(10 * time.Second))
		buf := make([]byte, bufferSize)
		n, readErr := conn.Read(buf)
		serverRead <- readResult{data: buf[:n], err: readErr}

		assert.NoError(t, conn.Close())
	}()

	serverAddr, ok := listener.Addr().(*net.UDPAddr)
	require.True(t, ok)

	client, err := Dial("udp", serverAddr,
		WithInsecureSkipVerify(true),
		WithReceiveBufferSize(bufferSize),
	)
	require.NoError(t, err)
	defer func() {
		assert.NoError(t, client.Close())
	}()

	n, err := client.Write(payload)
	require.NoError(t, err)
	require.Equal(t, payloadSize, n)

	res := <-serverRead
	require.NoError(t, res.err)
	assert.Equal(t, payload, res.data)
}

func TestWithReceiveBufferSizeValidation(t *testing.T) {
	for _, size := range []int{-1, 0, dtlsnet.MaxInboundDatagramSize + 1, 1 << 20} {
		_, err := buildConfig(WithReceiveBufferSize(size))
		assert.ErrorIs(t, err, dtlserrors.ErrInvalidReceiveBufferSize)
	}

	for _, size := range []int{minReceiveBufferSize, 16384, dtlsnet.MaxInboundDatagramSize} {
		config, err := buildConfig(WithReceiveBufferSize(size))
		assert.NoError(t, err)
		assert.Equal(t, size, config.ReceiveBufferSize)
	}
}