1 // SPDX-License-Identifier: GPL-2.0
2
3 /* Open a tun device.
4 *
5 * [modifications: use IFF_NAPI_FRAGS, add sk filter]
6 *
7 * Expects the device to have been configured previously, e.g.:
8 * sudo ip tuntap add name tap1 mode tap
9 * sudo ip link set tap1 up
10 * sudo ip link set dev tap1 addr 02:00:00:00:00:01
11 * sudo ip -6 addr add fdab::1 peer fdab::2 dev tap1 nodad
12 *
13 * And to avoid premature pskb_may_pull:
14 *
15 * sudo ethtool -K tap1 gro off
16 * sudo bash -c 'echo 0 > /proc/sys/net/ipv4/ip_early_demux'
17 */
18
19 #define _GNU_SOURCE
20
21 #include <arpa/inet.h>
22 #include <errno.h>
23 #include <error.h>
24 #include <fcntl.h>
25 #include <getopt.h>
26 #include <linux/filter.h>
27 #include <linux/if.h>
28 #include <linux/if_packet.h>
29 #include <linux/if_tun.h>
30 #include <linux/ipv6.h>
31 #include <netinet/if_ether.h>
32 #include <netinet/in.h>
33 #include <netinet/ip.h>
34 #include <netinet/ip6.h>
35 #include <netinet/udp.h>
36 #include <poll.h>
37 #include <signal.h>
38 #include <stdbool.h>
39 #include <stddef.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <sys/ioctl.h>
44 #include <sys/socket.h>
45 #include <sys/poll.h>
46 #include <sys/types.h>
47 #include <sys/uio.h>
48 #include <unistd.h>
49
50 static bool cfg_do_filter;
51 static bool cfg_do_frags;
52 static int cfg_dst_port = 8000;
53 static char *cfg_ifname;
54
tun_open(const char * tun_name)55 static int tun_open(const char *tun_name)
56 {
57 struct ifreq ifr = {0};
58 int fd, ret;
59
60 fd = open("/dev/net/tun", O_RDWR);
61 if (fd == -1)
62 error(1, errno, "open /dev/net/tun");
63
64 ifr.ifr_flags = IFF_TAP;
65 if (cfg_do_frags)
66 ifr.ifr_flags |= IFF_NAPI | IFF_NAPI_FRAGS;
67
68 strncpy(ifr.ifr_name, tun_name, IFNAMSIZ - 1);
69
70 ret = ioctl(fd, TUNSETIFF, &ifr);
71 if (ret)
72 error(1, ret, "ioctl TUNSETIFF");
73
74 return fd;
75 }
76
sk_set_filter(int fd)77 static void sk_set_filter(int fd)
78 {
79 const int offset_proto = offsetof(struct ip6_hdr, ip6_nxt);
80 const int offset_dport = sizeof(struct ip6_hdr) + offsetof(struct udphdr, dest);
81
82 /* Filter UDP packets with destination port cfg_dst_port */
83 struct sock_filter filter_code[] = {
84 BPF_STMT(BPF_LD + BPF_B + BPF_ABS, SKF_AD_OFF + SKF_AD_PKTTYPE),
85 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, PACKET_HOST, 0, 4),
86 BPF_STMT(BPF_LD + BPF_B + BPF_ABS, SKF_NET_OFF + offset_proto),
87 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_UDP, 0, 2),
88 BPF_STMT(BPF_LD + BPF_H + BPF_ABS, SKF_NET_OFF + offset_dport),
89 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, cfg_dst_port, 1, 0),
90 BPF_STMT(BPF_RET + BPF_K, 0),
91 BPF_STMT(BPF_RET + BPF_K, 0xFFFF),
92 };
93
94 struct sock_fprog filter = {
95 sizeof(filter_code) / sizeof(filter_code[0]),
96 filter_code,
97 };
98
99 if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter)))
100 error(1, errno, "setsockopt attach filter");
101 }
102
raw_open(void)103 static int raw_open(void)
104 {
105 int fd;
106
107 fd = socket(PF_INET6, SOCK_RAW, IPPROTO_UDP);
108 if (fd == -1)
109 error(1, errno, "socket raw (udp)");
110
111 if (cfg_do_filter)
112 sk_set_filter(fd);
113
114 return fd;
115 }
116
tun_write(int fd)117 static void tun_write(int fd)
118 {
119 const char eth_src[] = { 0x02, 0x00, 0x00, 0x00, 0x00, 0x02 };
120 const char eth_dst[] = { 0x02, 0x00, 0x00, 0x00, 0x00, 0x01 };
121 struct tun_pi pi = {0};
122 struct ipv6hdr ip6h = {0};
123 struct udphdr uh = {0};
124 struct ethhdr eth = {0};
125 uint32_t payload;
126 struct iovec iov[5];
127 int ret;
128
129 pi.proto = htons(ETH_P_IPV6);
130
131 memcpy(eth.h_source, eth_src, sizeof(eth_src));
132 memcpy(eth.h_dest, eth_dst, sizeof(eth_dst));
133 eth.h_proto = htons(ETH_P_IPV6);
134
135 ip6h.version = 6;
136 ip6h.payload_len = htons(sizeof(uh) + sizeof(uint32_t));
137 ip6h.nexthdr = IPPROTO_UDP;
138 ip6h.hop_limit = 8;
139 if (inet_pton(AF_INET6, "fdab::2", &ip6h.saddr) != 1)
140 error(1, errno, "inet_pton src");
141 if (inet_pton(AF_INET6, "fdab::1", &ip6h.daddr) != 1)
142 error(1, errno, "inet_pton src");
143
144 uh.source = htons(8000);
145 uh.dest = htons(cfg_dst_port);
146 uh.len = ip6h.payload_len;
147 uh.check = 0;
148
149 payload = htonl(0xABABABAB); /* Covered in IPv6 length */
150
151 iov[0].iov_base = π
152 iov[0].iov_len = sizeof(pi);
153 iov[1].iov_base = ð
154 iov[1].iov_len = sizeof(eth);
155 iov[2].iov_base = &ip6h;
156 iov[2].iov_len = sizeof(ip6h);
157 iov[3].iov_base = &uh;
158 iov[3].iov_len = sizeof(uh);
159 iov[4].iov_base = &payload;
160 iov[4].iov_len = sizeof(payload);
161
162 ret = writev(fd, iov, sizeof(iov) / sizeof(iov[0]));
163 if (ret <= 0)
164 error(1, errno, "writev");
165 }
166
raw_read(int fd)167 static void raw_read(int fd)
168 {
169 struct timeval tv = { .tv_usec = 100 * 1000 };
170 struct msghdr msg = {0};
171 struct iovec iov[2];
172 struct udphdr uh;
173 uint32_t payload[2];
174 int ret;
175
176 if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)))
177 error(1, errno, "setsockopt rcvtimeo udp");
178
179 iov[0].iov_base = &uh;
180 iov[0].iov_len = sizeof(uh);
181
182 iov[1].iov_base = payload;
183 iov[1].iov_len = sizeof(payload);
184
185 msg.msg_iov = iov;
186 msg.msg_iovlen = sizeof(iov) / sizeof(iov[0]);
187
188 ret = recvmsg(fd, &msg, 0);
189 if (ret <= 0)
190 error(1, errno, "read raw");
191 if (ret != sizeof(uh) + sizeof(payload[0]))
192 error(1, errno, "read raw: len=%d\n", ret);
193
194 fprintf(stderr, "raw recv: 0x%x\n", payload[0]);
195 }
196
parse_opts(int argc,char ** argv)197 static void parse_opts(int argc, char **argv)
198 {
199 int c;
200
201 while ((c = getopt(argc, argv, "fFi:")) != -1) {
202 switch (c) {
203 case 'f':
204 cfg_do_filter = true;
205 printf("bpf filter enabled\n");
206 break;
207 case 'F':
208 cfg_do_frags = true;
209 printf("napi frags mode enabled\n");
210 break;
211 case 'i':
212 cfg_ifname = optarg;
213 break;
214 default:
215 error(1, 0, "unknown option %c", optopt);
216 break;
217 }
218 }
219
220 if (!cfg_ifname)
221 error(1, 0, "must specify tap interface name (-i)");
222 }
223
main(int argc,char ** argv)224 int main(int argc, char **argv)
225 {
226 int fdt, fdr;
227
228 parse_opts(argc, argv);
229
230 fdr = raw_open();
231 fdt = tun_open(cfg_ifname);
232
233 tun_write(fdt);
234 raw_read(fdr);
235
236 if (close(fdt))
237 error(1, errno, "close tun");
238 if (close(fdr))
239 error(1, errno, "close udp");
240
241 fprintf(stderr, "OK\n");
242 return 0;
243 }
244
245