1
2
3
4
5
6#include <stdio.h>
7#include <unistd.h>
8#include <stdarg.h>
9#include <errno.h>
10#include <stddef.h>
11#include <string.h>
12#include <sys/ioctl.h>
13#include <net/if.h>
14#include <linux/if_tun.h>
15#include <arpa/inet.h>
16#include <sys/types.h>
17#include <sys/stat.h>
18#include <fcntl.h>
19#include <sys/types.h>
20#include <sys/socket.h>
21#include <net/ethernet.h>
22#include <netinet/ip.h>
23#include <netinet/ether.h>
24#include <linux/if_ether.h>
25#include <linux/if_packet.h>
26#include <sys/socket.h>
27#include <sys/wait.h>
28#include <linux/virtio_net.h>
29#include <netdb.h>
30#include <stdlib.h>
31#include <os.h>
32#include <um_malloc.h>
33#include "vector_user.h"
34
35#define ID_GRE 0
36#define ID_L2TPV3 1
37#define ID_MAX 1
38
39#define TOKEN_IFNAME "ifname"
40
41#define TRANS_RAW "raw"
42#define TRANS_RAW_LEN strlen(TRANS_RAW)
43
44#define VNET_HDR_FAIL "could not enable vnet headers on fd %d"
45#define TUN_GET_F_FAIL "tapraw: TUNGETFEATURES failed: %s"
46#define L2TPV3_BIND_FAIL "l2tpv3_open : could not bind socket err=%i"
47#define BPF_ATTACH_FAIL "Failed to attach filter size %d to %d, err %d\n"
48
49
50
51
52
53
54char *uml_vector_fetch_arg(struct arglist *ifspec, char *token)
55{
56 int i;
57
58 for (i = 0; i < ifspec->numargs; i++) {
59 if (strcmp(ifspec->tokens[i], token) == 0)
60 return ifspec->values[i];
61 }
62 return NULL;
63
64}
65
66struct arglist *uml_parse_vector_ifspec(char *arg)
67{
68 struct arglist *result;
69 int pos, len;
70 bool parsing_token = true, next_starts = true;
71
72 if (arg == NULL)
73 return NULL;
74 result = uml_kmalloc(sizeof(struct arglist), UM_GFP_KERNEL);
75 if (result == NULL)
76 return NULL;
77 result->numargs = 0;
78 len = strlen(arg);
79 for (pos = 0; pos < len; pos++) {
80 if (next_starts) {
81 if (parsing_token) {
82 result->tokens[result->numargs] = arg + pos;
83 } else {
84 result->values[result->numargs] = arg + pos;
85 result->numargs++;
86 }
87 next_starts = false;
88 }
89 if (*(arg + pos) == '=') {
90 if (parsing_token)
91 parsing_token = false;
92 else
93 goto cleanup;
94 next_starts = true;
95 (*(arg + pos)) = '\0';
96 }
97 if (*(arg + pos) == ',') {
98 parsing_token = true;
99 next_starts = true;
100 (*(arg + pos)) = '\0';
101 }
102 }
103 return result;
104cleanup:
105 printk(UM_KERN_ERR "vector_setup - Couldn't parse '%s'\n", arg);
106 kfree(result);
107 return NULL;
108}
109
110
111
112
113
114
115
116#define PATH_NET_TUN "/dev/net/tun"
117
118static struct vector_fds *user_init_tap_fds(struct arglist *ifspec)
119{
120 struct ifreq ifr;
121 int fd = -1;
122 struct sockaddr_ll sock;
123 int err = -ENOMEM, offload;
124 char *iface;
125 struct vector_fds *result = NULL;
126
127 iface = uml_vector_fetch_arg(ifspec, TOKEN_IFNAME);
128 if (iface == NULL) {
129 printk(UM_KERN_ERR "uml_tap: failed to parse interface spec\n");
130 goto tap_cleanup;
131 }
132
133 result = uml_kmalloc(sizeof(struct vector_fds), UM_GFP_KERNEL);
134 if (result == NULL) {
135 printk(UM_KERN_ERR "uml_tap: failed to allocate file descriptors\n");
136 goto tap_cleanup;
137 }
138 result->rx_fd = -1;
139 result->tx_fd = -1;
140 result->remote_addr = NULL;
141 result->remote_addr_size = 0;
142
143
144
145 fd = open(PATH_NET_TUN, O_RDWR);
146 if (fd < 0) {
147 printk(UM_KERN_ERR "uml_tap: failed to open tun device\n");
148 goto tap_cleanup;
149 }
150 result->tx_fd = fd;
151 memset(&ifr, 0, sizeof(ifr));
152 ifr.ifr_flags = IFF_TAP | IFF_NO_PI | IFF_VNET_HDR;
153 strncpy((char *)&ifr.ifr_name, iface, sizeof(ifr.ifr_name) - 1);
154
155 err = ioctl(fd, TUNSETIFF, (void *) &ifr);
156 if (err != 0) {
157 printk(UM_KERN_ERR "uml_tap: failed to select tap interface\n");
158 goto tap_cleanup;
159 }
160
161 offload = TUN_F_CSUM | TUN_F_TSO4 | TUN_F_TSO6;
162 ioctl(fd, TUNSETOFFLOAD, offload);
163
164
165
166 fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
167 if (fd == -1) {
168 printk(UM_KERN_ERR
169 "uml_tap: failed to create socket: %i\n", -errno);
170 goto tap_cleanup;
171 }
172 result->rx_fd = fd;
173 memset(&ifr, 0, sizeof(ifr));
174 strncpy((char *)&ifr.ifr_name, iface, sizeof(ifr.ifr_name) - 1);
175 if (ioctl(fd, SIOCGIFINDEX, (void *) &ifr) < 0) {
176 printk(UM_KERN_ERR
177 "uml_tap: failed to set interface: %i\n", -errno);
178 goto tap_cleanup;
179 }
180
181 sock.sll_family = AF_PACKET;
182 sock.sll_protocol = htons(ETH_P_ALL);
183 sock.sll_ifindex = ifr.ifr_ifindex;
184
185 if (bind(fd,
186 (struct sockaddr *) &sock, sizeof(struct sockaddr_ll)) < 0) {
187 printk(UM_KERN_ERR
188 "user_init_tap: failed to bind raw pair, err %d\n",
189 -errno);
190 goto tap_cleanup;
191 }
192 return result;
193tap_cleanup:
194 printk(UM_KERN_ERR "user_init_tap: init failed, error %d", err);
195 if (result != NULL) {
196 if (result->rx_fd >= 0)
197 os_close_file(result->rx_fd);
198 if (result->tx_fd >= 0)
199 os_close_file(result->tx_fd);
200 kfree(result);
201 }
202 return NULL;
203}
204
205
206static struct vector_fds *user_init_raw_fds(struct arglist *ifspec)
207{
208 struct ifreq ifr;
209 int rxfd = -1, txfd = -1;
210 struct sockaddr_ll sock;
211 int err = -ENOMEM;
212 char *iface;
213 struct vector_fds *result = NULL;
214
215 iface = uml_vector_fetch_arg(ifspec, TOKEN_IFNAME);
216 if (iface == NULL)
217 goto cleanup;
218
219 rxfd = socket(AF_PACKET, SOCK_RAW, ETH_P_ALL);
220 if (rxfd == -1) {
221 err = -errno;
222 goto cleanup;
223 }
224 txfd = socket(AF_PACKET, SOCK_RAW, 0);
225 if (txfd == -1) {
226 err = -errno;
227 goto cleanup;
228 }
229 memset(&ifr, 0, sizeof(ifr));
230 strncpy((char *)&ifr.ifr_name, iface, sizeof(ifr.ifr_name) - 1);
231 if (ioctl(rxfd, SIOCGIFINDEX, (void *) &ifr) < 0) {
232 err = -errno;
233 goto cleanup;
234 }
235
236 sock.sll_family = AF_PACKET;
237 sock.sll_protocol = htons(ETH_P_ALL);
238 sock.sll_ifindex = ifr.ifr_ifindex;
239
240 if (bind(rxfd,
241 (struct sockaddr *) &sock, sizeof(struct sockaddr_ll)) < 0) {
242 err = -errno;
243 goto cleanup;
244 }
245
246 sock.sll_family = AF_PACKET;
247 sock.sll_protocol = htons(ETH_P_IP);
248 sock.sll_ifindex = ifr.ifr_ifindex;
249
250 if (bind(txfd,
251 (struct sockaddr *) &sock, sizeof(struct sockaddr_ll)) < 0) {
252 err = -errno;
253 goto cleanup;
254 }
255
256 result = uml_kmalloc(sizeof(struct vector_fds), UM_GFP_KERNEL);
257 if (result != NULL) {
258 result->rx_fd = rxfd;
259 result->tx_fd = txfd;
260 result->remote_addr = NULL;
261 result->remote_addr_size = 0;
262 }
263 return result;
264cleanup:
265 printk(UM_KERN_ERR "user_init_raw: init failed, error %d", err);
266 if (rxfd >= 0)
267 os_close_file(rxfd);
268 if (txfd >= 0)
269 os_close_file(txfd);
270 if (result != NULL)
271 kfree(result);
272 return NULL;
273}
274
275
276bool uml_raw_enable_qdisc_bypass(int fd)
277{
278 int optval = 1;
279
280 if (setsockopt(fd,
281 SOL_PACKET, PACKET_QDISC_BYPASS,
282 &optval, sizeof(optval)) != 0) {
283 return false;
284 }
285 return true;
286}
287
288bool uml_raw_enable_vnet_headers(int fd)
289{
290 int optval = 1;
291
292 if (setsockopt(fd,
293 SOL_PACKET, PACKET_VNET_HDR,
294 &optval, sizeof(optval)) != 0) {
295 printk(UM_KERN_INFO VNET_HDR_FAIL, fd);
296 return false;
297 }
298 return true;
299}
300bool uml_tap_enable_vnet_headers(int fd)
301{
302 unsigned int features;
303 int len = sizeof(struct virtio_net_hdr);
304
305 if (ioctl(fd, TUNGETFEATURES, &features) == -1) {
306 printk(UM_KERN_INFO TUN_GET_F_FAIL, strerror(errno));
307 return false;
308 }
309 if ((features & IFF_VNET_HDR) == 0) {
310 printk(UM_KERN_INFO "tapraw: No VNET HEADER support");
311 return false;
312 }
313 ioctl(fd, TUNSETVNETHDRSZ, &len);
314 return true;
315}
316
317static struct vector_fds *user_init_socket_fds(struct arglist *ifspec, int id)
318{
319 int err = -ENOMEM;
320 int fd = -1, gairet;
321 struct addrinfo srchints;
322 struct addrinfo dsthints;
323 bool v6, udp;
324 char *value;
325 char *src, *dst, *srcport, *dstport;
326 struct addrinfo *gairesult = NULL;
327 struct vector_fds *result = NULL;
328
329
330 value = uml_vector_fetch_arg(ifspec, "v6");
331 v6 = false;
332 udp = false;
333 if (value != NULL) {
334 if (strtol((const char *) value, NULL, 10) > 0)
335 v6 = true;
336 }
337
338 value = uml_vector_fetch_arg(ifspec, "udp");
339 if (value != NULL) {
340 if (strtol((const char *) value, NULL, 10) > 0)
341 udp = true;
342 }
343 src = uml_vector_fetch_arg(ifspec, "src");
344 dst = uml_vector_fetch_arg(ifspec, "dst");
345 srcport = uml_vector_fetch_arg(ifspec, "srcport");
346 dstport = uml_vector_fetch_arg(ifspec, "dstport");
347
348 memset(&dsthints, 0, sizeof(dsthints));
349
350 if (v6)
351 dsthints.ai_family = AF_INET6;
352 else
353 dsthints.ai_family = AF_INET;
354
355 switch (id) {
356 case ID_GRE:
357 dsthints.ai_socktype = SOCK_RAW;
358 dsthints.ai_protocol = IPPROTO_GRE;
359 break;
360 case ID_L2TPV3:
361 if (udp) {
362 dsthints.ai_socktype = SOCK_DGRAM;
363 dsthints.ai_protocol = 0;
364 } else {
365 dsthints.ai_socktype = SOCK_RAW;
366 dsthints.ai_protocol = IPPROTO_L2TP;
367 }
368 break;
369 default:
370 printk(KERN_ERR "Unsupported socket type\n");
371 return NULL;
372 }
373 memcpy(&srchints, &dsthints, sizeof(struct addrinfo));
374
375 gairet = getaddrinfo(src, srcport, &dsthints, &gairesult);
376 if ((gairet != 0) || (gairesult == NULL)) {
377 printk(UM_KERN_ERR
378 "socket_open : could not resolve src, error = %s",
379 gai_strerror(gairet)
380 );
381 return NULL;
382 }
383 fd = socket(gairesult->ai_family,
384 gairesult->ai_socktype, gairesult->ai_protocol);
385 if (fd == -1) {
386 printk(UM_KERN_ERR
387 "socket_open : could not open socket, error = %d",
388 -errno
389 );
390 goto cleanup;
391 }
392 if (bind(fd,
393 (struct sockaddr *) gairesult->ai_addr,
394 gairesult->ai_addrlen)) {
395 printk(UM_KERN_ERR L2TPV3_BIND_FAIL, errno);
396 goto cleanup;
397 }
398
399 if (gairesult != NULL)
400 freeaddrinfo(gairesult);
401
402 gairesult = NULL;
403
404 gairet = getaddrinfo(dst, dstport, &dsthints, &gairesult);
405 if ((gairet != 0) || (gairesult == NULL)) {
406 printk(UM_KERN_ERR
407 "socket_open : could not resolve dst, error = %s",
408 gai_strerror(gairet)
409 );
410 return NULL;
411 }
412
413 result = uml_kmalloc(sizeof(struct vector_fds), UM_GFP_KERNEL);
414 if (result != NULL) {
415 result->rx_fd = fd;
416 result->tx_fd = fd;
417 result->remote_addr = uml_kmalloc(
418 gairesult->ai_addrlen, UM_GFP_KERNEL);
419 if (result->remote_addr == NULL)
420 goto cleanup;
421 result->remote_addr_size = gairesult->ai_addrlen;
422 memcpy(
423 result->remote_addr,
424 gairesult->ai_addr,
425 gairesult->ai_addrlen
426 );
427 }
428 freeaddrinfo(gairesult);
429 return result;
430cleanup:
431 if (gairesult != NULL)
432 freeaddrinfo(gairesult);
433 printk(UM_KERN_ERR "user_init_socket: init failed, error %d", err);
434 if (fd >= 0)
435 os_close_file(fd);
436 if (result != NULL) {
437 if (result->remote_addr != NULL)
438 kfree(result->remote_addr);
439 kfree(result);
440 }
441 return NULL;
442}
443
444struct vector_fds *uml_vector_user_open(
445 int unit,
446 struct arglist *parsed
447)
448{
449 char *transport;
450
451 if (parsed == NULL) {
452 printk(UM_KERN_ERR "no parsed config for unit %d\n", unit);
453 return NULL;
454 }
455 transport = uml_vector_fetch_arg(parsed, "transport");
456 if (transport == NULL) {
457 printk(UM_KERN_ERR "missing transport for unit %d\n", unit);
458 return NULL;
459 }
460 if (strncmp(transport, TRANS_RAW, TRANS_RAW_LEN) == 0)
461 return user_init_raw_fds(parsed);
462 if (strncmp(transport, TRANS_TAP, TRANS_TAP_LEN) == 0)
463 return user_init_tap_fds(parsed);
464 if (strncmp(transport, TRANS_GRE, TRANS_GRE_LEN) == 0)
465 return user_init_socket_fds(parsed, ID_GRE);
466 if (strncmp(transport, TRANS_L2TPV3, TRANS_L2TPV3_LEN) == 0)
467 return user_init_socket_fds(parsed, ID_L2TPV3);
468 return NULL;
469}
470
471
472int uml_vector_sendmsg(int fd, void *hdr, int flags)
473{
474 int n;
475
476 CATCH_EINTR(n = sendmsg(fd, (struct msghdr *) hdr, flags));
477 if ((n < 0) && (errno == EAGAIN))
478 return 0;
479 if (n >= 0)
480 return n;
481 else
482 return -errno;
483}
484
485int uml_vector_recvmsg(int fd, void *hdr, int flags)
486{
487 int n;
488
489 CATCH_EINTR(n = recvmsg(fd, (struct msghdr *) hdr, flags));
490 if ((n < 0) && (errno == EAGAIN))
491 return 0;
492 if (n >= 0)
493 return n;
494 else
495 return -errno;
496}
497
498int uml_vector_writev(int fd, void *hdr, int iovcount)
499{
500 int n;
501
502 CATCH_EINTR(n = writev(fd, (struct iovec *) hdr, iovcount));
503 if ((n < 0) && (errno == EAGAIN))
504 return 0;
505 if (n >= 0)
506 return n;
507 else
508 return -errno;
509}
510
511int uml_vector_sendmmsg(
512 int fd,
513 void *msgvec,
514 unsigned int vlen,
515 unsigned int flags)
516{
517 int n;
518
519 CATCH_EINTR(n = sendmmsg(fd, (struct mmsghdr *) msgvec, vlen, flags));
520 if ((n < 0) && (errno == EAGAIN))
521 return 0;
522 if (n >= 0)
523 return n;
524 else
525 return -errno;
526}
527
528int uml_vector_recvmmsg(
529 int fd,
530 void *msgvec,
531 unsigned int vlen,
532 unsigned int flags)
533{
534 int n;
535
536 CATCH_EINTR(
537 n = recvmmsg(fd, (struct mmsghdr *) msgvec, vlen, flags, 0));
538 if ((n < 0) && (errno == EAGAIN))
539 return 0;
540 if (n >= 0)
541 return n;
542 else
543 return -errno;
544}
545int uml_vector_attach_bpf(int fd, void *bpf, int bpf_len)
546{
547 int err = setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, bpf, bpf_len);
548
549 if (err < 0)
550 printk(KERN_ERR BPF_ATTACH_FAIL, bpf_len, fd, -errno);
551 return err;
552}
553
554#define DEFAULT_BPF_LEN 6
555
556void *uml_vector_default_bpf(int fd, void *mac)
557{
558 struct sock_filter *bpf;
559 uint32_t *mac1 = (uint32_t *)(mac + 2);
560 uint16_t *mac2 = (uint16_t *) mac;
561 struct sock_fprog bpf_prog = {
562 .len = 6,
563 .filter = NULL,
564 };
565
566 bpf = uml_kmalloc(
567 sizeof(struct sock_filter) * DEFAULT_BPF_LEN, UM_GFP_KERNEL);
568 if (bpf != NULL) {
569 bpf_prog.filter = bpf;
570
571 bpf[0] = (struct sock_filter){ 0x20, 0, 0, 0x00000008 };
572
573 bpf[1] = (struct sock_filter){ 0x15, 0, 3, ntohl(*mac1)};
574
575 bpf[2] = (struct sock_filter){ 0x28, 0, 0, 0x00000006 };
576
577 bpf[3] = (struct sock_filter){ 0x15, 0, 1, ntohs(*mac2)};
578
579 bpf[4] = (struct sock_filter){ 0x6, 0, 0, 0x00000000 };
580
581 bpf[5] = (struct sock_filter){ 0x6, 0, 0, 0x00040000 };
582 if (uml_vector_attach_bpf(
583 fd, &bpf_prog, sizeof(struct sock_fprog)) < 0) {
584 kfree(bpf);
585 bpf = NULL;
586 }
587 }
588 return bpf;
589}
590
591
