xref: /xnu-12377.81.4/tests/tcp_cache_test.c (revision 043036a2b3718f7f0be807e2870f8f47d3fa0796)

/*
 * Copyright (c) 2025 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */

#include <darwintest.h>
#include <sys/sysctl.h>
#include <netinet/tcp_cache.h>
#include <arpa/inet.h>
#include <stdlib.h>

T_DECL(tcp_cache_list_sysctl, "Test retrieving TCP cache list via sysctl")
{
	size_t size = 0;
	int ret;

	// First call to get the required buffer size
	ret = sysctlbyname("net.inet.tcp.cache_list", NULL, &size, NULL, 0);
	if (ret == -1) {
		T_SKIP("sysctlbyname(\"net.inet.tcp.cache_list\") error: %d", errno);
	}

	T_LOG("TCP cache list size: %zu bytes", size);

	if (size == 0) {
		T_PASS("No TCP cache entries found");
	}

	// Allocate buffer and retrieve the data
	void *buffer = malloc(size);
	T_QUIET; T_ASSERT_NOTNULL(buffer, "malloc buffer");

	ret = sysctlbyname("net.inet.tcp.cache_list", buffer, &size, NULL, 0);
	T_ASSERT_POSIX_SUCCESS(ret, "sysctlbyname to get data");

	// Calculate number of entries
	size_t num_entries = size / sizeof(struct tcp_cache_data);
	T_LOG("Found %zu TCP cache entries", num_entries);

	struct tcp_cache_data *entries = (struct tcp_cache_data *)buffer;

	// Log all fields of each entry
	for (size_t i = 0; i < num_entries; i++) {
		struct tcp_cache_data *entry = &entries[i];

		T_LOG("Entry %zu:", i);
		T_LOG("  tc_last_access: %u", entry->tc_last_access);
		T_LOG("  tc_key.tck_family: %d", entry->tc_key.tck_family);

		// Log source key info
		T_LOG("  tc_key.tck_src.thk_family: %d", entry->tc_key.tck_src.thk_family);
		if (entry->tc_key.tck_src.thk_family == AF_INET) {
			T_LOG("  tc_key.tck_src IP: %s", inet_ntoa(entry->tc_key.tck_src.thk_ip.addr));
		} else if (entry->tc_key.tck_src.thk_family == AF_INET6) {
			char addr_str[INET6_ADDRSTRLEN];
			inet_ntop(AF_INET6, &entry->tc_key.tck_src.thk_ip.addr6, addr_str, sizeof(addr_str));
			T_LOG("  tc_key.tck_src IPv6: %s", addr_str);
		}

		// Log destination address
		if (entry->tc_key.tck_family == AF_INET) {
			T_LOG("  tc_key.tck_dst IP: %s", inet_ntoa(entry->tc_key.tck_dst.addr));
		} else if (entry->tc_key.tck_family == AF_INET6) {
			char addr_str[INET6_ADDRSTRLEN];
			inet_ntop(AF_INET6, &entry->tc_key.tck_dst.addr6, addr_str, sizeof(addr_str));
			T_LOG("  tc_key.tck_dst IPv6: %s", addr_str);
		}

		// Log TFO cookie info
		T_LOG("  tc_tfo_cookie_len: %u", entry->tc_tfo_cookie_len);
		if (entry->tc_tfo_cookie_len > 0) {
			char cookie_hex[TFO_COOKIE_LEN_MAX * 2 + 1] = {0};
			for (int j = 0; j < entry->tc_tfo_cookie_len && j < TFO_COOKIE_LEN_MAX; j++) {
				snprintf(cookie_hex + j * 2, 3, "%02x", entry->tc_tfo_cookie[j]);
			}
			T_LOG("  tc_tfo_cookie: %s", cookie_hex);
		}

		// Log MPTCP info
		T_LOG("  tc_mptcp_version_confirmed: %u", entry->tc_mptcp_version_confirmed);
		T_LOG("  tc_mptcp_version: %u", entry->tc_mptcp_version);
		T_LOG("  tc_mptcp_next_version_try: %u", entry->tc_mptcp_next_version_try);
		T_LOG(""); // Empty line between entries
	}

	free(buffer);

	T_PASS("%s", __func__);
}

T_DECL(tcp_heuristics_list_sysctl, "Test retrieving TCP heuristics list via sysctl")
{
	size_t size = 0;
	int ret;

	// First call to get the required buffer size
	ret = sysctlbyname("net.inet.tcp.heuristics_list", NULL, &size, NULL, 0);
	if (ret == -1) {
		T_SKIP("sysctlbyname(\"net.inet.tcp.cache_list\") error: %d", errno);
	}

	T_LOG("TCP heuristics list size: %zu bytes", size);

	if (size == 0) {
		T_PASS("No TCP heuristics entries found");
	}

	// Allocate buffer and retrieve the data
	void *buffer = malloc(size);
	T_QUIET; T_ASSERT_NOTNULL(buffer, "malloc buffer");

	ret = sysctlbyname("net.inet.tcp.heuristics_list", buffer, &size, NULL, 0);
	T_ASSERT_POSIX_SUCCESS(ret, "sysctlbyname to get data");

	// Calculate number of entries
	size_t num_entries = size / sizeof(struct tcp_heuristics_data);
	T_LOG("Found %zu TCP heuristics entries", num_entries);

	struct tcp_heuristics_data *entries = (struct tcp_heuristics_data *)buffer;

	// Log all fields of each entry
	for (size_t i = 0; i < num_entries; i++) {
		struct tcp_heuristics_data *entry = &entries[i];

		T_LOG("Heuristics Entry %zu:", i);
		T_LOG("  th_last_access: %u", entry->th_last_access);
		T_LOG("  th_key.thk_family: %d", entry->th_key.thk_family);

		// Log source key info
		if (entry->th_key.thk_family == AF_INET) {
			T_LOG("  th_key.thk_ip IP: %s", inet_ntoa(entry->th_key.thk_ip.addr));
		} else if (entry->th_key.thk_family == AF_INET6) {
			char addr_str[INET6_ADDRSTRLEN];
			inet_ntop(AF_INET6, &entry->th_key.thk_ip.addr6, addr_str, sizeof(addr_str));
			T_LOG("  th_key.thk_ip IPv6: %s", addr_str);
		}

		// Log TFO heuristics
		T_LOG("  th_tfo_data_loss: %u", entry->th_tfo_data_loss);
		T_LOG("  th_tfo_req_loss: %u", entry->th_tfo_req_loss);
		T_LOG("  th_tfo_data_rst: %u", entry->th_tfo_data_rst);


		T_LOG("  th_tfo_req_rst: %u", entry->th_tfo_req_rst);

		// Log MPTCP heuristics
		T_LOG("  th_mptcp_loss: %u", entry->th_mptcp_loss);
		T_LOG("  th_mptcp_success: %u", entry->th_mptcp_success);

		// Log ECN heuristics
		T_LOG("  th_ecn_droprst: %u", entry->th_ecn_droprst);
		T_LOG("  th_ecn_synrst: %u", entry->th_ecn_synrst);

		// Log timing information
		T_LOG("  th_tfo_enabled_time: %u", entry->th_tfo_enabled_time);
		T_LOG("  th_tfo_backoff_until: %u", entry->th_tfo_backoff_until);
		T_LOG("  th_tfo_backoff: %u", entry->th_tfo_backoff);
		T_LOG("  th_mptcp_backoff: %u", entry->th_mptcp_backoff);
		T_LOG("  th_ecn_backoff: %u", entry->th_ecn_backoff);

		// Log flags
		T_LOG("  th_tfo_in_backoff: %u", entry->th_tfo_in_backoff);
		T_LOG("  th_mptcp_in_backoff: %u", entry->th_mptcp_in_backoff);
		T_LOG("  th_mptcp_heuristic_disabled: %u", entry->th_mptcp_heuristic_disabled);
		T_LOG(""); // Empty line between entries
	}

	free(buffer);

	T_PASS("%s", __func__);
}