The shipped netstack runs ToyOS's own network stack and smoltcp leaves the tree; libc reads a stream's end as std does

issues/a-connect-between-two-accepts-is-reset.md

@@ -32,5 +32,22 @@ metal harness's swapping boots, which that row was the one user of, and
 `issues/the-host-cannot-reach-the-t14-while-it-runs-toyos.md` records the commit
 that restores those.
 
+netstack's listener is the node's now, whose queue is [tcp]'s: a connect
+that arrives while another waits to be accepted is queued
+(`a_connect_between_two_accepts_is_queued_not_reset`,
+`userland/netstack/node/tests/listeners.rs`), and in a guest two host peers
+that dial before any accept are both accepted (`netstack_streams`, which on
+smoltcp ended `the listener was woken for 1 of two peers`). What is left of the
+exit is `lan_swap`.
+
+QEMU's own forward is a third place such a reset can come from, and it was
+not ruled out of the reading above: its listener queues one connection, and a
+host dial that arrives while one is queued is reset by QEMU with no SYN sent to
+the guest. Measured while `netstack_streams` was written, with the host at a
+load of 30 and twelve guests beside it: 3 of 8 runs red, the host's second
+dial ending `Connection reset by peer (os error 54)` and the frames recorded
+on the guest's card holding one SYN; none of 5 once the harness dialled its
+second peer only after QEMU's table showed the first carried.
+
 **Exit**: a listener that queues a connect arriving between two accepts, and
 `lan_swap` restored and green.

issues/a-listeners-tcp-nodelay-has-no-setter-in-std-or-the-forks-and-a-c-program-cannot-order-the-waiting-case.md

@@ -24,10 +24,8 @@ loopback delivers in. A red there prints the host's name and both answers.
 The pipe ABI carries both halves (`toyos/src/net.rs`): a bind's request
 carries its listener's options and `MsgType::TcpListenerSetOption` sets one
 afterwards, and an accept's answer says what its connection holds
-(`TcpOptions`). netstack answers the rule for both
-(`userland/netstack/src/listen.rs`), but for the connection after a reset
-handshake
-(`issues/a-handshake-reset-before-it-ends-hands-its-option-to-the-next-connection.md`),
+(`TcpOptions`). netstack answers the rule for both by the node's calls
+(`userland/netstack/src/serve.rs`, `userland/netstack/node/src/listeners.rs`),
 and the `libc_sockets` guest test reads it: `nodelay_accepted` by `toyos::net`, for a connection that
 waited when the option was set, its wake read first, and for the next one
 dialled; `tests/netcase/nodelay_kept.c` by libc's `setsockopt` and

issues/a-received-handle-has-no-knowable-type.md

@@ -33,9 +33,12 @@ typed can be ended by whoever sent it.** The sender needs nothing but
 - A window client receives its buffer the same way (`userland/toyos-window/src/lib.rs`).
 - blockd maps the region a client sends with its open (`Region::adopt` in
   `userland/blockd/src/region.rs`), so a *client* holding its connector ends it.
-- netd adopts as pipes the two handles a client sends with a piped socket
-  (`DataPipes::take`) and the one with a piped bind (`handle_tcp_bind_piped`),
-  both in `userland/netd/src/main.rs`: a *client* ends it the same way.
+- netstack adopts as pipes the two handles a client sends with a piped socket
+  (`data_pipes`) and the one with a piped bind (`Sockets::listen`), both in
+  `userland/netstack/src/serve.rs`: a handle that is no pipe end answers a
+  refusal the node ends that client's stream or listener for
+  (`userland/netstack/src/pipes.rs`), and a datagram socket's are netstack's
+  own to read and write.
 
 Nothing in the tree is hostile today, so nothing fails. The property the
 architecture claims — that a process cannot be harmed by what it was not given —

issues/a-stream-its-peer-reset-refuses-the-option-requests-a-host-answers.md

@@ -6,12 +6,12 @@ opened: 2026-10-08
 
 # A stream its peer reset refuses the option requests a host answers
 
-netstack lets a piped connection's socket and id go once the wire is finished
-and it has closed both of its pipe ends (`bridge_piped`,
-`userland/netstack/src/main.rs`). A peer's reset does both at once, so a
-client that still holds the stream names an id netstack no longer has, and
-`handle_tcp_set_option` answers it `ERR_NOT_CONNECTED`. Before the socket left
-with its bridge it answered from the kept socket.
+The node lets a stream go once it holds neither of its pipe ends
+(`userland/netstack/node/src/streams.rs`), and netstack's id for it goes with
+it (`userland/netstack/src/serve.rs`, `Sockets::settle`). A peer's reset ends
+both pipes at once, so a client that still holds the stream names an id
+netstack no longer has, and `Sockets::set_option` answers it
+`ERR_NOT_CONNECTED`.
 
 What a host answers `std::net::TcpStream` on a stream whose peer reset it,
 after the read that reported the reset:

issues/a-streams-failure-reaches-its-client-as-a-reset-whatever-it-was.md

@@ -12,9 +12,8 @@ one bit: the peer's FIN, or a failure. The node knows which failure
 (`toyos_net_tcp::Failure`: a reset, R2's timeout, an ICMP error), and std
 answers every one `ConnectionReset`, where Linux answers a connection [tcp]
 gave up on `ETIMEDOUT` and one an ICMP error ended `EHOSTUNREACH` or
-`ENETUNREACH`. libc reads no failure yet
-(`issues/a-netstack-client-cannot-tell-a-reset-from-the-peers-fin.md`), and
-the change the move carries for it answers every one `ECONNRESET`.
+`ENETUNREACH`. libc answers every one `ECONNRESET`
+(`userland/libc/src/streamend.rs`).
 
 A pipe's end carries no word, and every other carrier costs what this one does
 not: a third pipe or a kept request connection is a 2 MiB page each

issues/libc-answers-epipe-and-raises-no-sigpipe.md

@@ -16,10 +16,8 @@ and none of those
 `issues/a-childs-end-is-an-event-and-a-parent-takes-its-children-down.md`
 has it imitate is `SIGPIPE`. So every write behaves as if `MSG_NOSIGNAL` were
 given, and a C program that relies on the default action to stop writing into a
-closed pipe runs on, and stops only if it reads the error. `send` on a stream answers `EIO` for every refusal today; the libc
-change the move carries for
-`issues/a-netstack-client-cannot-tell-a-reset-from-the-peers-fin.md` answers
-`EPIPE` after `shutdown(SHUT_WR)`, and raises nothing either.
+closed pipe runs on, and stops only if it reads the error. `send` on a stream answers `EPIPE` after
+`shutdown(SHUT_WR)` (`userland/libc/src/socket.rs`), and raises nothing either.
 
 Whether libc raises `SIGPIPE` on these, or states the departure as it states
 others, is a decision of libc's design that nobody has made.

issues/most-t14-leases-land-one-dhcp-retry-late.md

@@ -26,6 +26,16 @@ The network track owns it: netd leaves smoltcp in stage 5 of
 `issues/the-loader-does-only-what-must-precede-the-handover.md`
 waits on it.
 
+netstack runs `toyos-dhcp` now (`userland/netstack/node`): an unanswered
+DISCOVER is sent again on RFC 2131 §4.1's schedule, and a link that comes up
+with no lease starts the exchange over
+(`a_link_that_returns_with_no_lease_starts_discovery_over_at_once`,
+`userland/netstack/node/tests/lease.rs`). Every reading above is of the
+smoltcp client. On this one, four T14 boots of pull request #801's
+measurement branches took their leases 3,419, 7,206, 8,172 and 8,397 ms after
+netstack came up; netstack logs no DISCOVER and no OFFER, so what became of
+the first DISCOVER of each is unread.
+
 **Exit**: netd logs each DISCOVER it sends and each OFFER it receives, and a
 T14 boot's log shows what became of the DISCOVER sent as the link came up; on
 every boot of a T14 run an unanswered DISCOVER is sent again within RFC 2131