From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-qk1-f172.google.com (mail-qk1-f172.google.com [209.85.222.172]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5C4F52E6CA8 for ; Wed, 25 Mar 2026 03:49:36 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.222.172 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1774410578; cv=none; b=bSLLIkVJhZ2FWzJK3OMkbE2niSLuPhiHHbrbBNDxIw47LuBgoNtuxqsTF+e/Htv2oLJDYE4fyWo/2Os9CgkPEbgFJbkn2obOtqgbZ1Qu6ZodhjfSAHwGPV+JZwVyke2k7ZfdEvq8lGFeZrH8iYBOHW3ptBJuPLdb1BjVdpP7TQA= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1774410578; c=relaxed/simple; bh=rhjbKjEvvRhLjKryPEE4IvivX2Rr4p7qqUaV4q7ntzk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=jXRrhcoluH9eyF3H8/bq63F/evSXgTfH2uzXZqEwR7VEl8JnaZy4S7RP1aXeM/Ab9w7pp2omss8EvsnW9OTRX6l1fQtR5NJ9SpvyxhiVrRYXMcQ2sPvi0owpz0jSzB58XCNmW1EGjHSiDo/sYyKCweIAbv1EnRHXxu5jhpBNzNc= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=s6UPhXLK; arc=none smtp.client-ip=209.85.222.172 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="s6UPhXLK" Received: by mail-qk1-f172.google.com with SMTP id af79cd13be357-8cb4136d865so595322585a.1 for ; Tue, 24 Mar 2026 20:49:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1774410575; x=1775015375; darn=lists.linux.dev; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=z7ZQtwNLmizfYWqFpNcALcDTpPpUWApC0k3x2CAc1gk=; b=s6UPhXLKWlp1Y4DLP6s5CvLu+6gJoNkFdsMisbTAVxCScW7b6uKvPRPdbk4HEBSlLs yEksbJ3+G5RQocY4NS9YB9FdyTbUXQyr/wgh/dRhh8lu4+7HngJCdKdXf3xcXBtLbyj3 gRBN9Q/WxzIjW/x9KG9T8f2HYoHdBUadyVyiCgTlS4RaVRNwom/i+hBt1WL1h7yUQfEE gwoMwAkiFnTpBciS/3T59IP1umfuyu4QNjU8/LLHdGcKT04jVxZln2w/i47coZ+DM+H3 DkcNBdqHv/a46wsmDCouulatGrBkr2Mvn40Sy90YEOyASLYd5E6DNYSSJIxQYuetybVx LICA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1774410575; x=1775015375; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=z7ZQtwNLmizfYWqFpNcALcDTpPpUWApC0k3x2CAc1gk=; b=qcWsLW36Fdw4qKe2d++Y8f4oGu5TPkqunw6vt32BOOKTkYvXuqDi0Gm44Nq3pk2gNV St2NXHDtmzOh7dCgR8XA9WLTX8FoJVxmXd26tlmPtOEmKqucdEb3psINzxHhuhZSSdJq ynako3mljuYLx97ugwxt0QZ57YmWEt7q8JD63UrIjawVrsMEV/LQxfoOmykdytj7VeVf t2qs1JwVcEfyceUH6jWLu8qm9fIxjzh+mamud5LM2X9/kxBQT3jFhFpETmHMfhDFC6UX 5yeWQK1C2wl4XhAiGJQfNIsiS6A3qKJhsXveC9K5lfmB7KGvYirfgvnC6IQzqeht7w/r fGAQ== X-Forwarded-Encrypted: i=1; AJvYcCUlxHMkuvjMeuU/tRCO4VKAPrcSyOo/LTq3hajZ+oj3iEmY8Q2HIH6bWjGehOy2c2MGbpHj@lists.linux.dev X-Gm-Message-State: AOJu0YwgfOXz7hGB1ZLkw58CKzNakaCzYSUTCerKyUFwbF3GjShoWsVL TnBIFAdbf0hMca98ovVrnX87vrCjc4No++tQZ8XReUuYPhL3cKvhU2O6 X-Gm-Gg: ATEYQzw8AeW0wBMWRIjB7Mk6TJ3UAL/xfaVO5Of8JJ1Ln7GQ0T1ydY+8xaM60w/eZr5 Zu+Xf8naIjy7cw+5K2MXjk1Rroq/6TpQlZZRP/tam3q4g7lYvhaw+hx3EkcWC2aHmKLlv72ppNA RYZqa7EhCSzTBTWxSD8FO9jC+iZ1ZPklNR8UXXCZ771WG5dqvu3GomVi6S2rlOu67WtCo3Jo9J9 O65+gJJn4wSdK0m2c3qLN8Rw1YD1rxVRMGRy5QzdyzMJAfIwihB5CysOa2i6mg0mI7QEoF8tD1s 3sf3cARVCHGInxZMwSoU3Ua2ly0rA1GGhiRhflAgQ3ziprK3bZYAOvLz7up8ETeOYnPhDJ/KJwg 23zcWG89dNlRwRDqTwdR8XFxGv5gh3pMvynHuiRKz7mWtG1z73CIb7saJiUHkzVq4y97AnGHxUt p20E2YFSOwAHResE9GliNzRlJFF4S2/B6xvFL+NIwa+2egpSYNMqj/k7Grin3J0NpRVlO57mNzl XeHspQR5QML9jJYCAmOz23b8AwS26psXTKwyMSM6oYkNQuTbyXQyljsMdIMAmWorA== X-Received: by 2002:a05:622a:164a:b0:509:4e1e:1b9a with SMTP id d75a77b69052e-50b80e45eb4mr29919321cf.54.1774410575084; Tue, 24 Mar 2026 20:49:35 -0700 (PDT) Received: from wsfd-netdev58.anl.eng.rdu2.dc.redhat.com ([66.187.232.140]) by smtp.gmail.com with ESMTPSA id d75a77b69052e-50b36cb2e29sm150093001cf.1.2026.03.24.20.49.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 24 Mar 2026 20:49:34 -0700 (PDT) From: Xin Long To: network dev , quic@lists.linux.dev Cc: davem@davemloft.net, kuba@kernel.org, Eric Dumazet , Paolo Abeni , Simon Horman , Stefan Metzmacher , Moritz Buhl , Tyler Fanelli , Pengtao He , Thomas Dreibholz , linux-cifs@vger.kernel.org, Steve French , Namjae Jeon , Paulo Alcantara , Tom Talpey , kernel-tls-handshake@lists.linux.dev, Chuck Lever , Jeff Layton , Steve Dickson , Hannes Reinecke , Alexander Aring , David Howells , Matthieu Baerts , John Ericson , Cong Wang , "D . Wythe" , Jason Baron , illiliti , Sabrina Dubroca , Marcelo Ricardo Leitner , Daniel Stenberg , Andy Gospodarek , "Marc E . Fiuczynski" Subject: [PATCH net-next v11 05/15] quic: provide quic.h header files for kernel and userspace Date: Tue, 24 Mar 2026 23:47:10 -0400 Message-ID: <734e985f1b35aa9e5c1631a6cd3bf0e760dd7699.1774410440.git.lucien.xin@gmail.com> X-Mailer: git-send-email 2.47.1 In-Reply-To: References: Precedence: bulk X-Mailing-List: quic@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit This commit adds quic.h to include/uapi/linux, providing the necessary definitions for the QUIC socket API. Exporting this header allows both user space applications and kernel subsystems to access QUIC-related control messages, socket options, and event/notification interfaces. Since kernel_get/setsockopt() is no longer available to kernel consumers, a corresponding internal header, include/linux/quic.h, is added. This exposes quic_do_get/setsockopt() to handle QUIC socket options directly for kernel subsystems. Detailed descriptions of these structures are available in [1], and will be also provided when adding corresponding socket interfaces in the later patches. [1] https://datatracker.ietf.org/doc/html/draft-lxin-quic-socket-apis Signed-off-by: Tyler Fanelli Signed-off-by: Stefan Metzmacher Signed-off-by: Thomas Dreibholz Signed-off-by: Xin Long Acked-by: Paolo Abeni --- v2: - Fix a kernel API description warning, found by Jakub. - Replace uintN_t with __uN, capitalize _UAPI_LINUX_QUIC_H, and assign explicit values for QUIC_TRANSPORT_ERROR_ enum in UAPI quic.h, suggested by David Howells. v4: - Use MSG_QUIC_ prefix for MSG_* flags to avoid conflicts with other protocols, such as MSG_NOTIFICATION in SCTP (reported by Thomas). - Remove QUIC_CONG_ALG_CUBIC; only NEW RENO congestion control is supported in this version. v5: - Add include/linux/quic.h and include/uapi/linux/quic.h to the QUIC PROTOCOL entry in MAINTAINERS. v6: - Fix the copy/pasted the uAPI path for SCTP to the QUIC entry (noted by Jakub). v7: - Expose quic_do_get/setsockopt() instead of quic_kernel_get/setsockopt() (suggested by Paolo). v10: - Fix typo: 'extented' -> 'extended' (noted by AI review). - Add comment for inclusion of sys/socket.h in uapi quic.h. - Add uses-libc += linux/quic.h in usr/include/Makefile to fix the new build error. - Delete config from struct quic_sock, its members will be split into other subcomponents in the future patches. - Add explicit reserved fields to multiple structs to account for implicit padding and ensure UAPI stability. - Expand reserved fields in struct transport_param and config, handshake and stream_info to allow future extensions without breaking the UAPI. v11: - Set maximum line length to 80 characters. - Drop trailing reserved fields in structs and rely on copy_struct_to/from_user() for extensibility; keep reserved fields in the middle to indicate memory holes. --- MAINTAINERS | 2 + include/linux/quic.h | 22 ++++ include/uapi/linux/quic.h | 237 ++++++++++++++++++++++++++++++++++++++ net/quic/socket.c | 36 +++++- net/quic/socket.h | 1 + usr/include/Makefile | 1 + 6 files changed, 295 insertions(+), 4 deletions(-) create mode 100644 include/linux/quic.h create mode 100644 include/uapi/linux/quic.h diff --git a/MAINTAINERS b/MAINTAINERS index 532030036a8c..271ddf760eb4 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -21901,6 +21901,8 @@ M: Xin Long L: quic@lists.linux.dev S: Maintained W: https://github.com/lxin/quic +F: include/linux/quic.h +F: include/uapi/linux/quic.h F: net/quic/ RADEON and AMDGPU DRM DRIVERS diff --git a/include/linux/quic.h b/include/linux/quic.h new file mode 100644 index 000000000000..4e43d20c9c11 --- /dev/null +++ b/include/linux/quic.h @@ -0,0 +1,22 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* QUIC kernel implementation + * (C) Copyright Red Hat Corp. 2023 + * + * This file is part of the QUIC kernel implementation + * + * Written or modified by: + * Xin Long + */ + +#ifndef _LINUX_QUIC_H +#define _LINUX_QUIC_H + +#include +#include + +int quic_do_setsockopt(struct sock *sk, int optname, sockptr_t optval, + unsigned int optlen); +int quic_do_getsockopt(struct sock *sk, int optname, sockptr_t optval, + sockptr_t optlen); + +#endif diff --git a/include/uapi/linux/quic.h b/include/uapi/linux/quic.h new file mode 100644 index 000000000000..92a0336b9b89 --- /dev/null +++ b/include/uapi/linux/quic.h @@ -0,0 +1,237 @@ +/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ +/* QUIC kernel implementation + * (C) Copyright Red Hat Corp. 2023 + * + * This file is part of the QUIC kernel implementation + * + * Written or modified by: + * Xin Long + */ + +#ifndef _UAPI_LINUX_QUIC_H +#define _UAPI_LINUX_QUIC_H + +#include +#ifdef __KERNEL__ +#include +#else +#include /* for MSG_* flags */ +#endif + +/* NOTE: Structure descriptions are specified in: + * https://datatracker.ietf.org/doc/html/draft-lxin-quic-socket-apis + */ + +/* Send or Receive Options APIs */ +enum quic_cmsg_type { + QUIC_STREAM_INFO, + QUIC_HANDSHAKE_INFO, +}; + +#define QUIC_STREAM_TYPE_SERVER_MASK 0x01 +#define QUIC_STREAM_TYPE_UNI_MASK 0x02 +#define QUIC_STREAM_TYPE_MASK 0x03 + +enum quic_msg_flags { + /* flags for stream_flags */ + MSG_QUIC_STREAM_NEW = MSG_SYN, + MSG_QUIC_STREAM_FIN = MSG_FIN, + MSG_QUIC_STREAM_UNI = MSG_CONFIRM, + MSG_QUIC_STREAM_DONTWAIT = MSG_WAITFORONE, + MSG_QUIC_STREAM_SNDBLOCK = MSG_ERRQUEUE, + + /* extended flags for msg_flags */ + MSG_QUIC_DATAGRAM = MSG_RST, + MSG_QUIC_NOTIFICATION = MSG_MORE, +}; + +enum quic_crypto_level { + QUIC_CRYPTO_APP, + QUIC_CRYPTO_INITIAL, + QUIC_CRYPTO_HANDSHAKE, + QUIC_CRYPTO_EARLY, + QUIC_CRYPTO_MAX, +}; + +struct quic_handshake_info { + __u8 crypto_level; +}; + +struct quic_stream_info { + __s64 stream_id; + __u32 stream_flags; +}; + +/* Socket Options APIs */ +#define QUIC_SOCKOPT_EVENT 0 +#define QUIC_SOCKOPT_STREAM_OPEN 1 +#define QUIC_SOCKOPT_STREAM_RESET 2 +#define QUIC_SOCKOPT_STREAM_STOP_SENDING 3 +#define QUIC_SOCKOPT_CONNECTION_ID 4 +#define QUIC_SOCKOPT_CONNECTION_CLOSE 5 +#define QUIC_SOCKOPT_CONNECTION_MIGRATION 6 +#define QUIC_SOCKOPT_KEY_UPDATE 7 +#define QUIC_SOCKOPT_TRANSPORT_PARAM 8 +#define QUIC_SOCKOPT_CONFIG 9 +#define QUIC_SOCKOPT_TOKEN 10 +#define QUIC_SOCKOPT_ALPN 11 +#define QUIC_SOCKOPT_SESSION_TICKET 12 +#define QUIC_SOCKOPT_CRYPTO_SECRET 13 +#define QUIC_SOCKOPT_TRANSPORT_PARAM_EXT 14 + +#define QUIC_VERSION_V1 0x1 +#define QUIC_VERSION_V2 0x6b3343cf + +struct quic_transport_param { + __u8 remote; + __u8 disable_active_migration; + __u8 grease_quic_bit; + __u8 stateless_reset; + __u8 disable_1rtt_encryption; + __u8 disable_compatible_version; + __u8 active_connection_id_limit; + __u8 ack_delay_exponent; + __u16 max_datagram_frame_size; + __u16 max_udp_payload_size; + __u32 max_idle_timeout; + __u32 max_ack_delay; + __u16 max_streams_bidi; + __u16 max_streams_uni; + __u64 max_data; + __u64 max_stream_data_bidi_local; + __u64 max_stream_data_bidi_remote; + __u64 max_stream_data_uni; +}; + +struct quic_config { + __u32 version; + __u32 plpmtud_probe_interval; + __u32 initial_smoothed_rtt; + __u32 payload_cipher_type; + __u8 congestion_control_algo; + __u8 validate_peer_address; + __u8 stream_data_nodelay; + __u8 receive_session_ticket; + __u8 certificate_request; +}; + +struct quic_crypto_secret { + __u8 send; /* send or recv */ + __u8 level; /* crypto level */ + __u16 reserved; + __u32 type; /* TLS_CIPHER_* */ +#define QUIC_CRYPTO_SECRET_BUFFER_SIZE 48 + __u8 secret[QUIC_CRYPTO_SECRET_BUFFER_SIZE]; +}; + +enum quic_cong_algo { + QUIC_CONG_ALG_RENO, + QUIC_CONG_ALG_MAX, +}; + +struct quic_errinfo { + __s64 stream_id; + __u32 errcode; +}; + +struct quic_connection_id_info { + __u8 dest; + __u8 reserved[3]; + __u32 active; + __u32 prior_to; +}; + +struct quic_event_option { + __u8 type; + __u8 on; +}; + +/* Event APIs */ +enum quic_event_type { + QUIC_EVENT_NONE, + QUIC_EVENT_STREAM_UPDATE, + QUIC_EVENT_STREAM_MAX_DATA, + QUIC_EVENT_STREAM_MAX_STREAM, + QUIC_EVENT_CONNECTION_ID, + QUIC_EVENT_CONNECTION_CLOSE, + QUIC_EVENT_CONNECTION_MIGRATION, + QUIC_EVENT_KEY_UPDATE, + QUIC_EVENT_NEW_TOKEN, + QUIC_EVENT_NEW_SESSION_TICKET, + QUIC_EVENT_MAX, +}; + +enum { + QUIC_STREAM_SEND_STATE_READY, + QUIC_STREAM_SEND_STATE_SEND, + QUIC_STREAM_SEND_STATE_SENT, + QUIC_STREAM_SEND_STATE_RECVD, + QUIC_STREAM_SEND_STATE_RESET_SENT, + QUIC_STREAM_SEND_STATE_RESET_RECVD, + + QUIC_STREAM_RECV_STATE_RECV, + QUIC_STREAM_RECV_STATE_SIZE_KNOWN, + QUIC_STREAM_RECV_STATE_RECVD, + QUIC_STREAM_RECV_STATE_READ, + QUIC_STREAM_RECV_STATE_RESET_RECVD, + QUIC_STREAM_RECV_STATE_RESET_READ, +}; + +struct quic_stream_update { + __s64 id; + __u8 state; + __u8 reserved[3]; + __u32 errcode; + __u64 finalsz; +}; + +struct quic_stream_max_data { + __s64 id; + __u64 max_data; +}; + +struct quic_connection_close { + __u32 errcode; + __u8 frame; + __u8 reserved[3]; + __u8 phrase[]; +}; + +union quic_event { + struct quic_stream_update update; + struct quic_stream_max_data max_data; + struct quic_connection_close close; + struct quic_connection_id_info info; + __u64 max_stream; + __u8 local_migration; + __u8 key_update_phase; +}; + +enum { + QUIC_TRANSPORT_ERROR_NONE = 0x00, + QUIC_TRANSPORT_ERROR_INTERNAL = 0x01, + QUIC_TRANSPORT_ERROR_CONNECTION_REFUSED = 0x02, + QUIC_TRANSPORT_ERROR_FLOW_CONTROL = 0x03, + QUIC_TRANSPORT_ERROR_STREAM_LIMIT = 0x04, + QUIC_TRANSPORT_ERROR_STREAM_STATE = 0x05, + QUIC_TRANSPORT_ERROR_FINAL_SIZE = 0x06, + QUIC_TRANSPORT_ERROR_FRAME_ENCODING = 0x07, + QUIC_TRANSPORT_ERROR_TRANSPORT_PARAM = 0x08, + QUIC_TRANSPORT_ERROR_CONNECTION_ID_LIMIT = 0x09, + QUIC_TRANSPORT_ERROR_PROTOCOL_VIOLATION = 0x0a, + QUIC_TRANSPORT_ERROR_INVALID_TOKEN = 0x0b, + QUIC_TRANSPORT_ERROR_APPLICATION = 0x0c, + QUIC_TRANSPORT_ERROR_CRYPTO_BUF_EXCEEDED = 0x0d, + QUIC_TRANSPORT_ERROR_KEY_UPDATE = 0x0e, + QUIC_TRANSPORT_ERROR_AEAD_LIMIT_REACHED = 0x0f, + QUIC_TRANSPORT_ERROR_NO_VIABLE_PATH = 0x10, + + /* The cryptographic handshake failed. A range of 256 values is reserved + * for carrying error codes specific to the cryptographic handshake that + * is used. Codes for errors occurring when TLS is used for the + * cryptographic handshake are described in Section 4.8 of [QUIC-TLS]. + */ + QUIC_TRANSPORT_ERROR_CRYPTO = 0x0100, +}; + +#endif /* _UAPI_LINUX_QUIC_H */ diff --git a/net/quic/socket.c b/net/quic/socket.c index f1181215ebbf..8dc2cb7628db 100644 --- a/net/quic/socket.c +++ b/net/quic/socket.c @@ -107,11 +107,25 @@ static void quic_close(struct sock *sk, long timeout) sk_common_release(sk); } -static int quic_do_setsockopt(struct sock *sk, int optname, sockptr_t optval, - unsigned int optlen) +/** + * quic_do_setsockopt - set a QUIC socket option + * @sk: socket to configure + * @optname: option name (QUIC-level) + * @optval: user buffer containing the option value + * @optlen: size of the option value + * + * Sets a QUIC socket option on a given socket. + * + * Return: + * - On success, 0 is returned. + * - On error, a negative error value is returned. + */ +int quic_do_setsockopt(struct sock *sk, int optname, sockptr_t optval, + unsigned int optlen) { return -EOPNOTSUPP; } +EXPORT_SYMBOL_GPL(quic_do_setsockopt); static int quic_setsockopt(struct sock *sk, int level, int optname, sockptr_t optval, unsigned int optlen) @@ -123,11 +137,25 @@ static int quic_setsockopt(struct sock *sk, int level, int optname, return quic_do_setsockopt(sk, optname, optval, optlen); } -static int quic_do_getsockopt(struct sock *sk, int optname, sockptr_t optval, - sockptr_t optlen) +/** + * quic_do_getsockopt - get a QUIC socket option + * @sk: socket to query + * @optname: option name (QUIC-level) + * @optval: user buffer to receive the option value + * @optlen: pointer to buffer size; updated with actual size on return + * + * Gets a QUIC socket option from a given socket. + * + * Return: + * - On success, 0 is returned. + * - On error, a negative error value is returned. + */ +int quic_do_getsockopt(struct sock *sk, int optname, sockptr_t optval, + sockptr_t optlen) { return -EOPNOTSUPP; } +EXPORT_SYMBOL_GPL(quic_do_getsockopt); static int quic_getsockopt(struct sock *sk, int level, int optname, char __user *optval, int __user *optlen) diff --git a/net/quic/socket.h b/net/quic/socket.h index 0aa642e3b0ae..61df0c5867be 100644 --- a/net/quic/socket.h +++ b/net/quic/socket.h @@ -9,6 +9,7 @@ */ #include +#include #include "common.h" #include "family.h" diff --git a/usr/include/Makefile b/usr/include/Makefile index 6d86a53c6f0a..a0442e4d77da 100644 --- a/usr/include/Makefile +++ b/usr/include/Makefile @@ -120,6 +120,7 @@ uses-libc += linux/netfilter_ipv4.h uses-libc += linux/netfilter_ipv4/ip_tables.h uses-libc += linux/netfilter_ipv6.h uses-libc += linux/netfilter_ipv6/ip6_tables.h +uses-libc += linux/quic.h uses-libc += linux/route.h uses-libc += linux/shm.h uses-libc += linux/soundcard.h -- 2.47.1