feat(tcp): source TCP buffer defaults from tcp.rmem/wmem.default (autotune step 5)

Fifth phase of the Tier-3 buffer auto-tuning plan
(docs/refactor/tcp_buffer_autotuning.md §2/§7/§10 step 5). Wire a TCP
socket's unset receive-window seed and send-buffer floor to the
tcp.rmem.default / tcp.wmem.default sysctls (Linux tcp_rmem[1] /
tcp_wmem[1]), giving the step-1 .default knobs live consumers and making
the TCP starting buffers operator-tunable.

Deliberately conservative: rather than adopting Linux's small initial
values (which would make auto-tuning immediately visible but change every
unset-buffer connection's start point), this keeps PyTCP's conservative
65535 / 212992 defaults and only re-sources them. The shipped knob values
equal the old constants, so there is ZERO behaviour change and no test
churn; an operator who wants Linux-style small-start-plus-autotune sets
'sysctl tcp.wmem.default=16384' with no code change.

Mechanism — a template-method seam on the base socket:
- socket._default_sndbuf() / _default_rcvbuf() return the generic
  SOCKET__SO_{SND,RCV}BUF__DEFAULT (Linux net.core.{w,r}mem_default), the
  datagram default; _effective_sndbuf() / _effective_rcvbuf() now call
  through them.
- TcpSocket overrides both to return tcp__constants.TCP__WMEM__DEFAULT /
  TCP__RMEM__DEFAULT via qualified module access (live sysctl value).

The TcpSession rcv_wnd_max seed already reads _effective_rcvbuf(), so it
picks up tcp.rmem.default automatically; datagram sockets keep the
net.core stand-ins (matching Linux, where datagram and TCP defaults are
distinct sysctls).

Tests-first: test__tcp__session__buffer_defaults.py (5 cases — rcv/snd
defaults keep 65535/212992, operator override of each raises the
seed/floor, datagram sockets unaffected by the TCP knobs). RED pre-impl:
the two operator-override cases fail (seed/floor hardcoded to the
SOCKET__ constants); the three regression guards pass pre- and post-impl.
Plan §2/§7/§10 step 5 marked done (revised to the conservative decision).

Reference: RFC 9293 §3.8.6 (receive window management).
Reference: RFC 9293 §3.9 (SEND — send-buffer flow control).
Reference: Linux net.ipv4.tcp_rmem[1] / tcp_wmem[1].

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ccie18643

docs/refactor/tcp_buffer_autotuning.md

@@ -350,13 +350,17 @@ Original plan text:
   by the same ACK's `_wake_sndbuf_waiters()`, then re-reads the widened
   `_effective_sndbuf()`.
 
-### S3 — pairing with the small initial default (see §2 / §7)
-
-Only meaningful once the Tier-2 `tcp.wmem` triple lands and the unset
-send default drops to `tcp.wmem.default` (small). Until then S2 grows
-only above 208 KiB (near-inert). Land S1/S2 behind the Tier-2 default
-switch, or ship S with the default-switch in the same series so the
-behaviour is observable.
+### S3 — pairing with the initial default (see §2 / §7)
+
+**Resolved conservatively (step 5).** The unset send floor is now sourced
+from `tcp.wmem.default` (via the `TcpSocket._default_sndbuf()` override),
+but the shipped value stays PyTCP's conservative 208 KiB rather than
+Linux's small 16 KiB. So S2 remains near-inert on the common path (it
+grows only once `2*cwnd*mss` exceeds 208 KiB) — a deliberate trade: no
+per-connection behaviour change, and an operator who wants Linux-style
+small-start-plus-autotune sets `tcp.wmem.default=16384` with no code
+change. Send auto-tuning is fully *functional*; whether it is *visible*
+on a given connection is now an operator knob.
 
 ## 6. Sysctl knobs (registered as part of this work)
 
@@ -381,10 +385,16 @@ means **Track R/S subsumes that slice of Tier-2**. Keep them flat (not
 
 ## 7. Decisions to lock
 
-- **Pair Track S with the small-default switch (§2).** Send auto-tuning
-  against the 208 KiB static default is cosmetic. Ship S2 together with
-  adopting `tcp.wmem.default` as the unset send bound, or the track
-  delivers no observable parity.
+- **Default sourcing over default *value* (§2, revised at step 5).** The
+  original decision was to pair Track S with adopting Linux's *small*
+  send default so auto-tuning is immediately visible. The project instead
+  chose to **keep PyTCP's conservative 208 KiB / 65535 defaults** and
+  only re-source them from `tcp.wmem.default` / `tcp.rmem.default`
+  (operator-tunable). Rationale: zero per-connection behaviour change and
+  no test churn, while still giving the `.default` knobs live consumers —
+  the Linux small-start behaviour is one `sysctl` away with no code.
+  Send auto-tuning is therefore near-inert on the common path by design,
+  not by omission.
 - **DRS is timestamps-gated for the first pass (R1).** The receiver RTT
   estimator uses the RFC 7323 TSecr echo. The no-timestamps
   `tcp_rcv_rtt_measure` fallback is a documented follow-on, not first-pass
@@ -537,10 +547,23 @@ CLAUDE.md "Linux as tiebreaker" precedence.
    `test__tcp__session__drs.py`. **DRS is functionally complete** (still
    inert on the common path until step 5 raises throughput enough to
    grow, but it fires whenever per-RTT throughput exceeds the window).
-5. **The small-default switch** (§2 / §7) — flip the unset `SO_SNDBUF`
-   (and optionally `rcv_wnd_max`) default to the Tier-2 `.default`,
-   making auto-tuning observable. Behaviour-changing → its own deliberate
-   commit with the test-churn it implies.
+5. **The default-sourcing switch** (§2 / §7) — **DONE, but conservative
+   by decision.** Rather than dropping to Linux's *small* initial values
+   (which would have made auto-tuning immediately observable at the cost
+   of changing every unset-buffer connection's start point), the project
+   chose to **keep PyTCP's conservative 65535 / 212992 defaults** and
+   only re-source them from the `tcp.rmem.default` / `tcp.wmem.default`
+   sysctls. A `_default_rcvbuf()` / `_default_sndbuf()` template method
+   on the base socket (generic `net.core.*_default`) is overridden by
+   `TcpSocket` (`tcp_rmem[1]` / `tcp_wmem[1]`), so `_effective_rcvbuf()`
+   / `_effective_sndbuf()` — and thus the `rcv_wnd_max` seed and the TCP
+   send floor — become operator-tunable with **zero behaviour change**
+   (the shipped knob values equal the old constants). This gives the
+   `.default` knobs live consumers and completes the Linux default
+   sourcing; adopting the small values remains available as a pure
+   sysctl override (`sysctl tcp.wmem.default=16384`) with no further
+   code. Tests: `test__tcp__session__buffer_defaults.py`. **No test
+   churn** — values unchanged.
 6. **R0 / no-TS fallback** — optional follow-ons, only if a consumer needs
    >8 MiB windows or DRS on non-timestamped connections.
 

packages/pytcp/pytcp/runtime/socket/__init__.py

@@ -1447,20 +1447,42 @@ def _multicast_send_suppressed(self, remote_ip_address: Ip4Address | Ip6Address,
 
         return remote_ip_address.is_multicast and self._effective_ip_ttl(remote_ip_address) == 0
 
+    def _default_sndbuf(self) -> int:
+        """
+        Get the unset-SO_SNDBUF send-buffer default. The base value is
+        the 'SOCKET__SO_SNDBUF__DEFAULT' stand-in for Linux
+        'net.core.wmem_default' — the datagram default. 'TcpSocket'
+        overrides this to the operator-tunable 'tcp.wmem.default'
+        (Linux 'tcp_wmem[1]').
+        """
+
+        return SOCKET__SO_SNDBUF__DEFAULT
+
+    def _default_rcvbuf(self) -> int:
+        """
+        Get the unset-SO_RCVBUF receive-buffer default. The base value
+        is the 'SOCKET__SO_RCVBUF__DEFAULT' stand-in for Linux
+        'net.core.rmem_default' — the datagram default. 'TcpSocket'
+        overrides this to the operator-tunable 'tcp.rmem.default'
+        (Linux 'tcp_rmem[1]').
+        """
+
+        return SOCKET__SO_RCVBUF__DEFAULT
+
     def _effective_sndbuf(self) -> int:
         """
         Get the SO_SNDBUF send-buffer bound. An explicit application
         value (SOCK_SNDBUF_LOCK) always wins and pins the bound. When
-        unset, the bound is the larger of the 'SOCKET__SO_SNDBUF__DEFAULT'
-        stand-in (Linux 'net.core.wmem_default') and the TCP
-        auto-tuning bound '_sndbuf_auto' (Tier-3 Track S; 0 for
-        datagram sockets, so their bound is the static default). PyTCP
-        does not apply Linux's 2x doubling of the requested value.
+        unset, the bound is the larger of '_default_sndbuf()' (the
+        per-flavour default — 'net.core.wmem_default' for datagram
+        sockets, 'tcp.wmem.default' for TCP) and the TCP auto-tuning
+        bound '_sndbuf_auto' (Tier-3 Track S; 0 for datagram sockets).
+        PyTCP does not apply Linux's 2x doubling of the requested value.
         """
 
         if self._so_sndbuf is not None:
             return self._so_sndbuf
-        return max(SOCKET__SO_SNDBUF__DEFAULT, self._sndbuf_auto)
+        return max(self._default_sndbuf(), self._sndbuf_auto)
 
     def _grow_sndbuf_auto(self, target: int, /) -> None:
         """
@@ -1476,13 +1498,14 @@ def _grow_sndbuf_auto(self, target: int, /) -> None:
     def _effective_rcvbuf(self) -> int:
         """
         Get the SO_RCVBUF receive-buffer size: the value the
-        application set, else the 'SOCKET__SO_RCVBUF__DEFAULT'
-        stand-in for Linux 'net.core.rmem_default'. The TCP advertised
-        receive window and the datagram RX-drop cap derive from this;
-        PyTCP does not apply Linux's 2x doubling of the requested value.
+        application set, else '_default_rcvbuf()' (the per-flavour
+        default — 'net.core.rmem_default' for datagram sockets,
+        'tcp.rmem.default' for TCP). The TCP advertised receive window
+        and the datagram RX-drop cap derive from this; PyTCP does not
+        apply Linux's 2x doubling of the requested value.
         """
 
-        return self._so_rcvbuf if self._so_rcvbuf is not None else SOCKET__SO_RCVBUF__DEFAULT
+        return self._so_rcvbuf if self._so_rcvbuf is not None else self._default_rcvbuf()
 
     def _charge_sndbuf(self, nbytes: int, /) -> None:
         """

packages/pytcp/pytcp/runtime/socket/tcp__socket.py

@@ -50,6 +50,7 @@
 from net_proto.lib.proto_enum import ProtoEnum
 from pytcp import stack
 from pytcp.lib.logger import log
+from pytcp.protocols.tcp import tcp__constants
 from pytcp.protocols.tcp.session import TcpSession
 from pytcp.protocols.tcp.tcp__enums import CcMode, FsmState
 from pytcp.protocols.tcp.tcp__errors import TcpSessionError
@@ -286,6 +287,29 @@ def parent_socket(self) -> TcpSocket | None:
 
         return self._parent_socket
 
+    @override
+    def _default_sndbuf(self) -> int:
+        """
+        Get the unset-SO_SNDBUF send-buffer default for TCP: the
+        operator-tunable 'tcp.wmem.default' (Linux 'tcp_wmem[1]'),
+        distinct from the datagram 'net.core.wmem_default'. Read via
+        qualified module access so a runtime sysctl override is picked
+        up live.
+        """
+
+        return tcp__constants.TCP__WMEM__DEFAULT
+
+    @override
+    def _default_rcvbuf(self) -> int:
+        """
+        Get the unset-SO_RCVBUF receive-buffer default for TCP: the
+        operator-tunable 'tcp.rmem.default' (Linux 'tcp_rmem[1]'),
+        distinct from the datagram 'net.core.rmem_default'. Seeds the
+        advertised-window cap ('rcv_wnd_max') at session construction.
+        """
+
+        return tcp__constants.TCP__RMEM__DEFAULT
+
     def status(self) -> TcpStatus:
         """
         Return a read-only snapshot of the connection's

packages/pytcp/pytcp/tests/integration/protocols/tcp/test__tcp__session__buffer_defaults.py

@@ -0,0 +1,176 @@
+################################################################################
+##                                                                            ##
+##   PyTCP - Python TCP/IP stack                                              ##
+##   Copyright (C) 2020-present Sebastian Majewski                            ##
+##                                                                            ##
+##   This program is free software: you can redistribute it and/or modify     ##
+##   it under the terms of the GNU General Public License as published by     ##
+##   the Free Software Foundation, either version 3 of the License, or        ##
+##   (at your option) any later version.                                      ##
+##                                                                            ##
+##   This program is distributed in the hope that it will be useful,          ##
+##   but WITHOUT ANY WARRANTY; without even the implied warranty of           ##
+##   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the             ##
+##   GNU General Public License for more details.                             ##
+##                                                                            ##
+##   You should have received a copy of the GNU General Public License        ##
+##   along with this program. If not, see <https://www.gnu.org/licenses/>.    ##
+##                                                                            ##
+##   Author's email: ccie18643@gmail.com                                      ##
+##   Github repository: https://github.com/ccie18643/PyTCP                    ##
+##                                                                            ##
+################################################################################
+
+
+# pylint: disable=protected-access
+# pyright: reportPrivateUsage=false
+
+
+"""
+Integration tests for the TCP buffer-default sourcing (Tier-3 Track R/S,
+step 5). A TCP socket's unset receive-window seed and send-buffer floor
+come from the 'tcp.rmem.default' / 'tcp.wmem.default' sysctls (Linux
+'tcp_rmem[1]' / 'tcp_wmem[1]'), so they are operator-tunable — while a
+datagram socket keeps the generic 'net.core.*_default' stand-ins. The
+shipped defaults keep PyTCP's conservative 65535 / 212992 values, so this
+changes no behaviour; it only makes the starting points configurable and
+gives the registered '.default' knobs live consumers.
+
+pytcp/tests/integration/protocols/tcp/test__tcp__session__buffer_defaults.py
+
+ver 3.0.8
+"""
+
+from typing import override
+
+from pytcp.runtime.socket import (
+    SOCKET__SO_RCVBUF__DEFAULT,
+    SOCKET__SO_SNDBUF__DEFAULT,
+    AddressFamily,
+)
+from pytcp.runtime.socket.udp__socket import UdpSocket
+from pytcp.stack import sysctl as sysctl_module
+from pytcp.tests.lib.tcp_testcase import TcpTestCase
+
+
+class TestTcpSessionBufferDefaults(TcpTestCase):
+    """
+    The TCP buffer-default sourcing tests.
+    """
+
+    @override
+    def tearDown(self) -> None:
+        """
+        Restore any sysctl overridden by an operator-override test so
+        the mutation cannot leak into a sibling test.
+        """
+
+        sysctl_module.reset_to_defaults()
+        super().tearDown()
+
+    def test__rcv_default__seeds_rcv_wnd_max_from_tcp_rmem_default(self) -> None:
+        """
+        Ensure a fresh session with no SO_RCVBUF seeds its advertised
+        receive-window cap from 'tcp.rmem.default' — the shipped value
+        keeps the conservative 65535.
+
+        Reference: RFC 9293 §3.8.6 (receive window management).
+        Reference: Linux net.ipv4.tcp_rmem[1] (default receive window).
+        """
+
+        session = self._make_active_session(iss=1000)
+        self.assertEqual(
+            session.rcv_wnd_max,
+            sysctl_module.get("tcp.rmem.default"),
+            msg="rcv_wnd_max must seed from tcp.rmem.default.",
+        )
+        self.assertEqual(
+            session.rcv_wnd_max,
+            65535,
+            msg="The shipped tcp.rmem.default must keep the conservative 65535.",
+        )
+
+    def test__rcv_default__operator_override_raises_seed(self) -> None:
+        """
+        Ensure raising 'tcp.rmem.default' raises the advertised-window
+        seed of a subsequently-opened session, so the starting window
+        is operator-tunable.
+
+        Reference: RFC 9293 §3.8.6 (receive window management).
+        Reference: Linux net.ipv4.tcp_rmem[1] (operator-tunable default).
+        """
+
+        sysctl_module.set("tcp.rmem.default", 131072)
+        session = self._make_active_session(iss=1000)
+        self.assertEqual(
+            session.rcv_wnd_max,
+            131072,
+            msg="A raised tcp.rmem.default must seed a larger rcv_wnd_max.",
+        )
+
+    def test__snd_default__effective_sndbuf_from_tcp_wmem_default(self) -> None:
+        """
+        Ensure a fresh TCP socket with no SO_SNDBUF reports a
+        send-buffer floor from 'tcp.wmem.default' — the shipped value
+        keeps the conservative 212992.
+
+        Reference: RFC 9293 §3.9 (SEND — send-buffer flow control).
+        Reference: Linux net.ipv4.tcp_wmem[1] (default send buffer).
+        """
+
+        session = self._make_active_session(iss=1000)
+        self.assertEqual(
+            session._socket._effective_sndbuf(),
+            sysctl_module.get("tcp.wmem.default"),
+            msg="The TCP send-buffer floor must come from tcp.wmem.default.",
+        )
+        self.assertEqual(
+            session._socket._effective_sndbuf(),
+            212992,
+            msg="The shipped tcp.wmem.default must keep the conservative 212992.",
+        )
+
+    def test__snd_default__operator_override_raises_floor(self) -> None:
+        """
+        Ensure raising 'tcp.wmem.default' raises the TCP send-buffer
+        floor, so the starting send bound is operator-tunable.
+
+        Reference: RFC 9293 §3.9 (SEND — send-buffer flow control).
+        Reference: Linux net.ipv4.tcp_wmem[1] (operator-tunable default).
+        """
+
+        session = self._make_active_session(iss=1000)
+        sysctl_module.set("tcp.wmem.default", 300000)
+        self.assertEqual(
+            session._socket._effective_sndbuf(),
+            300000,
+            msg="A raised tcp.wmem.default must raise the TCP send-buffer floor.",
+        )
+
+    def test__datagram_default__unaffected_by_tcp_knob(self) -> None:
+        """
+        Ensure a datagram socket sources its buffer defaults from the
+        generic 'net.core.*_default' stand-ins, not the TCP-specific
+        knobs — overriding 'tcp.rmem.default' / 'tcp.wmem.default' must
+        not move a UDP socket's effective buffers.
+
+        Reference: PyTCP test infrastructure (no RFC clause).
+        Reference: Linux net.core.rmem_default / wmem_default (datagram
+        default, distinct from tcp_rmem / tcp_wmem).
+        """
+
+        sysctl_module.set("tcp.rmem.default", 131072)
+        sysctl_module.set("tcp.wmem.default", 300000)
+        sock = UdpSocket(family=AddressFamily.INET4)
+        self.addCleanup(sock.close)
+
+        self.assertEqual(
+            sock._effective_rcvbuf(),
+            SOCKET__SO_RCVBUF__DEFAULT,
+            msg="A datagram socket's rcvbuf default must be the generic net.core stand-in.",
+        )
+        self.assertEqual(
+            sock._effective_sndbuf(),
+            SOCKET__SO_SNDBUF__DEFAULT,
+            msg="A datagram socket's sndbuf default must be the generic net.core stand-in.",
+        )