Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Martin KaFai Lau | 1177 | 36.86% | 9 | 16.98% |
Stanislav Fomichev | 560 | 17.54% | 9 | 16.98% |
Geliang Tang | 521 | 16.32% | 17 | 32.08% |
Tushar Vyavahare | 216 | 6.76% | 2 | 3.77% |
Jussi Mäki | 133 | 4.17% | 3 | 5.66% |
Aditi Ghag | 110 | 3.45% | 1 | 1.89% |
Daniel Borkmann | 99 | 3.10% | 3 | 5.66% |
Daan De Meyer | 97 | 3.04% | 1 | 1.89% |
Alexei Starovoitov | 76 | 2.38% | 2 | 3.77% |
Jakub Sitnicki | 73 | 2.29% | 1 | 1.89% |
Andrey Ignatov | 72 | 2.25% | 1 | 1.89% |
Toke Höiland-Jörgensen | 45 | 1.41% | 1 | 1.89% |
Nicolas Rybowski | 9 | 0.28% | 1 | 1.89% |
Andrii Nakryiko | 5 | 0.16% | 2 | 3.77% |
Total | 3193 | 53 |
// SPDX-License-Identifier: GPL-2.0-only #define _GNU_SOURCE #include <errno.h> #include <stdbool.h> #include <stdio.h> #include <string.h> #include <unistd.h> #include <sched.h> #include <arpa/inet.h> #include <sys/mount.h> #include <sys/stat.h> #include <sys/un.h> #include <linux/err.h> #include <linux/in.h> #include <linux/in6.h> #include <linux/limits.h> #include "bpf_util.h" #include "network_helpers.h" #include "test_progs.h" #ifndef IPPROTO_MPTCP #define IPPROTO_MPTCP 262 #endif #define clean_errno() (errno == 0 ? "None" : strerror(errno)) #define log_err(MSG, ...) ({ \ int __save = errno; \ fprintf(stderr, "(%s:%d: errno: %s) " MSG "\n", \ __FILE__, __LINE__, clean_errno(), \ ##__VA_ARGS__); \ errno = __save; \ }) struct ipv4_packet pkt_v4 = { .eth.h_proto = __bpf_constant_htons(ETH_P_IP), .iph.ihl = 5, .iph.protocol = IPPROTO_TCP, .iph.tot_len = __bpf_constant_htons(MAGIC_BYTES), .tcp.urg_ptr = 123, .tcp.doff = 5, }; struct ipv6_packet pkt_v6 = { .eth.h_proto = __bpf_constant_htons(ETH_P_IPV6), .iph.nexthdr = IPPROTO_TCP, .iph.payload_len = __bpf_constant_htons(MAGIC_BYTES), .tcp.urg_ptr = 123, .tcp.doff = 5, }; static const struct network_helper_opts default_opts; int settimeo(int fd, int timeout_ms) { struct timeval timeout = { .tv_sec = 3 }; if (timeout_ms > 0) { timeout.tv_sec = timeout_ms / 1000; timeout.tv_usec = (timeout_ms % 1000) * 1000; } if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout))) { log_err("Failed to set SO_RCVTIMEO"); return -1; } if (setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout))) { log_err("Failed to set SO_SNDTIMEO"); return -1; } return 0; } #define save_errno_close(fd) ({ int __save = errno; close(fd); errno = __save; }) static int __start_server(int type, const struct sockaddr *addr, socklen_t addrlen, const struct network_helper_opts *opts) { int fd; fd = socket(addr->sa_family, type, opts->proto); if (fd < 0) { log_err("Failed to create server socket"); return -1; } if (settimeo(fd, opts->timeout_ms)) goto error_close; if (opts->post_socket_cb && opts->post_socket_cb(fd, opts->cb_opts)) { log_err("Failed to call post_socket_cb"); goto error_close; } if (bind(fd, addr, addrlen) < 0) { log_err("Failed to bind socket"); goto error_close; } if (type == SOCK_STREAM) { if (listen(fd, opts->backlog ? MAX(opts->backlog, 0) : 1) < 0) { log_err("Failed to listed on socket"); goto error_close; } } return fd; error_close: save_errno_close(fd); return -1; } int start_server_str(int family, int type, const char *addr_str, __u16 port, const struct network_helper_opts *opts) { struct sockaddr_storage addr; socklen_t addrlen; if (!opts) opts = &default_opts; if (make_sockaddr(family, addr_str, port, &addr, &addrlen)) return -1; return __start_server(type, (struct sockaddr *)&addr, addrlen, opts); } int start_server(int family, int type, const char *addr_str, __u16 port, int timeout_ms) { struct network_helper_opts opts = { .timeout_ms = timeout_ms, }; return start_server_str(family, type, addr_str, port, &opts); } static int reuseport_cb(int fd, void *opts) { int on = 1; return setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)); } int *start_reuseport_server(int family, int type, const char *addr_str, __u16 port, int timeout_ms, unsigned int nr_listens) { struct network_helper_opts opts = { .timeout_ms = timeout_ms, .post_socket_cb = reuseport_cb, }; struct sockaddr_storage addr; unsigned int nr_fds = 0; socklen_t addrlen; int *fds; if (!nr_listens) return NULL; if (make_sockaddr(family, addr_str, port, &addr, &addrlen)) return NULL; fds = malloc(sizeof(*fds) * nr_listens); if (!fds) return NULL; fds[0] = __start_server(type, (struct sockaddr *)&addr, addrlen, &opts); if (fds[0] == -1) goto close_fds; nr_fds = 1; if (getsockname(fds[0], (struct sockaddr *)&addr, &addrlen)) goto close_fds; for (; nr_fds < nr_listens; nr_fds++) { fds[nr_fds] = __start_server(type, (struct sockaddr *)&addr, addrlen, &opts); if (fds[nr_fds] == -1) goto close_fds; } return fds; close_fds: free_fds(fds, nr_fds); return NULL; } int start_server_addr(int type, const struct sockaddr_storage *addr, socklen_t len, const struct network_helper_opts *opts) { if (!opts) opts = &default_opts; return __start_server(type, (struct sockaddr *)addr, len, opts); } void free_fds(int *fds, unsigned int nr_close_fds) { if (fds) { while (nr_close_fds) close(fds[--nr_close_fds]); free(fds); } } int fastopen_connect(int server_fd, const char *data, unsigned int data_len, int timeout_ms) { struct sockaddr_storage addr; socklen_t addrlen = sizeof(addr); struct sockaddr_in *addr_in; int fd, ret; if (getsockname(server_fd, (struct sockaddr *)&addr, &addrlen)) { log_err("Failed to get server addr"); return -1; } addr_in = (struct sockaddr_in *)&addr; fd = socket(addr_in->sin_family, SOCK_STREAM, 0); if (fd < 0) { log_err("Failed to create client socket"); return -1; } if (settimeo(fd, timeout_ms)) goto error_close; ret = sendto(fd, data, data_len, MSG_FASTOPEN, (struct sockaddr *)&addr, addrlen); if (ret != data_len) { log_err("sendto(data, %u) != %d\n", data_len, ret); goto error_close; } return fd; error_close: save_errno_close(fd); return -1; } int client_socket(int family, int type, const struct network_helper_opts *opts) { int fd; if (!opts) opts = &default_opts; fd = socket(family, type, opts->proto); if (fd < 0) { log_err("Failed to create client socket"); return -1; } if (settimeo(fd, opts->timeout_ms)) goto error_close; if (opts->post_socket_cb && opts->post_socket_cb(fd, opts->cb_opts)) goto error_close; return fd; error_close: save_errno_close(fd); return -1; } static int connect_fd_to_addr(int fd, const struct sockaddr_storage *addr, socklen_t addrlen, const bool must_fail) { int ret; errno = 0; ret = connect(fd, (const struct sockaddr *)addr, addrlen); if (must_fail) { if (!ret) { log_err("Unexpected success to connect to server"); return -1; } if (errno != EPERM) { log_err("Unexpected error from connect to server"); return -1; } } else { if (ret) { log_err("Failed to connect to server"); return -1; } } return 0; } int connect_to_addr(int type, const struct sockaddr_storage *addr, socklen_t addrlen, const struct network_helper_opts *opts) { int fd; if (!opts) opts = &default_opts; fd = client_socket(addr->ss_family, type, opts); if (fd < 0) { log_err("Failed to create client socket"); return -1; } if (connect_fd_to_addr(fd, addr, addrlen, opts->must_fail)) goto error_close; return fd; error_close: save_errno_close(fd); return -1; } int connect_to_fd_opts(int server_fd, int type, const struct network_helper_opts *opts) { struct sockaddr_storage addr; socklen_t addrlen; if (!opts) opts = &default_opts; addrlen = sizeof(addr); if (getsockname(server_fd, (struct sockaddr *)&addr, &addrlen)) { log_err("Failed to get server addr"); return -1; } return connect_to_addr(type, &addr, addrlen, opts); } int connect_to_fd(int server_fd, int timeout_ms) { struct network_helper_opts opts = { .timeout_ms = timeout_ms, }; int type, protocol; socklen_t optlen; optlen = sizeof(type); if (getsockopt(server_fd, SOL_SOCKET, SO_TYPE, &type, &optlen)) { log_err("getsockopt(SOL_TYPE)"); return -1; } optlen = sizeof(protocol); if (getsockopt(server_fd, SOL_SOCKET, SO_PROTOCOL, &protocol, &optlen)) { log_err("getsockopt(SOL_PROTOCOL)"); return -1; } opts.proto = protocol; return connect_to_fd_opts(server_fd, type, &opts); } int connect_fd_to_fd(int client_fd, int server_fd, int timeout_ms) { struct sockaddr_storage addr; socklen_t len = sizeof(addr); if (settimeo(client_fd, timeout_ms)) return -1; if (getsockname(server_fd, (struct sockaddr *)&addr, &len)) { log_err("Failed to get server addr"); return -1; } if (connect_fd_to_addr(client_fd, &addr, len, false)) return -1; return 0; } int make_sockaddr(int family, const char *addr_str, __u16 port, struct sockaddr_storage *addr, socklen_t *len) { if (family == AF_INET) { struct sockaddr_in *sin = (void *)addr; memset(addr, 0, sizeof(*sin)); sin->sin_family = AF_INET; sin->sin_port = htons(port); if (addr_str && inet_pton(AF_INET, addr_str, &sin->sin_addr) != 1) { log_err("inet_pton(AF_INET, %s)", addr_str); return -1; } if (len) *len = sizeof(*sin); return 0; } else if (family == AF_INET6) { struct sockaddr_in6 *sin6 = (void *)addr; memset(addr, 0, sizeof(*sin6)); sin6->sin6_family = AF_INET6; sin6->sin6_port = htons(port); if (addr_str && inet_pton(AF_INET6, addr_str, &sin6->sin6_addr) != 1) { log_err("inet_pton(AF_INET6, %s)", addr_str); return -1; } if (len) *len = sizeof(*sin6); return 0; } else if (family == AF_UNIX) { /* Note that we always use abstract unix sockets to avoid having * to clean up leftover files. */ struct sockaddr_un *sun = (void *)addr; memset(addr, 0, sizeof(*sun)); sun->sun_family = family; sun->sun_path[0] = 0; strcpy(sun->sun_path + 1, addr_str); if (len) *len = offsetof(struct sockaddr_un, sun_path) + 1 + strlen(addr_str); return 0; } return -1; } char *ping_command(int family) { if (family == AF_INET6) { /* On some systems 'ping' doesn't support IPv6, so use ping6 if it is present. */ if (!system("which ping6 >/dev/null 2>&1")) return "ping6"; else return "ping -6"; } return "ping"; } struct nstoken { int orig_netns_fd; }; struct nstoken *open_netns(const char *name) { int nsfd; char nspath[PATH_MAX]; int err; struct nstoken *token; token = calloc(1, sizeof(struct nstoken)); if (!token) { log_err("Failed to malloc token"); return NULL; } token->orig_netns_fd = open("/proc/self/ns/net", O_RDONLY); if (token->orig_netns_fd == -1) { log_err("Failed to open(/proc/self/ns/net)"); goto fail; } snprintf(nspath, sizeof(nspath), "%s/%s", "/var/run/netns", name); nsfd = open(nspath, O_RDONLY | O_CLOEXEC); if (nsfd == -1) { log_err("Failed to open(%s)", nspath); goto fail; } err = setns(nsfd, CLONE_NEWNET); close(nsfd); if (err) { log_err("Failed to setns(nsfd)"); goto fail; } return token; fail: if (token->orig_netns_fd != -1) close(token->orig_netns_fd); free(token); return NULL; } void close_netns(struct nstoken *token) { if (!token) return; if (setns(token->orig_netns_fd, CLONE_NEWNET)) log_err("Failed to setns(orig_netns_fd)"); close(token->orig_netns_fd); free(token); } int get_socket_local_port(int sock_fd) { struct sockaddr_storage addr; socklen_t addrlen = sizeof(addr); int err; err = getsockname(sock_fd, (struct sockaddr *)&addr, &addrlen); if (err < 0) return err; if (addr.ss_family == AF_INET) { struct sockaddr_in *sin = (struct sockaddr_in *)&addr; return sin->sin_port; } else if (addr.ss_family == AF_INET6) { struct sockaddr_in6 *sin = (struct sockaddr_in6 *)&addr; return sin->sin6_port; } return -1; } int get_hw_ring_size(char *ifname, struct ethtool_ringparam *ring_param) { struct ifreq ifr = {0}; int sockfd, err; sockfd = socket(AF_INET, SOCK_DGRAM, 0); if (sockfd < 0) return -errno; memcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); ring_param->cmd = ETHTOOL_GRINGPARAM; ifr.ifr_data = (char *)ring_param; if (ioctl(sockfd, SIOCETHTOOL, &ifr) < 0) { err = errno; close(sockfd); return -err; } close(sockfd); return 0; } int set_hw_ring_size(char *ifname, struct ethtool_ringparam *ring_param) { struct ifreq ifr = {0}; int sockfd, err; sockfd = socket(AF_INET, SOCK_DGRAM, 0); if (sockfd < 0) return -errno; memcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); ring_param->cmd = ETHTOOL_SRINGPARAM; ifr.ifr_data = (char *)ring_param; if (ioctl(sockfd, SIOCETHTOOL, &ifr) < 0) { err = errno; close(sockfd); return -err; } close(sockfd); return 0; } struct send_recv_arg { int fd; uint32_t bytes; int stop; }; static void *send_recv_server(void *arg) { struct send_recv_arg *a = (struct send_recv_arg *)arg; ssize_t nr_sent = 0, bytes = 0; char batch[1500]; int err = 0, fd; fd = accept(a->fd, NULL, NULL); while (fd == -1) { if (errno == EINTR) continue; err = -errno; goto done; } if (settimeo(fd, 0)) { err = -errno; goto done; } while (bytes < a->bytes && !READ_ONCE(a->stop)) { nr_sent = send(fd, &batch, MIN(a->bytes - bytes, sizeof(batch)), 0); if (nr_sent == -1 && errno == EINTR) continue; if (nr_sent == -1) { err = -errno; break; } bytes += nr_sent; } if (bytes != a->bytes) { log_err("send %zd expected %u", bytes, a->bytes); if (!err) err = bytes > a->bytes ? -E2BIG : -EINTR; } done: if (fd >= 0) close(fd); if (err) { WRITE_ONCE(a->stop, 1); return ERR_PTR(err); } return NULL; } int send_recv_data(int lfd, int fd, uint32_t total_bytes) { ssize_t nr_recv = 0, bytes = 0; struct send_recv_arg arg = { .fd = lfd, .bytes = total_bytes, .stop = 0, }; pthread_t srv_thread; void *thread_ret; char batch[1500]; int err = 0; err = pthread_create(&srv_thread, NULL, send_recv_server, (void *)&arg); if (err) { log_err("Failed to pthread_create"); return err; } /* recv total_bytes */ while (bytes < total_bytes && !READ_ONCE(arg.stop)) { nr_recv = recv(fd, &batch, MIN(total_bytes - bytes, sizeof(batch)), 0); if (nr_recv == -1 && errno == EINTR) continue; if (nr_recv == -1) { err = -errno; break; } bytes += nr_recv; } if (bytes != total_bytes) { log_err("recv %zd expected %u", bytes, total_bytes); if (!err) err = bytes > total_bytes ? -E2BIG : -EINTR; } WRITE_ONCE(arg.stop, 1); pthread_join(srv_thread, &thread_ret); if (IS_ERR(thread_ret)) { log_err("Failed in thread_ret %ld", PTR_ERR(thread_ret)); err = err ? : PTR_ERR(thread_ret); } return err; }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1