inspektor-gadget

1
// Copyright 2022-2023 The Inspektor Gadget authors
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//     http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
//go:build linux
16
// +build linux
17

18
package tracer
19

20
import (
21
	"fmt"
22
	"net"
23
	"testing"
24

25
	utilstest "github.com/inspektor-gadget/inspektor-gadget/internal/test"
26
	"github.com/inspektor-gadget/inspektor-gadget/pkg/gadgets/snapshot/socket/types"
27
	eventtypes "github.com/inspektor-gadget/inspektor-gadget/pkg/types"
28
	"github.com/stretchr/testify/require"
29
)
30

31
func TestSocketTracerCreate(t *testing.T) {
32
	t.Parallel()
33

34
	utilstest.RequireRoot(t)
35

36
	tracer, err := NewTracer(types.ALL)
37
	require.Nil(t, err, "creating tracer: %v", err)
38

39
	tracer.CloseIters()
40
}
41

42
type testCase struct {
43
	name          string
44
	proto         types.Proto
45
	addr          string
46
	port          int
47
	expectedEvent func(info *utilstest.RunnerInfo, _ any) *types.Event
48
	socketCreator func(addr string, port int) error
49
}
50

51
func TestSnapshotSocket(t *testing.T) {
52
	t.Parallel()
53

54
	utilstest.RequireRoot(t)
55

56
	cases := []testCase{
57
		{
58
			name:  "listen_tcp_v4",
59
			proto: types.TCP,
60
			addr:  "127.0.0.1",
61
			port:  8082,
62
			expectedEvent: func(info *utilstest.RunnerInfo, _ any) *types.Event {
63
				return &types.Event{
64
					Event:       eventtypes.Event{Type: eventtypes.NORMAL},
65
					WithNetNsID: eventtypes.WithNetNsID{NetNsID: info.NetworkNsID},
66
					Protocol:    "TCP",
67
					Status:      "LISTEN",
68
					SrcEndpoint: eventtypes.L4Endpoint{
69
						L3Endpoint: eventtypes.L3Endpoint{
70
							Addr:    "127.0.0.1",
71
							Version: 4,
72
						},
73
						Port: 8082,
74
					},
75
					DstEndpoint: eventtypes.L4Endpoint{
76
						L3Endpoint: eventtypes.L3Endpoint{
77
							// There is no connection in this test, so there remote address is null.
78
							Addr:    "0.0.0.0",
79
							Version: 4,
80
						},
81
					},
82
				}
83
			},
84
			socketCreator: func(addr string, port int) error {
85
				conn, err := net.Listen("tcp", fmt.Sprintf("%s:%d", addr, port))
86
				if err != nil {
87
					return fmt.Errorf("listening to %s: %w", addr, err)
88
				}
89
				t.Cleanup(func() { conn.Close() })
90

91
				return nil
92
			},
93
		},
94
		{
95
			name:  "listen_tcp_v6",
96
			proto: types.TCP,
97
			addr:  "::1",
98
			port:  8082,
99
			expectedEvent: func(info *utilstest.RunnerInfo, _ any) *types.Event {
100
				return &types.Event{
101
					Event:       eventtypes.Event{Type: eventtypes.NORMAL},
102
					WithNetNsID: eventtypes.WithNetNsID{NetNsID: info.NetworkNsID},
103
					Protocol:    "TCP",
104
					Status:      "LISTEN",
105
					SrcEndpoint: eventtypes.L4Endpoint{
106
						L3Endpoint: eventtypes.L3Endpoint{
107
							Addr:    "::1",
108
							Version: 6,
109
						},
110
						Port: 8082,
111
					},
112
					DstEndpoint: eventtypes.L4Endpoint{
113
						L3Endpoint: eventtypes.L3Endpoint{
114
							// There is no connection in this test, so the remote address is null.
115
							Addr:    "::",
116
							Version: 6,
117
						},
118
					},
119
				}
120
			},
121
			socketCreator: func(addr string, port int) error {
122
				conn, err := net.Listen("tcp", fmt.Sprintf("[%s]:%d", addr, port))
123
				if err != nil {
124
					return fmt.Errorf("listening to %s: %w", addr, err)
125
				}
126
				t.Cleanup(func() { conn.Close() })
127

128
				return nil
129
			},
130
		},
131
		{
132
			name:  "listen_udp_v4",
133
			proto: types.UDP,
134
			addr:  "127.0.0.1",
135
			port:  8082,
136
			expectedEvent: func(info *utilstest.RunnerInfo, _ any) *types.Event {
137
				return &types.Event{
138
					Event:       eventtypes.Event{Type: eventtypes.NORMAL},
139
					WithNetNsID: eventtypes.WithNetNsID{NetNsID: info.NetworkNsID},
140
					Protocol:    "UDP",
141
					Status:      "INACTIVE",
142
					SrcEndpoint: eventtypes.L4Endpoint{
143
						L3Endpoint: eventtypes.L3Endpoint{
144
							Addr:    "127.0.0.1",
145
							Version: 4,
146
						},
147
						Port: 8082,
148
					},
149
					DstEndpoint: eventtypes.L4Endpoint{
150
						L3Endpoint: eventtypes.L3Endpoint{
151
							// There is no connection in this test, so there remote address is null.
152
							Addr:    "0.0.0.0",
153
							Version: 4,
154
						},
155
					},
156
				}
157
			},
158
			socketCreator: func(addr string, port int) error {
159
				conn, err := net.ListenUDP("udp", &net.UDPAddr{
160
					Port: port,
161
					IP:   net.ParseIP(addr),
162
				})
163
				if err != nil {
164
					return fmt.Errorf("listening to %s: %w", addr, err)
165
				}
166
				t.Cleanup(func() { conn.Close() })
167

168
				return nil
169
			},
170
		},
171
		{
172
			name:  "listen_udp_v6",
173
			proto: types.UDP,
174
			addr:  "::1",
175
			port:  8082,
176
			expectedEvent: func(info *utilstest.RunnerInfo, _ any) *types.Event {
177
				return &types.Event{
178
					Event:       eventtypes.Event{Type: eventtypes.NORMAL},
179
					WithNetNsID: eventtypes.WithNetNsID{NetNsID: info.NetworkNsID},
180
					Protocol:    "UDP",
181
					Status:      "INACTIVE",
182
					SrcEndpoint: eventtypes.L4Endpoint{
183
						L3Endpoint: eventtypes.L3Endpoint{
184
							Addr:    "::1",
185
							Version: 6,
186
						},
187
						Port: 8082,
188
					},
189
					DstEndpoint: eventtypes.L4Endpoint{
190
						L3Endpoint: eventtypes.L3Endpoint{
191
							// There is no connection in this test, so there remote address is null.
192
							Addr:    "::",
193
							Version: 6,
194
						},
195
					},
196
				}
197
			},
198
			socketCreator: func(addr string, port int) error {
199
				conn, err := net.ListenUDP("udp6", &net.UDPAddr{
200
					Port: port,
201
					IP:   net.ParseIP(addr),
202
				})
203
				if err != nil {
204
					return fmt.Errorf("listening to %s: %w", addr, err)
205
				}
206
				t.Cleanup(func() { conn.Close() })
207

208
				return nil
209
			},
210
		},
211
	}
212

213
	for _, c := range cases {
214
		c := c
215
		t.Run(c.name, func(t *testing.T) {
216
			t.Parallel()
217

218
			runner := utilstest.NewRunnerWithTest(t, nil)
219
			utilstest.RunWithRunner(t, runner, func() error {
220
				return c.socketCreator(c.addr, c.port)
221
			})
222

223
			tracer, err := NewTracer(c.proto)
224
			require.NoError(t, err, "creating tracer: %v", err)
225
			defer tracer.CloseIters()
226

227
			evs, err := tracer.runCollector(uint32(runner.Info.Tid), runner.Info.NetworkNsID)
228
			require.NoError(t, err, "running collector: %v", err)
229

230
			events := make([]types.Event, len(evs))
231
			for i, ev := range evs {
232
				events[i] = *ev
233

234
				// This is hard to guess the inode number, let's normalize it for the
235
				// moment.
236
				events[i].InodeNumber = 0
237
			}
238

239
			utilstest.ExpectAtLeastOneEvent(c.expectedEvent)(t, runner.Info, nil, events)
240
		})
241
	}
242
}
243