1 // SPDX-License-Identifier: GPL-2.0
2
3 #define _GNU_SOURCE
4
5 #include <arpa/inet.h>
6 #include <error.h>
7 #include <errno.h>
8 #include <limits.h>
9 #include <linux/errqueue.h>
10 #include <linux/if_packet.h>
11 #include <linux/socket.h>
12 #include <linux/sockios.h>
13 #include <net/ethernet.h>
14 #include <net/if.h>
15 #include <netinet/ip.h>
16 #include <netinet/ip6.h>
17 #include <netinet/tcp.h>
18 #include <netinet/udp.h>
19 #include <poll.h>
20 #include <sched.h>
21 #include <stdbool.h>
22 #include <stdio.h>
23 #include <stdint.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <sys/ioctl.h>
27 #include <sys/socket.h>
28 #include <sys/stat.h>
29 #include <sys/time.h>
30 #include <sys/types.h>
31 #include <sys/wait.h>
32 #include <unistd.h>
33
34 static int cfg_port = 8000;
35 static bool cfg_tcp;
36 static bool cfg_verify;
37
38 static bool interrupted;
39 static unsigned long packets, bytes;
40
sigint_handler(int signum)41 static void sigint_handler(int signum)
42 {
43 if (signum == SIGINT)
44 interrupted = true;
45 }
46
gettimeofday_ms(void)47 static unsigned long gettimeofday_ms(void)
48 {
49 struct timeval tv;
50
51 gettimeofday(&tv, NULL);
52 return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
53 }
54
do_poll(int fd)55 static void do_poll(int fd)
56 {
57 struct pollfd pfd;
58 int ret;
59
60 pfd.events = POLLIN;
61 pfd.revents = 0;
62 pfd.fd = fd;
63
64 do {
65 ret = poll(&pfd, 1, 10);
66 if (ret == -1)
67 error(1, errno, "poll");
68 if (ret == 0)
69 continue;
70 if (pfd.revents != POLLIN)
71 error(1, errno, "poll: 0x%x expected 0x%x\n",
72 pfd.revents, POLLIN);
73 } while (!ret && !interrupted);
74 }
75
do_socket(bool do_tcp)76 static int do_socket(bool do_tcp)
77 {
78 struct sockaddr_in6 addr = {0};
79 int fd, val;
80
81 fd = socket(PF_INET6, cfg_tcp ? SOCK_STREAM : SOCK_DGRAM, 0);
82 if (fd == -1)
83 error(1, errno, "socket");
84
85 val = 1 << 21;
86 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &val, sizeof(val)))
87 error(1, errno, "setsockopt rcvbuf");
88 val = 1;
89 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &val, sizeof(val)))
90 error(1, errno, "setsockopt reuseport");
91
92 addr.sin6_family = PF_INET6;
93 addr.sin6_port = htons(cfg_port);
94 addr.sin6_addr = in6addr_any;
95 if (bind(fd, (void *) &addr, sizeof(addr)))
96 error(1, errno, "bind");
97
98 if (do_tcp) {
99 int accept_fd = fd;
100
101 if (listen(accept_fd, 1))
102 error(1, errno, "listen");
103
104 do_poll(accept_fd);
105
106 fd = accept(accept_fd, NULL, NULL);
107 if (fd == -1)
108 error(1, errno, "accept");
109 if (close(accept_fd))
110 error(1, errno, "close accept fd");
111 }
112
113 return fd;
114 }
115
116 /* Flush all outstanding bytes for the tcp receive queue */
do_flush_tcp(int fd)117 static void do_flush_tcp(int fd)
118 {
119 int ret;
120
121 while (true) {
122 /* MSG_TRUNC flushes up to len bytes */
123 ret = recv(fd, NULL, 1 << 21, MSG_TRUNC | MSG_DONTWAIT);
124 if (ret == -1 && errno == EAGAIN)
125 return;
126 if (ret == -1)
127 error(1, errno, "flush");
128 if (ret == 0) {
129 /* client detached */
130 exit(0);
131 }
132
133 packets++;
134 bytes += ret;
135 }
136
137 }
138
sanitized_char(char val)139 static char sanitized_char(char val)
140 {
141 return (val >= 'a' && val <= 'z') ? val : '.';
142 }
143
do_verify_udp(const char * data,int len)144 static void do_verify_udp(const char *data, int len)
145 {
146 char cur = data[0];
147 int i;
148
149 /* verify contents */
150 if (cur < 'a' || cur > 'z')
151 error(1, 0, "data initial byte out of range");
152
153 for (i = 1; i < len; i++) {
154 if (cur == 'z')
155 cur = 'a';
156 else
157 cur++;
158
159 if (data[i] != cur)
160 error(1, 0, "data[%d]: len %d, %c(%hhu) != %c(%hhu)\n",
161 i, len,
162 sanitized_char(data[i]), data[i],
163 sanitized_char(cur), cur);
164 }
165 }
166
167 /* Flush all outstanding datagrams. Verify first few bytes of each. */
do_flush_udp(int fd)168 static void do_flush_udp(int fd)
169 {
170 static char rbuf[ETH_DATA_LEN];
171 int ret, len, budget = 256;
172
173 len = cfg_verify ? sizeof(rbuf) : 0;
174 while (budget--) {
175 /* MSG_TRUNC will make return value full datagram length */
176 ret = recv(fd, rbuf, len, MSG_TRUNC | MSG_DONTWAIT);
177 if (ret == -1 && errno == EAGAIN)
178 return;
179 if (ret == -1)
180 error(1, errno, "recv");
181 if (len) {
182 if (ret == 0)
183 error(1, errno, "recv: 0 byte datagram\n");
184
185 do_verify_udp(rbuf, ret);
186 }
187
188 packets++;
189 bytes += ret;
190 }
191 }
192
usage(const char * filepath)193 static void usage(const char *filepath)
194 {
195 error(1, 0, "Usage: %s [-tv] [-p port]", filepath);
196 }
197
parse_opts(int argc,char ** argv)198 static void parse_opts(int argc, char **argv)
199 {
200 int c;
201
202 while ((c = getopt(argc, argv, "ptv")) != -1) {
203 switch (c) {
204 case 'p':
205 cfg_port = htons(strtoul(optarg, NULL, 0));
206 break;
207 case 't':
208 cfg_tcp = true;
209 break;
210 case 'v':
211 cfg_verify = true;
212 break;
213 }
214 }
215
216 if (optind != argc)
217 usage(argv[0]);
218
219 if (cfg_tcp && cfg_verify)
220 error(1, 0, "TODO: implement verify mode for tcp");
221 }
222
do_recv(void)223 static void do_recv(void)
224 {
225 unsigned long tnow, treport;
226 int fd;
227
228 fd = do_socket(cfg_tcp);
229
230 treport = gettimeofday_ms() + 1000;
231 do {
232 do_poll(fd);
233
234 if (cfg_tcp)
235 do_flush_tcp(fd);
236 else
237 do_flush_udp(fd);
238
239 tnow = gettimeofday_ms();
240 if (tnow > treport) {
241 if (packets)
242 fprintf(stderr,
243 "%s rx: %6lu MB/s %8lu calls/s\n",
244 cfg_tcp ? "tcp" : "udp",
245 bytes >> 20, packets);
246 bytes = packets = 0;
247 treport = tnow + 1000;
248 }
249
250 } while (!interrupted);
251
252 if (close(fd))
253 error(1, errno, "close");
254 }
255
main(int argc,char ** argv)256 int main(int argc, char **argv)
257 {
258 parse_opts(argc, argv);
259
260 signal(SIGINT, sigint_handler);
261
262 do_recv();
263
264 return 0;
265 }
266
