jeka
/
utun2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
623 Commits
15 Branches
2 Tags
169 MiB
 
 
 
 
 
 
Tree: e7c32d9ac1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'e7c32d9ac1'
${ noResults }
utun2/src/tun_freebsd.c

365 lines
14 KiB
Raw Blame History

// tun_freebsd.c - FreeBSD TUN/TAP implementation
// Uses /dev/tun device with ioctl
#if defined(__FreeBSD__)
#include <sys/sockio.h> // SIOCIFDESTROY
#include "tun_if.h"
#include "../lib/debug_config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <sys/stat.h>
#include <net/if.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <net/if_tun.h> // Для TUNSIFINFO, TUNSIFMODE, TUNSIFHEAD
#include <libutil.h> // Для devname()
#include "../lib/platform_compat.h"
#include <errno.h>
#include "../lib/mem.h"
// Helper for interface ioctl operations
static int if_ioctl(const char *ifname, unsigned long request, struct ifreq *ifr) {
int sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "Failed to create ioctl socket: %s", strerror(errno));
return -1;
}
strncpy(ifr->ifr_name, ifname, IFNAMSIZ - 1);
ifr->ifr_name[IFNAMSIZ - 1] = '\0';
int ret = ioctl(sock, request, ifr);
if (ret < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "ioctl failed for %s (request=0x%lx): %s", ifname, request, strerror(errno));
}
close(sock);
return ret;
}
// Parse IP address and CIDR mask
static int parse_ip_mask(const char *ip_addr, struct in_addr *ip, struct in_addr *netmask) {
if (!ip_addr || !ip || !netmask) return -1;
char ip_str[INET_ADDRSTRLEN];
char *slash = strchr(ip_addr, '/');
if (!slash) return -1;
size_t ip_len = slash - ip_addr;
if (ip_len >= sizeof(ip_str)) return -1;
strncpy(ip_str, ip_addr, ip_len);
ip_str[ip_len] = '\0';
if (inet_pton(AF_INET, ip_str, ip) <= 0) return -1;
char *endptr;
long cidr = strtol(slash + 1, &endptr, 10);
if (*endptr != '\0' || cidr < 0 || cidr > 32) return -1;
uint32_t mask = (cidr == 0) ? 0 : ~((1U << (32 - cidr)) - 1);
netmask->s_addr = htonl(mask);
return 0;
}
// Create TUN device using cloning device /dev/tun
static int create_tun_device(char *ifname, size_t ifname_len) {
int fd;
// Открываем cloning device /dev/tun
fd = open("/dev/tun", O_RDWR);
if (fd < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "Failed to open /dev/tun: %s", strerror(errno));
return -1;
}
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Opened cloning device /dev/tun (fd=%d)", fd);
// Получаем имя созданного интерфейса через devname()
// devname() возвращает имя устройства по major/minor номерам
struct stat st;
if (fstat(fd, &st) < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "fstat failed: %s", strerror(errno));
close(fd);
return -1;
}
const char *dev_name = devname(st.st_rdev, S_IFCHR);
if (!dev_name) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "devname failed: %s", strerror(errno));
close(fd);
return -1;
}
// dev_name будет в формате "tunN" или "/dev/tunN"
const char *base_name = dev_name;
if (strncmp(dev_name, "/dev/", 5) == 0) {
base_name = dev_name + 5;
}
strncpy(ifname, base_name, ifname_len - 1);
ifname[ifname_len - 1] = '\0';
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Created TUN device: %s", ifname);
return fd;
}
// Configure TUN device mode (POINTOPOINT + MULTICAST)
static int tun_set_mode(int fd, const char *ifname) {
int mode = IFF_POINTOPOINT | IFF_MULTICAST;
if (ioctl(fd, TUNSIFMODE, &mode) < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "TUNSIFMODE failed for %s: %s", ifname, strerror(errno));
return -1;
}
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Set TUNSIFMODE (POINTOPOINT | MULTICAST) on %s", ifname);
return 0;
}
// Enable TUNSIFHEAD mode (multi-af, 4-byte header with address family)
static int tun_set_head(int fd, const char *ifname) {
int head = 1;
if (ioctl(fd, TUNSIFHEAD, &head) < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "TUNSIFHEAD failed for %s: %s", ifname, strerror(errno));
return -1;
}
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Set TUNSIFHEAD on %s", ifname);
return 0;
}
// Set IP address on TUN interface using ifconfig
// FreeBSD требует отдельно IP и netmask для TUN
// For point-to-point, require destination address, set to same as local for /32
static int tun_set_ip(const char *ifname, const char *ip_addr) {
if (!ifname || !ip_addr) {
errno = EINVAL;
return -1;
}
// Парсим IP и CIDR
char ip_str[INET_ADDRSTRLEN] = {0};
int cidr = -1;
char *slash = strchr(ip_addr, '/');
if (slash) {
size_t ip_len = slash - ip_addr;
if (ip_len >= sizeof(ip_str)) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "IP address too long");
return -1;
}
strncpy(ip_str, ip_addr, ip_len);
ip_str[ip_len] = '\0';
char *endptr;
cidr = (int)strtol(slash + 1, &endptr, 10);
if (*endptr != '\0' || cidr < 0 || cidr > 32) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "Invalid CIDR: %s", slash + 1);
return -1;
}
} else {
strncpy(ip_str, ip_addr, sizeof(ip_str) - 1);
cidr = 32; // По умолчанию /32 для POINTOPOINT
}
// Вычисляем netmask из CIDR
struct in_addr netmask;
if (cidr == 0) {
netmask.s_addr = 0;
} else {
netmask.s_addr = htonl(~((1U << (32 - cidr)) - 1));
}
char mask_str[INET_ADDRSTRLEN];
if (inet_ntop(AF_INET, &netmask, mask_str, sizeof(mask_str)) == NULL) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "inet_ntop failed for netmask");
return -1;
}
// Формируем команду ifconfig с destination address (same as local for /32)
char cmd[512];
snprintf(cmd, sizeof(cmd), "ifconfig %s inet %s %s netmask %s up",
ifname, ip_str, ip_str, mask_str);
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Executing: %s", cmd);
int ret = system(cmd);
if (ret != 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "ifconfig failed for %s with IP %s netmask %s",
ifname, ip_str, mask_str);
// Fallback: пробуем через ioctl напрямую
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Trying ioctl fallback...");
int sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "socket failed: %s", strerror(errno));
return -1;
}
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
// Устанавливаем адрес
struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
sin->sin_family = AF_INET;
if (inet_pton(AF_INET, ip_str, &sin->sin_addr) <= 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "inet_pton failed for %s", ip_str);
close(sock);
return -1;
}
if (ioctl(sock, SIOCSIFADDR, &ifr) < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "SIOCSIFADDR failed: %s", strerror(errno));
close(sock);
return -1;
}
// Устанавливаем destination address (same as local)
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
struct sockaddr_in *sin_dst = (struct sockaddr_in *)&ifr.ifr_dstaddr;
sin_dst->sin_family = AF_INET;
sin_dst->sin_addr = sin->sin_addr; // same as local
if (ioctl(sock, SIOCSIFDSTADDR, &ifr) < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "SIOCSIFDSTADDR failed: %s", strerror(errno));
close(sock);
return -1;
}
// Устанавливаем netmask через ifr_addr (union в ifreq)
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
sin = (struct sockaddr_in *)&ifr.ifr_addr;
sin->sin_family = AF_INET;
sin->sin_addr = netmask;
if (ioctl(sock, SIOCSIFNETMASK, &ifr) < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "SIOCSIFNETMASK failed: %s", strerror(errno));
close(sock);
return -1;
}
// Поднимаем интерфейс
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
if (ioctl(sock, SIOCGIFFLAGS, &ifr) < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "SIOCGIFFLAGS failed: %s", strerror(errno));
close(sock);
return -1;
}
ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
if (ioctl(sock, SIOCSIFFLAGS, &ifr) < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "SIOCSIFFLAGS failed: %s", strerror(errno));
close(sock);
return -1;
}
close(sock);
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Successfully configured %s via ioctl", ifname);
return 0;
}
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Set IP %s/%d on %s", ip_str, cidr, ifname);
return 0;
}
// Set MTU on TUN interface
static int tun_set_mtu(const char *ifname, int mtu) {
if (!ifname || mtu <= 0) {
errno = EINVAL;
return -1;
}
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
ifr.ifr_mtu = mtu;
if (if_ioctl(ifname, SIOCSIFMTU, &ifr) < 0) {
DEBUG_WARN(DEBUG_CATEGORY_TUN, "Failed to set MTU %d on %s: %s", mtu, ifname, strerror(errno));
return -1;
}
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Set MTU %d on %s", mtu, ifname);
return 0;
}
// Platform-specific initialization for FreeBSD
int tun_platform_init(struct tun_if* tun, const char* ifname, const char* ip_str, int mtu) {
(void)ifname; // FreeBSD выделяет имя автоматически через cloning device
// Create TUN device
tun->fd = create_tun_device(tun->ifname, sizeof(tun->ifname));
if (tun->fd < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "Failed to create TUN device");
return -1;
}
DEBUG_INFO(DEBUG_CATEGORY_TUN, "TUN interface created: %s (fd=%d)", tun->ifname, tun->fd);
// Устанавливаем режим POINTOPOINT (должно быть ДО поднятия интерфейса)
if (tun_set_mode(tun->fd, tun->ifname) < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "Failed to set TUN mode on %s", tun->ifname);
close(tun->fd);
tun->fd = -1;
return -1;
}
// Включаем TUNSIFHEAD для multi-af режима
if (tun_set_head(tun->fd, tun->ifname) < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "Failed to set TUN head mode on %s", tun->ifname);
close(tun->fd);
tun->fd = -1;
return -1;
}
// Configure IP address (это также поднимает интерфейс)
if (tun_set_ip(tun->ifname, ip_str) < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "Failed to set TUN IP: %s", ip_str);
close(tun->fd);
tun->fd = -1;
return -1;
}
// Set MTU
if (tun_set_mtu(tun->ifname, mtu) < 0) {
DEBUG_WARN(DEBUG_CATEGORY_TUN, "Failed to set MTU %d on %s", mtu, tun->ifname);
}
// Получаем ifindex
tun->ifindex = if_nametoindex(tun->ifname);
if (tun->ifindex == 0) {
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "Failed to get ifindex for %s", tun->ifname);
} else {
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Interface %s has index %d", tun->ifname, tun->ifindex);
}
// Set non-blocking mode
if (fcntl(tun->fd, F_SETFL, O_NONBLOCK) < 0) {
DEBUG_WARN(DEBUG_CATEGORY_TUN, "Failed to set non-blocking mode: %s", strerror(errno));
}
return 0;
}
// Platform-specific cleanup for FreeBSD
void tun_platform_cleanup(struct tun_if* tun) {
if (!tun) return;
if (tun->fd >= 0) {
close(tun->fd);
tun->fd = -1;
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Closed TUN fd for %s", tun->ifname);
}
if (tun->ifname[0] != '\0') {
int sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock >= 0) {
struct ifreq ifr = {0};
strncpy(ifr.ifr_name, tun->ifname, IFNAMSIZ - 1);
ifr.ifr_name[IFNAMSIZ - 1] = '\0';
if (ioctl(sock, SIOCIFDESTROY, &ifr) < 0) {
// ENXIO / ENOENT = interface already gone (normal after close)
if (errno != ENXIO && errno != ENOENT) {
DEBUG_WARN(DEBUG_CATEGORY_TUN,
"SIOCIFDESTROY failed for %s: %s (errno=%d)",
tun->ifname, strerror(errno), errno);
} else {
DEBUG_DEBUG(DEBUG_CATEGORY_TUN, "TUN interface %s already destroyed", tun->ifname);
}
} else {
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Successfully destroyed TUN interface %s", tun->ifname);
}
close(sock);
}
}
}
// Platform-specific read for FreeBSD
// Возвращает данные без 4-байтового заголовка (TUNSIFHEAD обрабатывается ядром)
ssize_t tun_platform_read(struct tun_if* tun, uint8_t* buf, size_t len) {
uint32_t family;
struct iovec iv[2];
// Читаем family + данные
iv[0].iov_base = &family;
iv[0].iov_len = sizeof(family);
iv[1].iov_base = buf;
iv[1].iov_len = len;
ssize_t nread = readv(tun->fd, iv, 2);
if (nread < 0) {
if (errno == EINTR) {
return 0;
}
return -1;
}
// Возвращаем только размер данных (без family)
if (nread <= (ssize_t)sizeof(family)) {
return 0;
}
return nread - sizeof(family);
}
// Platform-specific write for FreeBSD
// Добавляет 4-байтовый заголовок с family перед записью
ssize_t tun_platform_write(struct tun_if* tun, const uint8_t* buf, size_t len) {
uint32_t family = htonl(AF_INET); // Предполагаем IPv4, можно определять по заголовку пакета
struct iovec iv[2];
iv[0].iov_base = &family;
iv[0].iov_len = sizeof(family);
iv[1].iov_base = (void*)buf;
iv[1].iov_len = len;
return writev(tun->fd, iv, 2);
}
// Get poll fd for uasync
int tun_platform_get_poll_fd(struct tun_if* tun) {
return tun->fd;
}
#endif // __FreeBSD__