tun_adapter_linux.cpp

// Linux TUN adapter using /dev/net/tun.
// Implements the TunAdapter interface declared in tun_adapter.h.

#include "tun_adapter.h"

#include <fcntl.h>
#include <linux/if_tun.h>
#include <net/if.h>
#include <poll.h>
#include <sys/ioctl.h>
#include <unistd.h>

#include <array>
#include <cerrno>
#include <cstring>
#include <string>

#include "log.h"
#include "util.h"

namespace {
constexpr int kReadTimeoutMs = 500;
constexpr size_t kMaxIpPacketSize = 65535;
constexpr const char* kTunDevPath = "/dev/net/tun";
}  // namespace

class LinuxTunAdapter : public TunAdapter {
public:
	~LinuxTunAdapter() override { Close(); }

	bool Open(const Config& cfg) override {
		fd_ = ::open(kTunDevPath, O_RDWR);
		if (fd_ < 0) {
			Log(LogLevel::Error,
				std::string("Failed to open ") + kTunDevPath + ": "
				+ std::strerror(errno));
			return false;
		}

		struct ifreq ifr {};
		ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
		if (!cfg.adapter_name.empty()) {
			if (cfg.adapter_name.size() >= IFNAMSIZ) {
				Log(LogLevel::Error,
					"adapter_name is too long (max " + std::to_string(IFNAMSIZ - 1)
					+ " chars): " + cfg.adapter_name);
				Close();
				return false;
			}
			std::strncpy(ifr.ifr_name, cfg.adapter_name.c_str(), IFNAMSIZ - 1);
		}

		if (::ioctl(fd_, TUNSETIFF, &ifr) < 0) {
			Log(LogLevel::Error,
				std::string("TUNSETIFF failed: ") + std::strerror(errno));
			Close();
			return false;
		}

		Log(LogLevel::Info,
			std::string("TUN device opened: ") + ifr.ifr_name);

		if (cfg.auto_config_ipv4) {
			if (!ConfigureTunIpv4(cfg)) {
				Log(LogLevel::Error, "Failed to configure TUN IPv4.");
				Close();
				return false;
			}
			if (!ConfigureTunMtu(cfg)) {
				Log(LogLevel::Error, "Failed to configure TUN MTU.");
				Close();
				return false;
			}
		} else {
			Log(LogLevel::Info,
				"auto_config_ipv4=false, skip TUN IP/MTU setup.");
		}

		return true;
	}

	void Close() override {
		if (fd_ >= 0) {
			::close(fd_);
			fd_ = -1;
		}
	}

	TunReadResult ReadPacket(TunReadPacket& packet) override {
		ResetReadPacket(packet);
		if (fd_ < 0) {
			return TunReadResult::Closed;
		}

		struct pollfd pfd {};
		pfd.fd = fd_;
		pfd.events = POLLIN;

		const int ret = ::poll(&pfd, 1, kReadTimeoutMs);
		if (ret < 0) {
			if (errno == EINTR) {
				return TunReadResult::NoPacket;
			}
			Log(LogLevel::Error,
				std::string("poll() on TUN fd failed: ") + std::strerror(errno));
			return TunReadResult::Error;
		}
		if (ret == 0) {
			return TunReadResult::NoPacket;
		}
		if ((pfd.revents & (POLLHUP | POLLNVAL)) != 0) {
			return TunReadResult::Closed;
		}

		const ssize_t n = ::read(fd_, readBuffer_.data(), readBuffer_.size());
		if (n < 0) {
			// poll() can produce spurious POLLIN on some kernels; treat
			// EAGAIN / EWOULDBLOCK as a soft timeout rather than a fatal error.
			if (errno == EAGAIN || errno == EWOULDBLOCK) {
				return TunReadResult::NoPacket;
			}
			Log(LogLevel::Error,
				std::string("read() from TUN fd failed: ") + std::strerror(errno));
			return TunReadResult::Error;
		}
		if (n == 0) {
			return TunReadResult::Closed;
		}
		SetReadPacket(packet, readBuffer_.data(), static_cast<size_t>(n));
		return TunReadResult::Packet;
	}

	TunWriteResult WritePacket(const uint8_t* data, size_t len) override {
		if (fd_ < 0) {
			return TunWriteResult::Closed;
		}
		const ssize_t n = ::write(fd_, data, len);
		if (n < 0) {
			if (errno == EBADF || errno == ENODEV || errno == EIO) {
				return TunWriteResult::Closed;
			}
			Log(LogLevel::Error,
				std::string("write() to TUN fd failed: ") + std::strerror(errno));
			return TunWriteResult::Error;
		}
		// TUN writes are atomic (one write = one IP packet), but guard against
		// the unexpected case of a partial write.
		if (static_cast<size_t>(n) != len) {
			Log(LogLevel::Error,
				"write() to TUN fd: partial write, expected="
				+ std::to_string(len) + " got=" + std::to_string(n));
			return TunWriteResult::Error;
		}
		return TunWriteResult::Written;
	}

protected:
	void ReleaseReadPacket(const uint8_t*) override {}

private:
	int fd_ = -1;
	std::array<uint8_t, kMaxIpPacketSize> readBuffer_{};
};

TunAdapter* TunAdapter::Create() {
	return new LinuxTunAdapter();
}