kobako 0.30.0 → 0.31.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/.release-please-manifest.json +1 -1
- data/CHANGELOG.md +335 -0
- data/Cargo.lock +469 -11
- data/README.md +43 -3
- data/ROADMAP.md +1 -1
- data/crates/kobako-runtime/CHANGELOG.md +219 -0
- data/crates/kobako-runtime/Cargo.toml +51 -3
- data/crates/kobako-runtime/README.md +7 -4
- data/crates/kobako-runtime/src/cred.rs +124 -0
- data/crates/kobako-runtime/src/dispatch.rs +4 -5
- data/crates/kobako-runtime/src/endpoint/buffer.rs +153 -44
- data/crates/kobako-runtime/src/endpoint/dispatch.rs +80 -41
- data/crates/kobako-runtime/src/endpoint/invoke.rs +23 -36
- data/crates/kobako-runtime/src/endpoint.rs +137 -36
- data/crates/kobako-runtime/src/errno.rs +391 -0
- data/crates/kobako-runtime/src/error.rs +31 -10
- data/crates/kobako-runtime/src/filesystem/anon_inodes.rs +52 -0
- data/crates/kobako-runtime/src/filesystem/bind/lookup.rs +52 -14
- data/crates/kobako-runtime/src/filesystem/bind/walk.rs +19 -20
- data/crates/kobako-runtime/src/filesystem/bind.rs +437 -245
- data/crates/kobako-runtime/src/filesystem/overlay/file.rs +6 -6
- data/crates/kobako-runtime/src/filesystem/overlay/path.rs +43 -65
- data/crates/kobako-runtime/src/filesystem/overlay/stack/copy_up.rs +9 -16
- data/crates/kobako-runtime/src/filesystem/overlay/stack/dir.rs +47 -72
- data/crates/kobako-runtime/src/filesystem/overlay/stack/namei.rs +12 -12
- data/crates/kobako-runtime/src/filesystem/overlay/stack/readdir.rs +4 -7
- data/crates/kobako-runtime/src/filesystem/overlay/stack.rs +121 -37
- data/crates/kobako-runtime/src/filesystem/overlay.rs +302 -343
- data/crates/kobako-runtime/src/filesystem/pipe.rs +12 -9
- data/crates/kobako-runtime/src/filesystem/rdir.rs +15 -32
- data/crates/kobako-runtime/src/filesystem/tmpfs/seed.rs +32 -0
- data/crates/kobako-runtime/src/filesystem/tmpfs/tmpfile.rs +3 -3
- data/crates/kobako-runtime/src/filesystem/tmpfs/whiteout.rs +57 -35
- data/crates/kobako-runtime/src/filesystem/tmpfs/xattr.rs +2 -2
- data/crates/kobako-runtime/src/filesystem/tmpfs.rs +172 -160
- data/crates/kobako-runtime/src/filesystem/wrap.rs +36 -52
- data/crates/kobako-runtime/src/filesystem.rs +6 -3
- data/crates/kobako-runtime/src/fork.rs +96 -0
- data/crates/kobako-runtime/src/grant.rs +3 -0
- data/crates/kobako-runtime/src/hashtable.rs +4 -2
- data/crates/kobako-runtime/src/lib.rs +18 -7
- data/crates/kobako-runtime/src/limits.rs +195 -0
- data/crates/kobako-runtime/src/locking.rs +10 -0
- data/crates/kobako-runtime/src/memcg.rs +383 -0
- data/crates/kobako-runtime/src/mount.rs +67 -9
- data/crates/kobako-runtime/src/net/backends.rs +43 -0
- data/crates/kobako-runtime/src/net/connections.rs +179 -0
- data/crates/kobako-runtime/src/net/credential.rs +125 -0
- data/crates/kobako-runtime/src/net/egress.rs +160 -0
- data/crates/kobako-runtime/src/net/family.rs +181 -0
- data/crates/kobako-runtime/src/net/http.rs +2733 -0
- data/crates/kobako-runtime/src/net/lookup.rs +285 -0
- data/crates/kobako-runtime/src/net/mock.rs +251 -0
- data/crates/kobako-runtime/src/net/namespace.rs +1366 -0
- data/crates/kobako-runtime/src/net/reactor.rs +531 -0
- data/crates/kobako-runtime/src/net/resolv/darwin.rs +275 -0
- data/crates/kobako-runtime/src/net/resolv/stub/tests.rs +469 -0
- data/crates/kobako-runtime/src/net/resolv/stub.rs +536 -0
- data/crates/kobako-runtime/src/net/resolv/windows.rs +248 -0
- data/crates/kobako-runtime/src/net/resolv.rs +227 -0
- data/crates/kobako-runtime/src/net/socket.rs +870 -0
- data/crates/kobako-runtime/src/net/tcp.rs +1588 -0
- data/crates/kobako-runtime/src/net/tls.rs +58 -0
- data/crates/kobako-runtime/src/net/transport.rs +279 -0
- data/crates/kobako-runtime/src/net/udp.rs +1003 -0
- data/crates/kobako-runtime/src/net.rs +42 -0
- data/crates/kobako-runtime/src/network/builder.rs +177 -0
- data/crates/kobako-runtime/src/network/ruleset.rs +777 -0
- data/crates/kobako-runtime/src/network.rs +551 -0
- data/crates/kobako-runtime/src/policy.rs +16 -0
- data/crates/kobako-runtime/src/profile.rs +29 -144
- data/crates/kobako-runtime/src/runtime.rs +3 -5
- data/crates/kobako-runtime/src/sched.rs +130 -29
- data/crates/kobako-runtime/src/security/entry_policy.rs +22 -0
- data/crates/kobako-runtime/src/{vfs/cred.rs → security/hooks.rs} +52 -144
- data/crates/kobako-runtime/src/security/mount_policy.rs +158 -0
- data/crates/kobako-runtime/src/security.rs +101 -196
- data/crates/kobako-runtime/src/snapshot.rs +121 -2
- data/crates/kobako-runtime/src/vfs/attr.rs +5 -5
- data/crates/kobako-runtime/src/vfs/dentry.rs +143 -89
- data/crates/kobako-runtime/src/vfs/file.rs +199 -203
- data/crates/kobako-runtime/src/vfs/inode.rs +41 -45
- data/crates/kobako-runtime/src/vfs/kern_path.rs +38 -42
- data/crates/kobako-runtime/src/vfs/mount.rs +10 -9
- data/crates/kobako-runtime/src/vfs/namei.rs +829 -700
- data/crates/kobako-runtime/src/vfs/namespace.rs +162 -0
- data/crates/kobako-runtime/src/vfs/open_files.rs +69 -0
- data/crates/kobako-runtime/src/vfs/openat2.rs +3 -3
- data/crates/kobako-runtime/src/vfs/path.rs +6 -6
- data/crates/kobako-runtime/src/vfs/readdir.rs +6 -6
- data/crates/kobako-runtime/src/vfs/stat.rs +159 -23
- data/crates/kobako-runtime/src/vfs/super_block.rs +18 -14
- data/crates/kobako-runtime/src/vfs/utimes.rs +37 -27
- data/crates/kobako-runtime/src/vfs.rs +9 -6
- data/crates/kobako-runtime/src/wait.rs +356 -0
- data/crates/kobako-transport/CHANGELOG.md +31 -0
- data/crates/kobako-transport/Cargo.toml +1 -1
- data/crates/kobako-transport/README.md +3 -4
- data/crates/kobako-transport/src/abi.rs +78 -72
- data/crates/kobako-transport/src/envelope/bytes.rs +17 -6
- data/crates/kobako-transport/src/envelope/call.rs +32 -4
- data/crates/kobako-transport/src/envelope/error_record.rs +21 -0
- data/crates/kobako-transport/src/envelope/name.rs +99 -0
- data/crates/kobako-transport/src/envelope/outcome.rs +9 -9
- data/crates/kobako-transport/src/envelope/preamble.rs +24 -21
- data/crates/kobako-transport/src/envelope/reply.rs +27 -27
- data/crates/kobako-transport/src/envelope/unsupported.rs +10 -10
- data/crates/kobako-transport/src/envelope.rs +13 -8
- data/crates/kobako-wasmtime/CHANGELOG.md +161 -0
- data/crates/kobako-wasmtime/Cargo.toml +26 -7
- data/crates/kobako-wasmtime/README.md +3 -2
- data/crates/kobako-wasmtime/build/preview2.rs +1339 -0
- data/crates/kobako-wasmtime/build.rs +16 -0
- data/crates/kobako-wasmtime/src/abi.rs +17 -37
- data/crates/kobako-wasmtime/src/ambient.rs +33 -18
- data/crates/kobako-wasmtime/src/cache.rs +23 -15
- data/crates/kobako-wasmtime/src/config.rs +52 -68
- data/crates/kobako-wasmtime/src/driver.rs +48 -63
- data/crates/kobako-wasmtime/src/exports.rs +143 -17
- data/crates/kobako-wasmtime/src/guest.rs +12 -6
- data/crates/kobako-wasmtime/src/guest_binary.rs +14 -0
- data/crates/kobako-wasmtime/src/imports.rs +42 -18
- data/crates/kobako-wasmtime/src/instance_pre.rs +4 -4
- data/crates/kobako-wasmtime/src/invocation.rs +74 -12
- data/crates/kobako-wasmtime/src/lib.rs +5 -3
- data/crates/kobako-wasmtime/src/limiter.rs +70 -5
- data/crates/kobako-wasmtime/src/preview1/descriptors.rs +309 -0
- data/crates/kobako-wasmtime/src/preview1/differential/mount.rs +5 -15
- data/crates/kobako-wasmtime/src/preview1/differential.rs +27 -31
- data/crates/kobako-wasmtime/src/preview1/errno.rs +55 -66
- data/crates/kobako-wasmtime/src/preview1/fd.rs +327 -296
- data/crates/kobako-wasmtime/src/preview1/memory.rs +21 -12
- data/crates/kobako-wasmtime/src/preview1/mount_view/wrap.rs +34 -53
- data/crates/kobako-wasmtime/src/preview1/mount_view.rs +231 -217
- data/crates/kobako-wasmtime/src/preview1/path.rs +56 -121
- data/crates/kobako-wasmtime/src/preview1/poll.rs +244 -120
- data/crates/kobako-wasmtime/src/preview1/sock.rs +10 -8
- data/crates/kobako-wasmtime/src/preview1/testsuite.rs +5 -15
- data/crates/kobako-wasmtime/src/preview1.rs +46 -42
- data/crates/kobako-wasmtime/src/preview2/abi.rs +227 -0
- data/crates/kobako-wasmtime/src/preview2/error.rs +118 -0
- data/crates/kobako-wasmtime/src/preview2/filesystem.rs +122 -0
- data/crates/kobako-wasmtime/src/preview2/host.rs +3959 -0
- data/crates/kobako-wasmtime/src/preview2/http.rs +1503 -0
- data/crates/kobako-wasmtime/src/preview2/io.rs +315 -0
- data/crates/kobako-wasmtime/src/preview2/sockets.rs +379 -0
- data/crates/kobako-wasmtime/src/preview2/table.rs +305 -0
- data/crates/kobako-wasmtime/src/preview2.rs +57 -0
- data/crates/kobako-wasmtime/src/trap.rs +24 -9
- data/crates/kobako-wasmtime/src/wasi.rs +210 -81
- data/crates/kobako-wasmtime/wit/deps/cli.wit +233 -0
- data/crates/kobako-wasmtime/wit/deps/clocks.wit +162 -0
- data/crates/kobako-wasmtime/wit/deps/filesystem.wit +589 -0
- data/crates/kobako-wasmtime/wit/deps/http.wit +733 -0
- data/crates/kobako-wasmtime/wit/deps/io.wit +299 -0
- data/crates/kobako-wasmtime/wit/deps/random.wit +92 -0
- data/crates/kobako-wasmtime/wit/deps/sockets.wit +949 -0
- data/data/kobako.wasm +0 -0
- data/ext/kobako/Cargo.toml +1 -1
- data/ext/kobako/src/{runtime/errors.rs → errors.rs} +34 -26
- data/ext/kobako/src/{runtime/escape.rs → escape.rs} +42 -11
- data/ext/kobako/src/{runtime/filesystem → filesystem}/grants.rs +30 -26
- data/ext/kobako/src/{runtime/filesystem → filesystem}/ruby.rs +149 -168
- data/ext/kobako/src/{runtime/filesystem.rs → filesystem.rs} +24 -15
- data/ext/kobako/src/gvl.rs +306 -0
- data/ext/kobako/src/lib.rs +64 -3
- data/ext/kobako/src/network/mock.rs +187 -0
- data/ext/kobako/src/network.rs +591 -0
- data/ext/kobako/src/runtime/bridge.rs +30 -29
- data/ext/kobako/src/runtime/snapshot.rs +4 -4
- data/ext/kobako/src/runtime.rs +221 -143
- data/ext/kobako/src/wire.rs +42 -0
- data/lib/kobako/catalog/extensions.rb +14 -2
- data/lib/kobako/catalog/flags.rb +3 -5
- data/lib/kobako/catalog/grants.rb +5 -4
- data/lib/kobako/catalog/handles.rb +5 -27
- data/lib/kobako/catalog/mount.rb +11 -3
- data/lib/kobako/catalog/network.rb +35 -0
- data/lib/kobako/catalog/replacements.rb +28 -0
- data/lib/kobako/catalog/services.rb +5 -19
- data/lib/kobako/catalog/snippets.rb +3 -18
- data/lib/kobako/catalog.rb +3 -0
- data/lib/kobako/codec/{utils.rb → boundary.rb} +4 -2
- data/lib/kobako/codec/decoder.rb +4 -4
- data/lib/kobako/codec/ext_types.rb +3 -3
- data/lib/kobako/codec/handle_walk.rb +3 -43
- data/lib/kobako/codec/value_budget.rb +132 -40
- data/lib/kobako/codec.rb +1 -1
- data/lib/kobako/context.rb +24 -11
- data/lib/kobako/errors.rb +15 -12
- data/lib/kobako/extension.rb +3 -2
- data/lib/kobako/filesystem.rb +9 -2
- data/lib/kobako/handle.rb +2 -2
- data/lib/kobako/names.rb +28 -0
- data/lib/kobako/network.rb +210 -0
- data/lib/kobako/outcome.rb +7 -7
- data/lib/kobako/pool.rb +45 -23
- data/lib/kobako/runtime.rb +3 -2
- data/lib/kobako/sandbox.rb +92 -35
- data/lib/kobako/sandbox_options.rb +41 -106
- data/lib/kobako/transport/argument_wrap.rb +64 -0
- data/lib/kobako/transport/block_failure.rb +1 -1
- data/lib/kobako/transport/dispatcher.rb +6 -6
- data/lib/kobako/transport/exposure.rb +26 -15
- data/lib/kobako/transport/reflection.rb +21 -4
- data/lib/kobako/transport/run.rb +8 -23
- data/lib/kobako/transport/yielder.rb +2 -9
- data/lib/kobako/transport.rb +1 -0
- data/lib/kobako/version.rb +1 -1
- data/lib/kobako.rb +6 -2
- data/release-please-config.json +15 -0
- data/sig/core/thread.rbs +6 -0
- data/sig/kobako/catalog/extensions.rbs +2 -0
- data/sig/kobako/catalog/grants.rbs +7 -4
- data/sig/kobako/catalog/handles.rbs +0 -2
- data/sig/kobako/catalog/mount.rbs +3 -1
- data/sig/kobako/catalog/network.rbs +20 -0
- data/sig/kobako/catalog/replacements.rbs +14 -0
- data/sig/kobako/catalog/services.rbs +0 -4
- data/sig/kobako/catalog/snippets.rbs +0 -2
- data/sig/kobako/codec/{utils.rbs → boundary.rbs} +2 -2
- data/sig/kobako/codec/handle_walk.rbs +0 -6
- data/sig/kobako/codec/value_budget.rbs +47 -4
- data/sig/kobako/context.rbs +3 -1
- data/sig/kobako/errors.rbs +4 -4
- data/sig/kobako/filesystem.rbs +21 -3
- data/sig/kobako/network.rbs +115 -0
- data/sig/kobako/outcome.rbs +1 -1
- data/sig/kobako/pool.rbs +7 -3
- data/sig/kobako/runtime.rbs +32 -3
- data/sig/kobako/sandbox.rbs +19 -2
- data/sig/kobako/sandbox_options.rbs +29 -38
- data/sig/kobako/transport/argument_wrap.rbs +15 -0
- data/sig/kobako/transport/error.rbs +1 -1
- data/sig/kobako/transport/exposure.rbs +2 -4
- data/sig/kobako/transport/reflection.rbs +10 -0
- data/sig/kobako/transport/run.rbs +0 -2
- data/sig/kobako/transport/yielder.rbs +0 -3
- data/sig/kobako/transport.rbs +1 -1
- data/sig/kobako.rbs +13 -0
- metadata +84 -35
- data/crates/kobako-runtime/src/endpoint/capture.rs +0 -115
- data/crates/kobako-runtime/src/endpoint/memory_cap.rs +0 -238
- data/crates/kobako-runtime/src/filesystem/path.rs +0 -21
- data/crates/kobako-runtime/src/vfs/errno.rs +0 -153
- data/crates/kobako-runtime/tests/linux_baseline/calls.rs +0 -171
- data/crates/kobako-runtime/tests/linux_baseline/concurrent.rs +0 -276
- data/crates/kobako-runtime/tests/linux_baseline/kobako.rs +0 -323
- data/crates/kobako-runtime/tests/linux_baseline/linux-baseline-expected.txt +0 -16
- data/crates/kobako-runtime/tests/linux_baseline/linux.rs +0 -449
- data/crates/kobako-runtime/tests/linux_baseline/main.rs +0 -611
- data/crates/kobako-runtime/tests/linux_baseline/permissions.rs +0 -236
- data/crates/kobako-wasmtime/src/descriptors.rs +0 -200
- data/crates/kobako-wasmtime/tests/integration/compile_posture.rs +0 -43
- data/crates/kobako-wasmtime/tests/integration/guest_file.rs +0 -1085
- data/crates/kobako-wasmtime/tests/integration/main.rs +0 -29
- data/crates/kobako-wasmtime/tests/integration/preamble_flags.rs +0 -70
- data/crates/kobako-wasmtime/tests/integration/snippet_compile.rs +0 -95
- data/crates/kobako-wasmtime/tests/integration/support/mod.rs +0 -30
- data/crates/kobako-wasmtime/tests/integration/unanswered_call.rs +0 -86
- data/crates/kobako-wasmtime/tests/integration/unsupported_call.rs +0 -51
- data/ext/kobako/src/runtime/gvl.rs +0 -147
- data/lib/kobako/constant_name.rb +0 -8
- data/sig/kobako/constant_name.rbs +0 -3
- /data/ext/kobako/src/{runtime/pinned_value.rs → pinned_value.rs} +0 -0
|
@@ -0,0 +1,1588 @@
|
|
|
1
|
+
//! A TCP socket the guest holds, as Linux's `tcp_sock` behind a socket file.
|
|
2
|
+
//! The host socket is non-blocking and the reactor watches it: each change
|
|
3
|
+
//! moves what fits between the host socket and the socket's buffers, as a
|
|
4
|
+
//! softirq fills `sk_receive_queue`, then wakes the socket's wait queue. A
|
|
5
|
+
//! guest call moves what it can at once, so a buffer the guest drained reads
|
|
6
|
+
//! on without waiting for another event.
|
|
7
|
+
|
|
8
|
+
use std::collections::VecDeque;
|
|
9
|
+
use std::io::{self, Read, Write};
|
|
10
|
+
use std::net::{Shutdown, SocketAddr};
|
|
11
|
+
use std::sync::{Arc, Mutex, MutexGuard, PoisonError, Weak};
|
|
12
|
+
use std::time::Duration;
|
|
13
|
+
|
|
14
|
+
use socket2::{SockRef, TcpKeepalive};
|
|
15
|
+
|
|
16
|
+
use super::connections::{OpenConnections, Place};
|
|
17
|
+
use super::family::ProtocolFamily;
|
|
18
|
+
use super::namespace::Namespace;
|
|
19
|
+
use super::reactor::{Reactor, Ready, Registration};
|
|
20
|
+
use super::socket::{
|
|
21
|
+
connect4, ensure_within, filter, filter_with, set_hop_limit, take_connect_outcome, BindHash,
|
|
22
|
+
Buffers, Destination, InetSock, ProtoOps, SkState, SockOpt, MAX_SOCKET_BUFFER,
|
|
23
|
+
};
|
|
24
|
+
use crate::cred::Cred;
|
|
25
|
+
use crate::memcg::MemoryCharge;
|
|
26
|
+
use crate::network::{Protocol, Ruleset};
|
|
27
|
+
use crate::vfs::PollMask;
|
|
28
|
+
use crate::wait::{poll_wait, PollTable, WaitQueueHead};
|
|
29
|
+
use crate::Errno;
|
|
30
|
+
|
|
31
|
+
/// The most one host read moves at once.
|
|
32
|
+
const MAX_HOST_READ: usize = 16 * 1024;
|
|
33
|
+
|
|
34
|
+
/// Linux's keepalive defaults, `TCP_KEEPALIVE_TIME`, `TCP_KEEPALIVE_INTVL`,
|
|
35
|
+
/// and `TCP_KEEPALIVE_PROBES`, in seconds and probes.
|
|
36
|
+
const TCP_KEEPALIVE_TIME: u32 = 7200;
|
|
37
|
+
const TCP_KEEPALIVE_INTVL: u32 = 75;
|
|
38
|
+
const TCP_KEEPALIVE_PROBES: u32 = 9;
|
|
39
|
+
|
|
40
|
+
/// Linux's ceilings on each, past which a set answers EINVAL.
|
|
41
|
+
pub const MAX_TCP_KEEPIDLE: u32 = 32767;
|
|
42
|
+
pub const MAX_TCP_KEEPINTVL: u32 = 32767;
|
|
43
|
+
pub const MAX_TCP_KEEPCNT: u32 = 127;
|
|
44
|
+
|
|
45
|
+
/// When a socket probes an idle peer, as `tcp_sock` keeps `keepalive_time`,
|
|
46
|
+
/// `keepalive_intvl`, and `keepalive_probes` beside `SOCK_KEEPOPEN`.
|
|
47
|
+
#[derive(Clone, Copy)]
|
|
48
|
+
struct KeepAlive {
|
|
49
|
+
on: bool,
|
|
50
|
+
idle: u32,
|
|
51
|
+
interval: u32,
|
|
52
|
+
count: u32,
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
impl KeepAlive {
|
|
56
|
+
/// The probes as the host socket takes them.
|
|
57
|
+
fn to_params(self) -> TcpKeepalive {
|
|
58
|
+
TcpKeepalive::new()
|
|
59
|
+
.with_time(Duration::from_secs(self.idle.into()))
|
|
60
|
+
.with_interval(Duration::from_secs(self.interval.into()))
|
|
61
|
+
.with_retries(self.count)
|
|
62
|
+
}
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
66
|
+
enum Phase {
|
|
67
|
+
/// Connected to nothing yet, as a fresh socket stands in `TCP_CLOSE`.
|
|
68
|
+
Unconnected,
|
|
69
|
+
Connecting,
|
|
70
|
+
Connected,
|
|
71
|
+
/// Closed by a failed connect, as `tcp_done` leaves a socket in
|
|
72
|
+
/// `TCP_CLOSE` with both sides shut down; it may connect afresh.
|
|
73
|
+
Failed,
|
|
74
|
+
/// Closed once connected, by a reset or by both ends' FIN, as `tcp_done`
|
|
75
|
+
/// leaves it beside `SS_CONNECTED`, so it never connects again.
|
|
76
|
+
Done,
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
impl Phase {
|
|
80
|
+
/// Whether a failed connect, a reset, or both ends' FIN closed it.
|
|
81
|
+
fn is_closed(&self) -> bool {
|
|
82
|
+
matches!(self, Phase::Failed | Phase::Done)
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
/// The `sk_state` it stands in.
|
|
86
|
+
fn sk_state(&self) -> SkState {
|
|
87
|
+
match self {
|
|
88
|
+
Phase::Connecting => SkState::SynSent,
|
|
89
|
+
Phase::Connected => SkState::Established,
|
|
90
|
+
Phase::Unconnected | Phase::Failed | Phase::Done => SkState::Close,
|
|
91
|
+
}
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
struct State {
|
|
96
|
+
phase: Phase,
|
|
97
|
+
/// The host socket, and its place in the reactor.
|
|
98
|
+
host: Option<(mio::net::TcpStream, Registration)>,
|
|
99
|
+
/// What arrived and the guest has not read, as `sk_receive_queue`.
|
|
100
|
+
receive_queue: VecDeque<u8>,
|
|
101
|
+
/// The peer ended its side, as a read of zero answers.
|
|
102
|
+
received_end: bool,
|
|
103
|
+
/// What the guest wrote and the host has not taken, as `sk_write_queue`.
|
|
104
|
+
write_queue: VecDeque<u8>,
|
|
105
|
+
/// The FIN left, once the writing side was shut and the buffer drained.
|
|
106
|
+
fin_sent: bool,
|
|
107
|
+
/// What every inet socket holds. What arrived still reads once the
|
|
108
|
+
/// reading side is shut.
|
|
109
|
+
inet: InetSock,
|
|
110
|
+
/// The keepalive probes the guest asked for; the host socket takes them
|
|
111
|
+
/// as it is dialed.
|
|
112
|
+
keepalive: KeepAlive,
|
|
113
|
+
/// Whether each write leaves without Nagle's delay, as `TCP_NODELAY`
|
|
114
|
+
/// sets `tp->nonagle`; Linux's default waits.
|
|
115
|
+
nodelay: bool,
|
|
116
|
+
/// The socket itself once released with bytes still to send, held until
|
|
117
|
+
/// they and the FIN leave, as Linux keeps an orphan in `FIN_WAIT1`.
|
|
118
|
+
orphan: Option<Arc<TcpSock>>,
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
impl State {
|
|
122
|
+
/// The room left in the send buffer, as `sk_stream_wspace` takes what is
|
|
123
|
+
/// queued from `sk_sndbuf`.
|
|
124
|
+
fn stream_wspace(&self) -> usize {
|
|
125
|
+
self.inet
|
|
126
|
+
.buffers
|
|
127
|
+
.sndbuf
|
|
128
|
+
.saturating_sub(self.write_queue.len())
|
|
129
|
+
}
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
/// One TCP socket, shared by the socket file and the reactor.
|
|
133
|
+
pub struct TcpSock {
|
|
134
|
+
state: Mutex<State>,
|
|
135
|
+
/// What a guest's poll waits on.
|
|
136
|
+
wait: Arc<WaitQueueHead>,
|
|
137
|
+
family: Arc<dyn ProtocolFamily>,
|
|
138
|
+
this: Weak<Self>,
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
impl TcpSock {
|
|
142
|
+
/// A socket connected to nothing, which connects through `family`, as
|
|
143
|
+
/// `inet_create` makes one; its buffers are reserved against `cred`'s
|
|
144
|
+
/// memory, and past it the socket answers `ENOMEM`.
|
|
145
|
+
pub(crate) fn new(
|
|
146
|
+
family: Arc<dyn ProtocolFamily>,
|
|
147
|
+
cred: &Arc<Cred>,
|
|
148
|
+
) -> Result<Arc<Self>, Errno> {
|
|
149
|
+
let memory = MemoryCharge::new(cred.memory_budget(), 2 * MAX_SOCKET_BUFFER)?;
|
|
150
|
+
Ok(Arc::new_cyclic(|this| Self {
|
|
151
|
+
state: Mutex::new(State {
|
|
152
|
+
phase: Phase::Unconnected,
|
|
153
|
+
host: None,
|
|
154
|
+
receive_queue: VecDeque::new(),
|
|
155
|
+
received_end: false,
|
|
156
|
+
write_queue: VecDeque::new(),
|
|
157
|
+
fin_sent: false,
|
|
158
|
+
inet: InetSock::new(memory, Buffers::tcp()),
|
|
159
|
+
keepalive: KeepAlive {
|
|
160
|
+
on: false,
|
|
161
|
+
idle: TCP_KEEPALIVE_TIME,
|
|
162
|
+
interval: TCP_KEEPALIVE_INTVL,
|
|
163
|
+
count: TCP_KEEPALIVE_PROBES,
|
|
164
|
+
},
|
|
165
|
+
nodelay: false,
|
|
166
|
+
orphan: None,
|
|
167
|
+
}),
|
|
168
|
+
wait: Arc::default(),
|
|
169
|
+
family,
|
|
170
|
+
this: this.clone(),
|
|
171
|
+
}))
|
|
172
|
+
}
|
|
173
|
+
|
|
174
|
+
/// Whether the socket may begin a connect, as `__inet_stream_connect`
|
|
175
|
+
/// switches on its state before anything else: one connecting answers
|
|
176
|
+
/// `EALREADY`, one connected or reset `EISCONN`, and one a connect failed
|
|
177
|
+
/// answers that failure once and stands unconnected again.
|
|
178
|
+
fn check_state(&self) -> Result<(), Errno> {
|
|
179
|
+
let mut state = self.state();
|
|
180
|
+
match state.phase {
|
|
181
|
+
Phase::Connecting => Err(Errno::AlreadyInProgress),
|
|
182
|
+
Phase::Connected | Phase::Done => Err(Errno::AlreadyConnected),
|
|
183
|
+
Phase::Failed => {
|
|
184
|
+
let err = state.inet.err.take().unwrap_or(Errno::ConnectionAborted);
|
|
185
|
+
Self::disconnect(&mut state);
|
|
186
|
+
Err(err)
|
|
187
|
+
}
|
|
188
|
+
Phase::Unconnected => Ok(()),
|
|
189
|
+
}
|
|
190
|
+
}
|
|
191
|
+
|
|
192
|
+
/// Dial `addr`, the guest having named `peer`, as `tcp_v4_connect` sends
|
|
193
|
+
/// the SYN to one destination; the connect goes on without blocking, so
|
|
194
|
+
/// this returns at once and a poll finds the socket writable once it
|
|
195
|
+
/// settles. The socket counts against `open_connections` and the process
|
|
196
|
+
/// until released, and a full count answers `EAGAIN`, never a Trap, so one
|
|
197
|
+
/// Sandbox cannot end another's run.
|
|
198
|
+
pub(crate) fn dial(
|
|
199
|
+
&self,
|
|
200
|
+
addr: SocketAddr,
|
|
201
|
+
peer: SocketAddr,
|
|
202
|
+
open_connections: &Arc<OpenConnections>,
|
|
203
|
+
) -> Result<(), Errno> {
|
|
204
|
+
let mut state = self.state();
|
|
205
|
+
if let Some(place) = state.inet.open_place(open_connections)? {
|
|
206
|
+
state.inet.place = Some(place);
|
|
207
|
+
}
|
|
208
|
+
self.start_connect(&mut state, addr, peer);
|
|
209
|
+
Ok(())
|
|
210
|
+
}
|
|
211
|
+
|
|
212
|
+
/// Connect to `dest`, the destination an egress proxy already judged by
|
|
213
|
+
/// its name, through what the socket layer judges after the hooks: the
|
|
214
|
+
/// socket's state, a port from `ports`, and `ruleset`'s filter. The hooks
|
|
215
|
+
/// already judged the name the guest asked for, so they see no real
|
|
216
|
+
/// address. The socket holds `place`, the request's own, so a socket
|
|
217
|
+
/// still sending once the request is released counts against the caps
|
|
218
|
+
/// until it closes, as a guest's socket keeps its place.
|
|
219
|
+
pub(crate) fn connect_upstream(
|
|
220
|
+
&self,
|
|
221
|
+
ports: &Arc<BindHash>,
|
|
222
|
+
ruleset: &Ruleset,
|
|
223
|
+
dest: &Destination,
|
|
224
|
+
place: &Arc<Place>,
|
|
225
|
+
) -> Result<(), Errno> {
|
|
226
|
+
self.check_state()?;
|
|
227
|
+
self.state().inet.place = Some(place.clone());
|
|
228
|
+
self.connect_from_port(ports, || {
|
|
229
|
+
let real = filter_with(ruleset, &*self.family, dest, Protocol::Http)?;
|
|
230
|
+
self.start_connect(&mut self.state(), real, real);
|
|
231
|
+
Ok(())
|
|
232
|
+
})
|
|
233
|
+
}
|
|
234
|
+
|
|
235
|
+
/// Hold a port from `ports`, then `connect`, putting the port back if it
|
|
236
|
+
/// fails, as `tcp_v4_connect` hashes a port before the SYN meets the
|
|
237
|
+
/// filter and its one `failure:` puts it.
|
|
238
|
+
fn connect_from_port(
|
|
239
|
+
&self,
|
|
240
|
+
ports: &Arc<BindHash>,
|
|
241
|
+
connect: impl FnOnce() -> Result<(), Errno>,
|
|
242
|
+
) -> Result<(), Errno> {
|
|
243
|
+
self.hash_connect(ports)?;
|
|
244
|
+
connect().inspect_err(|_| self.state().inet.put_port())
|
|
245
|
+
}
|
|
246
|
+
|
|
247
|
+
/// Begin connecting to `addr` for the guest's `peer`: no failure pending,
|
|
248
|
+
/// as `tcp_connect_init` clears `sk_err`, then the host socket's dial.
|
|
249
|
+
fn start_connect(&self, state: &mut State, addr: SocketAddr, peer: SocketAddr) {
|
|
250
|
+
state.inet.err = None;
|
|
251
|
+
state.inet.peer = Some(peer);
|
|
252
|
+
state.phase = Phase::Connecting;
|
|
253
|
+
self.dial_host(state, addr);
|
|
254
|
+
}
|
|
255
|
+
|
|
256
|
+
/// The queue a task or a poll waits on for this socket, as `sk_sleep`
|
|
257
|
+
/// answers a socket's wait queue.
|
|
258
|
+
pub(crate) fn sk_sleep(&self) -> &Arc<WaitQueueHead> {
|
|
259
|
+
&self.wait
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
/// Hold a free port from `ports` as the guest's own, unless one is held.
|
|
263
|
+
pub(crate) fn hash_connect(&self, ports: &Arc<BindHash>) -> Result<(), Errno> {
|
|
264
|
+
self.state().inet.hash_connect(ports)
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
fn state(&self) -> MutexGuard<'_, State> {
|
|
268
|
+
self.state.lock().unwrap_or_else(PoisonError::into_inner)
|
|
269
|
+
}
|
|
270
|
+
|
|
271
|
+
/// Start connecting the host socket to `addr`, or fail the connect. The
|
|
272
|
+
/// dial registers on the reactor running as it dials, so a reactor whose
|
|
273
|
+
/// poll failed meanwhile is replaced, not waited on.
|
|
274
|
+
fn dial_host(&self, state: &mut State, addr: SocketAddr) {
|
|
275
|
+
let dialed = Reactor::current().and_then(|reactor| {
|
|
276
|
+
let stream = self.family.connect(addr)?;
|
|
277
|
+
// The guest's own setsockopt already took each option, so one the
|
|
278
|
+
// host socket refuses as it dials is no part of the connect's
|
|
279
|
+
// outcome, which is what the guest reads.
|
|
280
|
+
let _ = Self::set_options(SockRef::from(&stream), state);
|
|
281
|
+
let mut stream = mio::net::TcpStream::from_std(stream);
|
|
282
|
+
let ready: Weak<dyn Ready> = self.this.clone();
|
|
283
|
+
let registration = reactor.register(&mut stream, ready)?;
|
|
284
|
+
Ok((stream, registration))
|
|
285
|
+
});
|
|
286
|
+
match dialed {
|
|
287
|
+
Ok(host) => state.host = Some(host),
|
|
288
|
+
Err(err) => Self::done_with_error(state, Errno::from_io_error(&err)),
|
|
289
|
+
}
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
/// Give the host socket `socket` the options the guest set.
|
|
293
|
+
fn set_options(socket: SockRef<'_>, state: &State) -> io::Result<()> {
|
|
294
|
+
socket.set_tcp_keepalive(&state.keepalive.to_params())?;
|
|
295
|
+
socket.set_keepalive(state.keepalive.on)?;
|
|
296
|
+
socket.set_tcp_nodelay(state.nodelay)?;
|
|
297
|
+
set_hop_limit(socket, state.inet.uc_ttl)
|
|
298
|
+
}
|
|
299
|
+
|
|
300
|
+
/// End the socket on `err`, as `tcp_done_with_error` does after a failed
|
|
301
|
+
/// connect or a reset: `tcp_done`, with the failure pending.
|
|
302
|
+
fn done_with_error(state: &mut State, err: Errno) {
|
|
303
|
+
Self::done(state);
|
|
304
|
+
state.inet.err = Some(err);
|
|
305
|
+
}
|
|
306
|
+
|
|
307
|
+
/// End the socket, as `tcp_done` does: `TCP_CLOSE`, both sides shut
|
|
308
|
+
/// down, its port given back. Linux ends one whose FIN left once the
|
|
309
|
+
/// peer's arrived and its own was acknowledged; no acknowledgement shows
|
|
310
|
+
/// through a host socket, so the two FINs alone end it here.
|
|
311
|
+
fn done(state: &mut State) {
|
|
312
|
+
Self::close_host(state);
|
|
313
|
+
state.inet.put_port();
|
|
314
|
+
state.phase = match state.phase {
|
|
315
|
+
Phase::Connected => Phase::Done,
|
|
316
|
+
_ => Phase::Failed,
|
|
317
|
+
};
|
|
318
|
+
}
|
|
319
|
+
|
|
320
|
+
/// Return a socket whose connect failed or was given up to one never
|
|
321
|
+
/// connected, as `tcp_disconnect` clears what the connect left.
|
|
322
|
+
fn disconnect(state: &mut State) {
|
|
323
|
+
state.phase = Phase::Unconnected;
|
|
324
|
+
state.receive_queue.clear();
|
|
325
|
+
state.received_end = false;
|
|
326
|
+
state.inet.rcv_shutdown = false;
|
|
327
|
+
state.write_queue.clear();
|
|
328
|
+
state.inet.send_shutdown = false;
|
|
329
|
+
state.fin_sent = false;
|
|
330
|
+
state.inet.err = None;
|
|
331
|
+
state.inet.peer = None;
|
|
332
|
+
state.inet.put_port();
|
|
333
|
+
}
|
|
334
|
+
|
|
335
|
+
/// Let the host socket go, deregistered from the reactor.
|
|
336
|
+
fn close_host(state: &mut State) {
|
|
337
|
+
if let Some((mut stream, registration)) = state.host.take() {
|
|
338
|
+
registration.deregister(&mut stream);
|
|
339
|
+
let _ = stream.shutdown(Shutdown::Both);
|
|
340
|
+
}
|
|
341
|
+
}
|
|
342
|
+
|
|
343
|
+
/// Move what the host socket takes and holds now, without blocking.
|
|
344
|
+
fn pump(&self, state: &mut State) {
|
|
345
|
+
if state.phase == Phase::Connecting {
|
|
346
|
+
self.settle_connect(state);
|
|
347
|
+
}
|
|
348
|
+
if state.phase != Phase::Connected {
|
|
349
|
+
return;
|
|
350
|
+
}
|
|
351
|
+
match Self::move_bytes(state) {
|
|
352
|
+
Ok(()) if state.fin_sent && state.received_end => Self::done(state),
|
|
353
|
+
Ok(()) => {}
|
|
354
|
+
Err(err) => Self::done_with_error(state, err),
|
|
355
|
+
}
|
|
356
|
+
}
|
|
357
|
+
|
|
358
|
+
/// Read what arrived and write what is queued, until the host socket
|
|
359
|
+
/// would block; a failure either way is the connection's end.
|
|
360
|
+
fn move_bytes(state: &mut State) -> Result<(), Errno> {
|
|
361
|
+
let Some((stream, _)) = state.host.as_mut() else {
|
|
362
|
+
return Ok(());
|
|
363
|
+
};
|
|
364
|
+
let mut chunk = [0; MAX_HOST_READ];
|
|
365
|
+
let rcvbuf = state.inet.buffers.rcvbuf;
|
|
366
|
+
while state.receive_queue.len() < rcvbuf && !state.received_end {
|
|
367
|
+
let room = (rcvbuf - state.receive_queue.len()).min(MAX_HOST_READ);
|
|
368
|
+
match stream.read(&mut chunk[..room]) {
|
|
369
|
+
Ok(0) => state.received_end = true,
|
|
370
|
+
Ok(n) => state.receive_queue.extend(&chunk[..n]),
|
|
371
|
+
Err(err) if err.kind() == io::ErrorKind::Interrupted => {}
|
|
372
|
+
Err(err) if err.kind() == io::ErrorKind::WouldBlock => break,
|
|
373
|
+
Err(err) => return Err(Errno::from_io_error(&err)),
|
|
374
|
+
}
|
|
375
|
+
}
|
|
376
|
+
while !state.write_queue.is_empty() {
|
|
377
|
+
match stream.write(state.write_queue.as_slices().0) {
|
|
378
|
+
Ok(n) => {
|
|
379
|
+
state.write_queue.drain(..n);
|
|
380
|
+
}
|
|
381
|
+
Err(err) if err.kind() == io::ErrorKind::Interrupted => {}
|
|
382
|
+
Err(err) if err.kind() == io::ErrorKind::WouldBlock => break,
|
|
383
|
+
Err(err) => return Err(Errno::from_io_error(&err)),
|
|
384
|
+
}
|
|
385
|
+
}
|
|
386
|
+
if state.inet.send_shutdown && state.write_queue.is_empty() && !state.fin_sent {
|
|
387
|
+
let _ = stream.shutdown(Shutdown::Write);
|
|
388
|
+
state.fin_sent = true;
|
|
389
|
+
}
|
|
390
|
+
Ok(())
|
|
391
|
+
}
|
|
392
|
+
|
|
393
|
+
/// Settle the connect under way once it finished, as `SO_ERROR` settles a
|
|
394
|
+
/// non-blocking `connect`: connected, or failed with what the host saw.
|
|
395
|
+
fn settle_connect(&self, state: &mut State) {
|
|
396
|
+
let Some((stream, _)) = state.host.as_ref() else {
|
|
397
|
+
return;
|
|
398
|
+
};
|
|
399
|
+
let failure = match take_connect_outcome(stream) {
|
|
400
|
+
None => return,
|
|
401
|
+
Some(Ok(())) => {
|
|
402
|
+
state.phase = Phase::Connected;
|
|
403
|
+
state.inet.buffers.sndbuf_expand();
|
|
404
|
+
return;
|
|
405
|
+
}
|
|
406
|
+
Some(Err(err)) => err,
|
|
407
|
+
};
|
|
408
|
+
Self::done_with_error(state, Errno::from_io_error(&failure));
|
|
409
|
+
}
|
|
410
|
+
|
|
411
|
+
/// Move what can move, then wake every poller, since what a poll finds
|
|
412
|
+
/// may have changed. An orphan whose bytes and FIN left, or whose
|
|
413
|
+
/// connection ended, lets go of itself; one the peer sends to resets the
|
|
414
|
+
/// connection, as Linux resets data arriving after `__tcp_close`.
|
|
415
|
+
fn pump_and_wake(&self, mut state: MutexGuard<'_, State>) {
|
|
416
|
+
self.pump(&mut state);
|
|
417
|
+
let arrived = state.orphan.is_some() && !state.receive_queue.is_empty();
|
|
418
|
+
if arrived {
|
|
419
|
+
Self::reset_host(&mut state);
|
|
420
|
+
}
|
|
421
|
+
let settled = state.orphan.is_some()
|
|
422
|
+
&& (arrived
|
|
423
|
+
|| state.phase != Phase::Connected
|
|
424
|
+
|| (state.write_queue.is_empty() && state.fin_sent));
|
|
425
|
+
let orphan = settled.then(|| Self::let_go(&mut state)).flatten();
|
|
426
|
+
drop(state);
|
|
427
|
+
self.wait.wake_up();
|
|
428
|
+
drop(orphan);
|
|
429
|
+
}
|
|
430
|
+
|
|
431
|
+
/// Close the host socket with a zero linger and no FIN, so its peer reads
|
|
432
|
+
/// a reset.
|
|
433
|
+
fn reset_host(state: &mut State) {
|
|
434
|
+
if let Some((mut stream, registration)) = state.host.take() {
|
|
435
|
+
registration.deregister(&mut stream);
|
|
436
|
+
let _ = SockRef::from(&stream).set_linger(Some(Duration::ZERO));
|
|
437
|
+
}
|
|
438
|
+
}
|
|
439
|
+
|
|
440
|
+
/// Give back the socket's place and memory and close the host socket,
|
|
441
|
+
/// answering the hold an orphan kept on itself.
|
|
442
|
+
fn let_go(state: &mut State) -> Option<Arc<TcpSock>> {
|
|
443
|
+
state.write_queue.clear();
|
|
444
|
+
state.inet.release();
|
|
445
|
+
Self::close_host(state);
|
|
446
|
+
state.orphan.take()
|
|
447
|
+
}
|
|
448
|
+
|
|
449
|
+
/// Lock the host socket's send buffer at `size`, so the host stops
|
|
450
|
+
/// taking bytes once it holds that many, as a test needs a connection
|
|
451
|
+
/// still sending.
|
|
452
|
+
#[cfg(test)]
|
|
453
|
+
pub(crate) fn lock_host_send_buffer(&self, size: usize) {
|
|
454
|
+
if let Some((stream, _)) = self.state().host.as_ref() {
|
|
455
|
+
SockRef::from(stream)
|
|
456
|
+
.set_send_buffer_size(size)
|
|
457
|
+
.expect("the host socket takes a send buffer size");
|
|
458
|
+
}
|
|
459
|
+
}
|
|
460
|
+
|
|
461
|
+
/// End the socket from outside, as the Invocation's end does, the way
|
|
462
|
+
/// `tcp_abort` ends one: a connect under way or a connection fails with
|
|
463
|
+
/// `ECONNABORTED` and wakes whoever waits on it, and an orphan still
|
|
464
|
+
/// sending lets go of what it holds.
|
|
465
|
+
pub(crate) fn abort(&self) {
|
|
466
|
+
let mut state = self.state();
|
|
467
|
+
if matches!(state.phase, Phase::Connecting | Phase::Connected) {
|
|
468
|
+
Self::done_with_error(&mut state, Errno::ConnectionAborted);
|
|
469
|
+
}
|
|
470
|
+
let orphan = Self::let_go(&mut state);
|
|
471
|
+
drop(state);
|
|
472
|
+
self.wait.wake_up();
|
|
473
|
+
drop(orphan);
|
|
474
|
+
}
|
|
475
|
+
|
|
476
|
+
/// How the connect under way ended, as a non-blocking connect reads it
|
|
477
|
+
/// through `SO_ERROR`: `EAGAIN` while it is under way; success once
|
|
478
|
+
/// connected; otherwise the failure pending, taken once as `sock_error`
|
|
479
|
+
/// takes `sk_err`, or `ENOTCONN` when none is.
|
|
480
|
+
pub fn take_connect_outcome(&self) -> Result<(), Errno> {
|
|
481
|
+
let mut state = self.state();
|
|
482
|
+
match &state.phase {
|
|
483
|
+
Phase::Connecting => Err(Errno::WouldBlock),
|
|
484
|
+
Phase::Connected => Ok(()),
|
|
485
|
+
Phase::Unconnected | Phase::Failed | Phase::Done => {
|
|
486
|
+
Err(state.inet.err.take().unwrap_or(Errno::NotConnected))
|
|
487
|
+
}
|
|
488
|
+
}
|
|
489
|
+
}
|
|
490
|
+
|
|
491
|
+
/// Whether a connect is under way, as a socket in `TCP_SYN_SENT` is.
|
|
492
|
+
pub fn is_connecting(&self) -> bool {
|
|
493
|
+
self.state().phase == Phase::Connecting
|
|
494
|
+
}
|
|
495
|
+
|
|
496
|
+
/// How many bytes a send would take now.
|
|
497
|
+
pub fn send_room(&self) -> usize {
|
|
498
|
+
self.state().stream_wspace()
|
|
499
|
+
}
|
|
500
|
+
|
|
501
|
+
/// Whether everything sent has left for the host, as Linux's `SIOCOUTQ`
|
|
502
|
+
/// reads zero.
|
|
503
|
+
pub fn is_drained(&self) -> bool {
|
|
504
|
+
self.state().write_queue.is_empty()
|
|
505
|
+
}
|
|
506
|
+
|
|
507
|
+
/// Change what the host socket takes; a socket dialed already passes the
|
|
508
|
+
/// change to its host socket at once, and keeps what it held should the
|
|
509
|
+
/// host refuse, as a failed `setsockopt` changes nothing.
|
|
510
|
+
fn set_options_with(&self, change: impl FnOnce(&mut State)) -> Result<(), Errno> {
|
|
511
|
+
let mut state = self.state();
|
|
512
|
+
let kept = (state.keepalive, state.nodelay, state.inet.uc_ttl);
|
|
513
|
+
change(&mut state);
|
|
514
|
+
let Some((stream, _)) = &state.host else {
|
|
515
|
+
return Ok(());
|
|
516
|
+
};
|
|
517
|
+
let set = Self::set_options(SockRef::from(stream), &state);
|
|
518
|
+
set.map_err(|err| {
|
|
519
|
+
(state.keepalive, state.nodelay, state.inet.uc_ttl) = kept;
|
|
520
|
+
Errno::from_io_error(&err)
|
|
521
|
+
})
|
|
522
|
+
}
|
|
523
|
+
}
|
|
524
|
+
|
|
525
|
+
impl Ready for TcpSock {
|
|
526
|
+
fn on_event(&self) {
|
|
527
|
+
let state = self.state();
|
|
528
|
+
self.pump_and_wake(state);
|
|
529
|
+
}
|
|
530
|
+
}
|
|
531
|
+
|
|
532
|
+
/// TCP's answers for its socket file, as `inet_stream_ops` hands each call to
|
|
533
|
+
/// `tcp_prot`.
|
|
534
|
+
impl ProtoOps for TcpSock {
|
|
535
|
+
/// The socket's state first, then `net`'s `connect4`, then within the
|
|
536
|
+
/// connection caps a port, the ruleset, and the dial, as
|
|
537
|
+
/// `inet_stream_connect` runs `connect4` only on a socket connected to
|
|
538
|
+
/// nothing and `tcp_v4_connect` hashes a port before the SYN meets the
|
|
539
|
+
/// filter. A refused destination puts the port back, as that failure
|
|
540
|
+
/// does.
|
|
541
|
+
fn connect(&self, net: &Namespace, addr: SocketAddr) -> Result<(), Errno> {
|
|
542
|
+
self.check_state()?;
|
|
543
|
+
let dest = connect4(net, addr)?;
|
|
544
|
+
net.within_connection_budget(Errno::WouldBlock, || {
|
|
545
|
+
self.connect_from_port(net.ports_of(Protocol::Tcp), || {
|
|
546
|
+
let real = filter(net, &dest, Protocol::Tcp)?;
|
|
547
|
+
self.dial(real, addr, net.open_connections())
|
|
548
|
+
})
|
|
549
|
+
})
|
|
550
|
+
}
|
|
551
|
+
|
|
552
|
+
/// A socket connecting or connected holds its own end already, as
|
|
553
|
+
/// `inet_hash_connect` binds one past `TCP_CLOSE`; one a failed connect or
|
|
554
|
+
/// a reset closed is back in `TCP_CLOSE`.
|
|
555
|
+
fn bind(&self, net: &Namespace, addr: SocketAddr) -> Result<(), Errno> {
|
|
556
|
+
let mut state = self.state();
|
|
557
|
+
let sk_state = state.phase.sk_state();
|
|
558
|
+
state.inet.bind(addr, sk_state, net.ports_of(Protocol::Tcp))
|
|
559
|
+
}
|
|
560
|
+
|
|
561
|
+
/// What the receive buffer holds, up to `buf`'s length, as
|
|
562
|
+
/// `tcp_recvmsg_locked` copies what is queued first. A drained buffer then
|
|
563
|
+
/// answers the peer's end as zero, ahead of any failure as `SOCK_DONE`
|
|
564
|
+
/// is, then a pending failure once; it answers EAGAIN until either comes,
|
|
565
|
+
/// and ENOTCONN on a socket that never connected.
|
|
566
|
+
fn recvmsg(&self, buf: &mut [u8]) -> Result<(usize, Option<SocketAddr>), Errno> {
|
|
567
|
+
let mut state = self.state();
|
|
568
|
+
if !state.receive_queue.is_empty() {
|
|
569
|
+
let take = state.receive_queue.len().min(buf.len());
|
|
570
|
+
for (slot, byte) in buf.iter_mut().zip(state.receive_queue.drain(..take)) {
|
|
571
|
+
*slot = byte;
|
|
572
|
+
}
|
|
573
|
+
self.pump_and_wake(state);
|
|
574
|
+
return Ok((take, None));
|
|
575
|
+
}
|
|
576
|
+
if state.received_end {
|
|
577
|
+
return Ok((0, None));
|
|
578
|
+
}
|
|
579
|
+
if let Some(err) = state.inet.err.take() {
|
|
580
|
+
return Err(err);
|
|
581
|
+
}
|
|
582
|
+
match state.phase {
|
|
583
|
+
_ if state.inet.rcv_shutdown => Ok((0, None)),
|
|
584
|
+
Phase::Failed | Phase::Done => Ok((0, None)),
|
|
585
|
+
Phase::Unconnected => Err(Errno::NotConnected),
|
|
586
|
+
Phase::Connecting | Phase::Connected => Err(Errno::WouldBlock),
|
|
587
|
+
}
|
|
588
|
+
}
|
|
589
|
+
|
|
590
|
+
/// Queue what fits of `buf`, sent as the host socket takes it; a full
|
|
591
|
+
/// buffer answers EAGAIN. A socket not connected answers as
|
|
592
|
+
/// `sk_stream_wait_connect` does: EAGAIN while it connects, a pending
|
|
593
|
+
/// failure once, then EPIPE. A connected one past its failure or its
|
|
594
|
+
/// writing side's shutdown answers as `sk_stream_error`: the failure
|
|
595
|
+
/// once, then EPIPE.
|
|
596
|
+
fn sendmsg(&self, buf: &[u8]) -> Result<usize, Errno> {
|
|
597
|
+
let mut state = self.state();
|
|
598
|
+
match state.phase {
|
|
599
|
+
Phase::Connecting => return Err(Errno::WouldBlock),
|
|
600
|
+
Phase::Connected if !state.inet.send_shutdown && state.inet.err.is_none() => {}
|
|
601
|
+
_ => return Err(state.inet.err.take().unwrap_or(Errno::BrokenPipe)),
|
|
602
|
+
}
|
|
603
|
+
let take = buf.len().min(state.stream_wspace());
|
|
604
|
+
if take == 0 && !buf.is_empty() {
|
|
605
|
+
return Err(Errno::WouldBlock);
|
|
606
|
+
}
|
|
607
|
+
state.write_queue.extend(&buf[..take]);
|
|
608
|
+
self.pump_and_wake(state);
|
|
609
|
+
Ok(take)
|
|
610
|
+
}
|
|
611
|
+
|
|
612
|
+
/// As `tcp_poll` answers: hung up in `TCP_CLOSE` or with both sides shut
|
|
613
|
+
/// down, readable once the reading side is, and writable unless it
|
|
614
|
+
/// connects, always so once its writing side is shut down and otherwise
|
|
615
|
+
/// once the room left is half what is queued, as
|
|
616
|
+
/// `__sk_stream_is_writeable` asks.
|
|
617
|
+
fn poll(&self, table: Option<&mut PollTable>) -> PollMask {
|
|
618
|
+
poll_wait(&self.wait, table);
|
|
619
|
+
let state = self.state();
|
|
620
|
+
let closed = state.phase == Phase::Unconnected || state.phase.is_closed();
|
|
621
|
+
let rcv_shutdown = state.received_end || state.inet.rcv_shutdown || state.phase.is_closed();
|
|
622
|
+
let send_shutdown = state.inet.send_shutdown || state.phase.is_closed();
|
|
623
|
+
let mut mask = PollMask::default();
|
|
624
|
+
if closed || (rcv_shutdown && send_shutdown) {
|
|
625
|
+
mask = mask | PollMask::HUP;
|
|
626
|
+
}
|
|
627
|
+
if !state.receive_queue.is_empty() || rcv_shutdown {
|
|
628
|
+
mask = mask | PollMask::IN;
|
|
629
|
+
}
|
|
630
|
+
let writable = state.stream_wspace() >= state.write_queue.len() / 2;
|
|
631
|
+
if state.phase != Phase::Connecting && (send_shutdown || writable) {
|
|
632
|
+
mask = mask | PollMask::OUT;
|
|
633
|
+
}
|
|
634
|
+
if state.inet.err.is_some() {
|
|
635
|
+
mask = mask | PollMask::ERR;
|
|
636
|
+
}
|
|
637
|
+
mask
|
|
638
|
+
}
|
|
639
|
+
|
|
640
|
+
/// Shut the writing side down once what is queued is sent, or the reading
|
|
641
|
+
/// side, which still reads what arrived, as `inet_shutdown` sets
|
|
642
|
+
/// `SEND_SHUTDOWN` and `RCV_SHUTDOWN`; a socket not connected marks them
|
|
643
|
+
/// and answers `ENOTCONN`. One still connecting is disconnected instead,
|
|
644
|
+
/// back to unconnected with nothing marked and `ECONNRESET` pending, as
|
|
645
|
+
/// `inet_shutdown` disconnects one in `TCP_SYN_SENT` and
|
|
646
|
+
/// `tcp_disconnect` sets `sk_err`; it keeps its place until released.
|
|
647
|
+
fn shutdown(&self, how: Shutdown) -> Result<(), Errno> {
|
|
648
|
+
let mut state = self.state();
|
|
649
|
+
if state.phase == Phase::Connecting {
|
|
650
|
+
Self::close_host(&mut state);
|
|
651
|
+
Self::disconnect(&mut state);
|
|
652
|
+
state.inet.err = Some(Errno::ConnectionReset);
|
|
653
|
+
drop(state);
|
|
654
|
+
self.wait.wake_up();
|
|
655
|
+
return Ok(());
|
|
656
|
+
}
|
|
657
|
+
let sk_state = state.phase.sk_state();
|
|
658
|
+
let shut = state.inet.shutdown(how, sk_state);
|
|
659
|
+
self.pump_and_wake(state);
|
|
660
|
+
shut
|
|
661
|
+
}
|
|
662
|
+
|
|
663
|
+
fn protocol(&self) -> Protocol {
|
|
664
|
+
Protocol::Tcp
|
|
665
|
+
}
|
|
666
|
+
|
|
667
|
+
fn getname(&self, peer: bool) -> Result<SocketAddr, Errno> {
|
|
668
|
+
let state = self.state();
|
|
669
|
+
state.inet.getname(peer, state.phase.sk_state())
|
|
670
|
+
}
|
|
671
|
+
|
|
672
|
+
/// Its own keepalive flag and probes, never the host's, beside the
|
|
673
|
+
/// buffers and the hop limit.
|
|
674
|
+
fn getsockopt(&self, opt: SockOpt) -> Result<u32, Errno> {
|
|
675
|
+
let state = self.state();
|
|
676
|
+
match opt {
|
|
677
|
+
SockOpt::KeepAlive => Ok(u32::from(state.keepalive.on)),
|
|
678
|
+
SockOpt::KeepIdle => Ok(state.keepalive.idle),
|
|
679
|
+
SockOpt::KeepIntvl => Ok(state.keepalive.interval),
|
|
680
|
+
SockOpt::KeepCnt => Ok(state.keepalive.count),
|
|
681
|
+
SockOpt::NoDelay => Ok(u32::from(state.nodelay)),
|
|
682
|
+
_ => state.inet.getsockopt(opt),
|
|
683
|
+
}
|
|
684
|
+
}
|
|
685
|
+
|
|
686
|
+
/// The probes and the hop limit reach a host socket already dialed at
|
|
687
|
+
/// once; each probe bound is Linux's, as `tcp_sock_set_keepidle` and its
|
|
688
|
+
/// kin refuse past it with EINVAL.
|
|
689
|
+
fn setsockopt(&self, opt: SockOpt, value: u32) -> Result<(), Errno> {
|
|
690
|
+
match opt {
|
|
691
|
+
SockOpt::KeepAlive => self.set_options_with(|state| state.keepalive.on = value != 0),
|
|
692
|
+
SockOpt::KeepIdle => {
|
|
693
|
+
ensure_within(value, MAX_TCP_KEEPIDLE)?;
|
|
694
|
+
self.set_options_with(|state| state.keepalive.idle = value)
|
|
695
|
+
}
|
|
696
|
+
SockOpt::KeepIntvl => {
|
|
697
|
+
ensure_within(value, MAX_TCP_KEEPINTVL)?;
|
|
698
|
+
self.set_options_with(|state| state.keepalive.interval = value)
|
|
699
|
+
}
|
|
700
|
+
SockOpt::KeepCnt => {
|
|
701
|
+
ensure_within(value, MAX_TCP_KEEPCNT)?;
|
|
702
|
+
self.set_options_with(|state| state.keepalive.count = value)
|
|
703
|
+
}
|
|
704
|
+
SockOpt::NoDelay => self.set_options_with(|state| state.nodelay = value != 0),
|
|
705
|
+
_ => {
|
|
706
|
+
let mut guard = self.state();
|
|
707
|
+
let state = &mut *guard;
|
|
708
|
+
let host = state.host.as_ref().map(|(stream, _)| SockRef::from(stream));
|
|
709
|
+
state.inet.setsockopt(opt, value, host)
|
|
710
|
+
}
|
|
711
|
+
}
|
|
712
|
+
}
|
|
713
|
+
|
|
714
|
+
/// Let go of the socket once every view is gone, as `sock_close` runs on
|
|
715
|
+
/// the last `fput` and `__tcp_close` closes it: bytes still queued leave
|
|
716
|
+
/// before the FIN, the socket holding itself and its place until then,
|
|
717
|
+
/// and bytes that arrived unread reset the connection instead.
|
|
718
|
+
fn release(&self) {
|
|
719
|
+
let mut state = self.state();
|
|
720
|
+
let unread = !std::mem::take(&mut state.receive_queue).is_empty();
|
|
721
|
+
if unread {
|
|
722
|
+
Self::reset_host(&mut state);
|
|
723
|
+
} else if state.phase == Phase::Connected && !state.write_queue.is_empty() {
|
|
724
|
+
state.inet.mark_shutdown(Shutdown::Both);
|
|
725
|
+
state.orphan = self.this.upgrade();
|
|
726
|
+
self.pump_and_wake(state);
|
|
727
|
+
return;
|
|
728
|
+
}
|
|
729
|
+
let orphan = Self::let_go(&mut state);
|
|
730
|
+
drop(state);
|
|
731
|
+
self.wait.wake_up();
|
|
732
|
+
drop(orphan);
|
|
733
|
+
}
|
|
734
|
+
}
|
|
735
|
+
|
|
736
|
+
#[cfg(test)]
|
|
737
|
+
mod tests {
|
|
738
|
+
use std::io::{Read, Write};
|
|
739
|
+
use std::net::TcpListener;
|
|
740
|
+
use std::time::Duration;
|
|
741
|
+
|
|
742
|
+
use super::*;
|
|
743
|
+
use crate::net::socket::testing::wait_for;
|
|
744
|
+
use crate::net::{sock_alloc_file, HostInet};
|
|
745
|
+
use crate::security::prepare_creds;
|
|
746
|
+
use crate::vfs::File;
|
|
747
|
+
|
|
748
|
+
/// A socket connecting to `addr` through the host.
|
|
749
|
+
fn dial(addr: SocketAddr) -> Arc<TcpSock> {
|
|
750
|
+
let sock = TcpSock::new(Arc::new(HostInet), &prepare_creds(&[], None))
|
|
751
|
+
.expect("an unbounded socket is made");
|
|
752
|
+
sock.dial(addr, addr, &OpenConnections::new(None))
|
|
753
|
+
.expect("an uncapped socket connects");
|
|
754
|
+
sock
|
|
755
|
+
}
|
|
756
|
+
|
|
757
|
+
/// A namespace whose ruleset admits 127.0.0.1 on `ports`, its sockets
|
|
758
|
+
/// counting against `open`.
|
|
759
|
+
fn loopback(ports: &[u16], open: Arc<OpenConnections>) -> Namespace {
|
|
760
|
+
use crate::net::Backends;
|
|
761
|
+
use crate::network::{Builder, Endpoint, Network};
|
|
762
|
+
let mut entry = Builder::default();
|
|
763
|
+
for port in ports {
|
|
764
|
+
entry.endpoint(
|
|
765
|
+
Endpoint::new("127.0.0.1", *port)
|
|
766
|
+
.unwrap()
|
|
767
|
+
.with_protocol(Protocol::Tcp),
|
|
768
|
+
);
|
|
769
|
+
}
|
|
770
|
+
let network = Network::new("loopback", Arc::new(entry)).unwrap();
|
|
771
|
+
Namespace::new([&network], &Backends::default(), open, None).expect("the endpoints compile")
|
|
772
|
+
}
|
|
773
|
+
|
|
774
|
+
/// A socket file connecting to a loopback listener, and the peer the
|
|
775
|
+
/// listener accepted.
|
|
776
|
+
fn connected_socket() -> (Arc<TcpSock>, File, std::net::TcpStream) {
|
|
777
|
+
let listener = TcpListener::bind("127.0.0.1:0").expect("a loopback listener");
|
|
778
|
+
let sock = dial(listener.local_addr().unwrap());
|
|
779
|
+
let file = sock_alloc_file(sock.clone(), &Arc::default());
|
|
780
|
+
let (peer, _) = listener.accept().expect("the listener accepts");
|
|
781
|
+
wait_for(|table| file.poll(table), PollMask::OUT);
|
|
782
|
+
(sock, file, peer)
|
|
783
|
+
}
|
|
784
|
+
|
|
785
|
+
// @behavior RT-381
|
|
786
|
+
#[test]
|
|
787
|
+
fn a_socket_file_never_waits() {
|
|
788
|
+
let (_sock, mut file, _peer) = connected_socket();
|
|
789
|
+
file.setfl(false, false);
|
|
790
|
+
let started = std::time::Instant::now();
|
|
791
|
+
let read = crate::sched::testing::within_max_wait(|| file.read(&mut [0; 8]));
|
|
792
|
+
assert_eq!(
|
|
793
|
+
(read, started.elapsed() < Duration::from_secs(1)),
|
|
794
|
+
(Err(Errno::WouldBlock), true),
|
|
795
|
+
"File::read of a connected socket whose peer sent nothing must answer EAGAIN at \
|
|
796
|
+
once, its non-blocking flag cleared or not, since WASI's sockets never block"
|
|
797
|
+
);
|
|
798
|
+
}
|
|
799
|
+
|
|
800
|
+
// @behavior RT-365
|
|
801
|
+
#[test]
|
|
802
|
+
fn a_guest_socket_keeps_nagles_algorithm() {
|
|
803
|
+
let (sock, _file, _peer) = connected_socket();
|
|
804
|
+
let nodelay = sock
|
|
805
|
+
.state()
|
|
806
|
+
.host
|
|
807
|
+
.as_ref()
|
|
808
|
+
.map(|(stream, _)| stream.nodelay().unwrap());
|
|
809
|
+
assert_eq!(
|
|
810
|
+
nodelay,
|
|
811
|
+
Some(false),
|
|
812
|
+
"a guest's TCP socket connected through the Protocol Family must leave the stream's \
|
|
813
|
+
TCP_NODELAY off, as Linux's tcp_init_sock does, since WASI gives the guest no \
|
|
814
|
+
option to set it"
|
|
815
|
+
);
|
|
816
|
+
}
|
|
817
|
+
|
|
818
|
+
#[test]
|
|
819
|
+
fn a_socket_asked_for_tcp_nodelay_gives_it_to_its_host_socket() {
|
|
820
|
+
let (sock, _file, _peer) = connected_socket();
|
|
821
|
+
sock.setsockopt(SockOpt::NoDelay, 1)
|
|
822
|
+
.expect("TCP takes TCP_NODELAY");
|
|
823
|
+
let nodelay = sock
|
|
824
|
+
.state()
|
|
825
|
+
.host
|
|
826
|
+
.as_ref()
|
|
827
|
+
.map(|(stream, _)| stream.nodelay().unwrap());
|
|
828
|
+
assert_eq!(
|
|
829
|
+
(sock.getsockopt(SockOpt::NoDelay), nodelay),
|
|
830
|
+
(Ok(1), Some(true)),
|
|
831
|
+
"a TCP socket asked for TCP_NODELAY must read it back and pass it to the host \
|
|
832
|
+
socket it dialed, so each write leaves without Nagle's delay"
|
|
833
|
+
);
|
|
834
|
+
}
|
|
835
|
+
|
|
836
|
+
/// Whether the host socket `sock` dialed sends keepalive probes.
|
|
837
|
+
fn host_keepalive(sock: &TcpSock) -> Option<bool> {
|
|
838
|
+
sock.state()
|
|
839
|
+
.host
|
|
840
|
+
.as_ref()
|
|
841
|
+
.map(|(stream, _)| SockRef::from(stream).keepalive().unwrap())
|
|
842
|
+
}
|
|
843
|
+
|
|
844
|
+
// @behavior RT-366
|
|
845
|
+
#[test]
|
|
846
|
+
fn a_socket_holds_its_options_and_gives_them_to_the_host_socket() {
|
|
847
|
+
let listener = TcpListener::bind("127.0.0.1:0").expect("a loopback listener");
|
|
848
|
+
let addr = listener.local_addr().unwrap();
|
|
849
|
+
let sock = TcpSock::new(Arc::new(HostInet), &prepare_creds(&[], None))
|
|
850
|
+
.expect("an unbounded socket is made");
|
|
851
|
+
sock.setsockopt(SockOpt::KeepAlive, 1)
|
|
852
|
+
.expect("an unconnected socket takes an option");
|
|
853
|
+
let keepalive = |sock: &TcpSock| sock.getsockopt(SockOpt::KeepAlive).unwrap();
|
|
854
|
+
let before = (keepalive(&sock), host_keepalive(&sock));
|
|
855
|
+
sock.dial(addr, addr, &OpenConnections::new(None))
|
|
856
|
+
.expect("an uncapped socket connects");
|
|
857
|
+
let dialed = host_keepalive(&sock);
|
|
858
|
+
sock.setsockopt(SockOpt::KeepAlive, 0)
|
|
859
|
+
.expect("a connected socket takes an option");
|
|
860
|
+
let after = (keepalive(&sock), host_keepalive(&sock));
|
|
861
|
+
assert_eq!(
|
|
862
|
+
(before, dialed, after),
|
|
863
|
+
((1, None), Some(true), (0, Some(false))),
|
|
864
|
+
"SO_KEEPALIVE set before a connect must be held by the socket and reach the host \
|
|
865
|
+
stream the Protocol Family dials; set once connected, it must reach that stream at \
|
|
866
|
+
once"
|
|
867
|
+
);
|
|
868
|
+
}
|
|
869
|
+
|
|
870
|
+
// @behavior RT-367
|
|
871
|
+
// Windows sets keepalive timing through SIO_KEEPALIVE_VALS, which reads
|
|
872
|
+
// nothing back, so only the hosts that read it witness the dialed values.
|
|
873
|
+
#[cfg(not(windows))]
|
|
874
|
+
#[test]
|
|
875
|
+
fn a_socket_bounds_its_keepalive_probes_as_linux_and_dials_with_them() {
|
|
876
|
+
let listener = TcpListener::bind("127.0.0.1:0").expect("a loopback listener");
|
|
877
|
+
let addr = listener.local_addr().unwrap();
|
|
878
|
+
let sock = TcpSock::new(Arc::new(HostInet), &prepare_creds(&[], None))
|
|
879
|
+
.expect("an unbounded socket is made");
|
|
880
|
+
let get = |opt| sock.getsockopt(opt).unwrap();
|
|
881
|
+
let defaults = (
|
|
882
|
+
get(SockOpt::KeepIdle),
|
|
883
|
+
get(SockOpt::KeepIntvl),
|
|
884
|
+
get(SockOpt::KeepCnt),
|
|
885
|
+
);
|
|
886
|
+
let refused = [
|
|
887
|
+
sock.setsockopt(SockOpt::KeepIdle, 0),
|
|
888
|
+
sock.setsockopt(SockOpt::KeepIdle, 32768),
|
|
889
|
+
sock.setsockopt(SockOpt::KeepIntvl, 32768),
|
|
890
|
+
sock.setsockopt(SockOpt::KeepCnt, 128),
|
|
891
|
+
];
|
|
892
|
+
sock.setsockopt(SockOpt::KeepIdle, 30)
|
|
893
|
+
.expect("an idle time Linux takes");
|
|
894
|
+
sock.setsockopt(SockOpt::KeepIntvl, 10)
|
|
895
|
+
.expect("an interval Linux takes");
|
|
896
|
+
sock.setsockopt(SockOpt::KeepCnt, 3)
|
|
897
|
+
.expect("a count Linux takes");
|
|
898
|
+
sock.dial(addr, addr, &OpenConnections::new(None))
|
|
899
|
+
.expect("an uncapped socket connects");
|
|
900
|
+
let host = sock.state().host.as_ref().map(|(stream, _)| {
|
|
901
|
+
let host = SockRef::from(stream);
|
|
902
|
+
(
|
|
903
|
+
host.tcp_keepalive_time().unwrap(),
|
|
904
|
+
host.tcp_keepalive_interval().unwrap(),
|
|
905
|
+
host.tcp_keepalive_retries().unwrap(),
|
|
906
|
+
)
|
|
907
|
+
});
|
|
908
|
+
assert_eq!(
|
|
909
|
+
(defaults, refused, host),
|
|
910
|
+
(
|
|
911
|
+
(7200, 75, 9),
|
|
912
|
+
[(); 4].map(|()| Err(Errno::InvalidInput)),
|
|
913
|
+
Some((Duration::from_secs(30), Duration::from_secs(10), 3))
|
|
914
|
+
),
|
|
915
|
+
"a socket must read Linux's keepalive defaults, refuse with EINVAL an idle time or \
|
|
916
|
+
interval outside 1 to 32767 and a count outside 1 to 127, and give the host stream it \
|
|
917
|
+
dials the probes it was set"
|
|
918
|
+
);
|
|
919
|
+
}
|
|
920
|
+
|
|
921
|
+
// @behavior RT-369
|
|
922
|
+
#[test]
|
|
923
|
+
fn a_socket_holds_its_hop_limit_for_the_host_socket() {
|
|
924
|
+
let listener = TcpListener::bind("127.0.0.1:0").expect("a loopback listener");
|
|
925
|
+
let addr = listener.local_addr().unwrap();
|
|
926
|
+
let sock = TcpSock::new(Arc::new(HostInet), &prepare_creds(&[], None))
|
|
927
|
+
.expect("an unbounded socket is made");
|
|
928
|
+
let host_ttl = |sock: &TcpSock| {
|
|
929
|
+
sock.state()
|
|
930
|
+
.host
|
|
931
|
+
.as_ref()
|
|
932
|
+
.map(|(stream, _)| SockRef::from(stream).ttl_v4().unwrap())
|
|
933
|
+
};
|
|
934
|
+
let default = sock.getsockopt(SockOpt::Ttl);
|
|
935
|
+
let refused = [
|
|
936
|
+
sock.setsockopt(SockOpt::Ttl, 0),
|
|
937
|
+
sock.setsockopt(SockOpt::Ttl, 256),
|
|
938
|
+
];
|
|
939
|
+
sock.setsockopt(SockOpt::Ttl, 7)
|
|
940
|
+
.expect("a hop limit Linux takes");
|
|
941
|
+
sock.dial(addr, addr, &OpenConnections::new(None))
|
|
942
|
+
.expect("an uncapped socket connects");
|
|
943
|
+
let dialed = host_ttl(&sock);
|
|
944
|
+
sock.setsockopt(SockOpt::Ttl, 9)
|
|
945
|
+
.expect("a connected socket takes a hop limit");
|
|
946
|
+
assert_eq!(
|
|
947
|
+
(
|
|
948
|
+
default,
|
|
949
|
+
refused,
|
|
950
|
+
dialed,
|
|
951
|
+
sock.getsockopt(SockOpt::Ttl),
|
|
952
|
+
host_ttl(&sock)
|
|
953
|
+
),
|
|
954
|
+
(
|
|
955
|
+
Ok(64),
|
|
956
|
+
[(); 2].map(|()| Err(Errno::InvalidInput)),
|
|
957
|
+
Some(7),
|
|
958
|
+
Ok(9),
|
|
959
|
+
Some(9)
|
|
960
|
+
),
|
|
961
|
+
"a TCP socket must read Linux's default hop limit rather than the host's, refuse zero \
|
|
962
|
+
and one past 255 with EINVAL, and give the host stream it dials the limit set, at \
|
|
963
|
+
once once connected"
|
|
964
|
+
);
|
|
965
|
+
}
|
|
966
|
+
|
|
967
|
+
// @behavior RT-368
|
|
968
|
+
#[test]
|
|
969
|
+
fn a_socket_doubles_its_buffer_sizes_and_holds_its_queues_within_them() {
|
|
970
|
+
let (sock, file, mut peer) = connected_socket();
|
|
971
|
+
let get = |opt| sock.getsockopt(opt).unwrap() as usize;
|
|
972
|
+
let defaults = (get(SockOpt::RcvBuf), get(SockOpt::SndBuf));
|
|
973
|
+
sock.setsockopt(SockOpt::RcvBuf, 10_000_000).unwrap();
|
|
974
|
+
let capped = get(SockOpt::RcvBuf);
|
|
975
|
+
sock.setsockopt(SockOpt::SndBuf, 1000).unwrap();
|
|
976
|
+
sock.setsockopt(SockOpt::RcvBuf, 1000).unwrap();
|
|
977
|
+
let set = (get(SockOpt::RcvBuf), get(SockOpt::SndBuf), sock.send_room());
|
|
978
|
+
peer.write_all(&[7; 10_000]).expect("the peer writes");
|
|
979
|
+
wait_for(|table| file.poll(table), PollMask::IN);
|
|
980
|
+
let held = sock.state().receive_queue.len();
|
|
981
|
+
assert_eq!(
|
|
982
|
+
(defaults, capped, set, held <= 2304),
|
|
983
|
+
(
|
|
984
|
+
(MAX_SOCKET_BUFFER, MAX_SOCKET_BUFFER),
|
|
985
|
+
MAX_SOCKET_BUFFER,
|
|
986
|
+
(2304, 4608, 4608),
|
|
987
|
+
true
|
|
988
|
+
),
|
|
989
|
+
"SO_RCVBUF and SO_SNDBUF must double a size as Linux does, within the socket's \
|
|
990
|
+
reserved buffer and above Linux's least, and the queues must hold no more than they \
|
|
991
|
+
say; the receive queue held {held}"
|
|
992
|
+
);
|
|
993
|
+
}
|
|
994
|
+
|
|
995
|
+
// @behavior RT-385
|
|
996
|
+
#[test]
|
|
997
|
+
fn a_socket_binds_once_and_not_after_its_connect() {
|
|
998
|
+
let any: SocketAddr = "0.0.0.0:0".parse().unwrap();
|
|
999
|
+
let net = loopback(&[], OpenConnections::new(None));
|
|
1000
|
+
let cred = prepare_creds(&[], None);
|
|
1001
|
+
let fresh = TcpSock::new(Arc::new(HostInet), &cred).expect("an unbounded socket is made");
|
|
1002
|
+
let (first, second) = (fresh.bind(&net, any), fresh.bind(&net, any));
|
|
1003
|
+
let ipv6 = TcpSock::new(Arc::new(HostInet), &cred)
|
|
1004
|
+
.expect("an unbounded socket is made")
|
|
1005
|
+
.bind(&net, "[::]:0".parse().unwrap());
|
|
1006
|
+
let (connected, _file, _peer) = connected_socket();
|
|
1007
|
+
let udp_peer = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
1008
|
+
let udp = crate::net::UdpSock::new(&cred).expect("an unbounded socket is made");
|
|
1009
|
+
let family: Arc<dyn ProtocolFamily> = Arc::new(HostInet);
|
|
1010
|
+
let at = udp_peer.local_addr().unwrap();
|
|
1011
|
+
udp.dial(&family, at, at, &OpenConnections::new(None))
|
|
1012
|
+
.expect("an uncapped socket connects");
|
|
1013
|
+
assert_eq!(
|
|
1014
|
+
(
|
|
1015
|
+
first,
|
|
1016
|
+
second,
|
|
1017
|
+
ipv6,
|
|
1018
|
+
connected.bind(&net, any),
|
|
1019
|
+
udp.bind(&net, any)
|
|
1020
|
+
),
|
|
1021
|
+
(
|
|
1022
|
+
Ok(()),
|
|
1023
|
+
Err(Errno::InvalidInput),
|
|
1024
|
+
Err(Errno::AddressFamilyNotSupported),
|
|
1025
|
+
Err(Errno::InvalidInput),
|
|
1026
|
+
Err(Errno::InvalidInput)
|
|
1027
|
+
),
|
|
1028
|
+
"a socket's bind must take its own end once, answer EINVAL to a second bind and to a \
|
|
1029
|
+
bind after a TCP or UDP connect bound it, and EAFNOSUPPORT to IPv6, as Linux's \
|
|
1030
|
+
inet_bind"
|
|
1031
|
+
);
|
|
1032
|
+
}
|
|
1033
|
+
|
|
1034
|
+
// @behavior RT-386
|
|
1035
|
+
#[test]
|
|
1036
|
+
fn a_failed_connect_gives_back_a_port_its_bind_did_not_name() {
|
|
1037
|
+
// A privileged port no test can bind, so every connect to it is
|
|
1038
|
+
// refused and no other socket is handed it meanwhile.
|
|
1039
|
+
let closed = SocketAddr::from(([127, 0, 0, 1], 1));
|
|
1040
|
+
let cred = prepare_creds(&[], None);
|
|
1041
|
+
let net = loopback(&[], OpenConnections::new(None));
|
|
1042
|
+
let failed_after = |own: &str| {
|
|
1043
|
+
let sock =
|
|
1044
|
+
TcpSock::new(Arc::new(HostInet), &cred).expect("an unbounded socket is made");
|
|
1045
|
+
sock.bind(&net, own.parse().unwrap())
|
|
1046
|
+
.expect("a fresh socket binds");
|
|
1047
|
+
sock.dial(closed, closed, &OpenConnections::new(None))
|
|
1048
|
+
.expect("an uncapped socket connects");
|
|
1049
|
+
let file = sock_alloc_file(sock.clone(), &Arc::default());
|
|
1050
|
+
wait_for(|table| file.poll(table), PollMask::ERR);
|
|
1051
|
+
sock.bind(&net, "0.0.0.0:0".parse().unwrap())
|
|
1052
|
+
};
|
|
1053
|
+
assert_eq!(
|
|
1054
|
+
(failed_after("0.0.0.0:0"), failed_after("127.0.0.1:40000")),
|
|
1055
|
+
(Ok(()), Err(Errno::InvalidInput)),
|
|
1056
|
+
"a TCP socket bound to port 0 must bind again once its connect to a closed port fails, \
|
|
1057
|
+
and one bound to a named port must still answer EINVAL, as tcp_set_state puts the \
|
|
1058
|
+
port on TCP_CLOSE unless SOCK_BINDPORT_LOCK keeps it"
|
|
1059
|
+
);
|
|
1060
|
+
}
|
|
1061
|
+
|
|
1062
|
+
// @behavior RT-390
|
|
1063
|
+
#[test]
|
|
1064
|
+
fn a_port_one_socket_holds_is_no_other_sockets() {
|
|
1065
|
+
let net = loopback(&[], OpenConnections::new(None));
|
|
1066
|
+
let cred = prepare_creds(&[], None);
|
|
1067
|
+
let socket =
|
|
1068
|
+
|| TcpSock::new(Arc::new(HostInet), &cred).expect("an unbounded socket is made");
|
|
1069
|
+
let (named, free, again) = (socket(), socket(), socket());
|
|
1070
|
+
let answers = (
|
|
1071
|
+
named.bind(&net, "0.0.0.0:32768".parse().unwrap()),
|
|
1072
|
+
free.bind(&net, "0.0.0.0:0".parse().unwrap()),
|
|
1073
|
+
again.bind(&net, "0.0.0.0:32768".parse().unwrap()),
|
|
1074
|
+
);
|
|
1075
|
+
let free_port = free.getname(false).unwrap().port();
|
|
1076
|
+
drop(named);
|
|
1077
|
+
assert_eq!(
|
|
1078
|
+
(
|
|
1079
|
+
answers,
|
|
1080
|
+
free_port,
|
|
1081
|
+
again.bind(&net, "0.0.0.0:32768".parse().unwrap())
|
|
1082
|
+
),
|
|
1083
|
+
((Ok(()), Ok(()), Err(Errno::AddressInUse)), 32769, Ok(())),
|
|
1084
|
+
"a TCP socket's bind must pass over a port another socket holds for port 0, answer \
|
|
1085
|
+
EADDRINUSE to it by name, and take it once the holder is gone, as \
|
|
1086
|
+
inet_csk_get_port finds a bucket taken"
|
|
1087
|
+
);
|
|
1088
|
+
}
|
|
1089
|
+
|
|
1090
|
+
// @behavior RT-389
|
|
1091
|
+
#[test]
|
|
1092
|
+
fn a_connect_refused_for_a_full_count_or_by_the_ruleset_gives_back_its_port() {
|
|
1093
|
+
let listener = TcpListener::bind("127.0.0.1:0").expect("a loopback listener");
|
|
1094
|
+
let at = listener.local_addr().unwrap();
|
|
1095
|
+
let cred = prepare_creds(&[], None);
|
|
1096
|
+
let refused_after = |net: &Namespace, to: SocketAddr| {
|
|
1097
|
+
let sock =
|
|
1098
|
+
TcpSock::new(Arc::new(HostInet), &cred).expect("an unbounded socket is made");
|
|
1099
|
+
let connected = ProtoOps::connect(&*sock, net, to);
|
|
1100
|
+
(connected, sock.bind(net, "0.0.0.0:0".parse().unwrap()))
|
|
1101
|
+
};
|
|
1102
|
+
let full = loopback(&[at.port()], OpenConnections::new(Some(0)));
|
|
1103
|
+
let filtered = loopback(&[at.port()], OpenConnections::new(None));
|
|
1104
|
+
assert_eq!(
|
|
1105
|
+
(
|
|
1106
|
+
refused_after(&full, at),
|
|
1107
|
+
refused_after(&filtered, SocketAddr::from(([127, 0, 0, 1], 1)))
|
|
1108
|
+
),
|
|
1109
|
+
(
|
|
1110
|
+
(Err(Errno::WouldBlock), Ok(())),
|
|
1111
|
+
(Err(Errno::PermissionDenied), Ok(()))
|
|
1112
|
+
),
|
|
1113
|
+
"a TCP socket's connect under a full open connection count, and one to a destination \
|
|
1114
|
+
the ruleset refuses, must answer EAGAIN and EACCES and give back the port it held, \
|
|
1115
|
+
so a bind to port 0 then succeeds, as tcp_v4_connect's failure puts the port it \
|
|
1116
|
+
hashed"
|
|
1117
|
+
);
|
|
1118
|
+
}
|
|
1119
|
+
|
|
1120
|
+
// @behavior RT-384
|
|
1121
|
+
#[test]
|
|
1122
|
+
fn a_socket_polls_writable_once_its_room_is_half_what_it_queued() {
|
|
1123
|
+
let (sock, file, _peer) = connected_socket();
|
|
1124
|
+
sock.setsockopt(SockOpt::SndBuf, 1000).unwrap();
|
|
1125
|
+
let polled_with = |queued: usize| {
|
|
1126
|
+
let mut state = sock.state();
|
|
1127
|
+
if let Some((stream, registration)) = state.host.as_mut() {
|
|
1128
|
+
registration.deregister(stream);
|
|
1129
|
+
}
|
|
1130
|
+
state.write_queue = std::iter::repeat_n(0, queued).collect();
|
|
1131
|
+
drop(state);
|
|
1132
|
+
file.poll(None).contains(PollMask::OUT)
|
|
1133
|
+
};
|
|
1134
|
+
assert_eq!(
|
|
1135
|
+
(polled_with(3072), polled_with(3073)),
|
|
1136
|
+
(true, false),
|
|
1137
|
+
"a TCP socket whose send buffer reads 4608 must poll writable with 3072 bytes queued, \
|
|
1138
|
+
its room then half of them, and not with 3073, as __sk_stream_is_writeable asks"
|
|
1139
|
+
);
|
|
1140
|
+
}
|
|
1141
|
+
|
|
1142
|
+
// @behavior RT-342
|
|
1143
|
+
#[test]
|
|
1144
|
+
fn a_socket_connects_without_blocking_and_its_poll_wakes() {
|
|
1145
|
+
let (sock, _file, _peer) = connected_socket();
|
|
1146
|
+
assert_eq!(
|
|
1147
|
+
sock.take_connect_outcome(),
|
|
1148
|
+
Ok(()),
|
|
1149
|
+
"a non-blocking connect to a listening peer must settle as connected once the \
|
|
1150
|
+
socket's poll finds it writable"
|
|
1151
|
+
);
|
|
1152
|
+
}
|
|
1153
|
+
|
|
1154
|
+
// @behavior RT-356
|
|
1155
|
+
#[test]
|
|
1156
|
+
fn a_connected_socket_asked_to_connect_again_answers_eisconn() {
|
|
1157
|
+
let (sock, _file, _peer) = connected_socket();
|
|
1158
|
+
sock.take_connect_outcome().expect("the socket connected");
|
|
1159
|
+
let addr = sock.getname(true).expect("a connected socket has a peer");
|
|
1160
|
+
let (was_reset, _reset_file) = reset_socket();
|
|
1161
|
+
// The ruleset admits the peer only, under a cap already spent.
|
|
1162
|
+
let net = loopback(&[addr.port()], OpenConnections::new(Some(0)));
|
|
1163
|
+
let refused = SocketAddr::from(([127, 0, 0, 1], 1));
|
|
1164
|
+
let again = |sock: &TcpSock, to| ProtoOps::connect(sock, &net, to);
|
|
1165
|
+
assert_eq!(
|
|
1166
|
+
[
|
|
1167
|
+
again(&sock, addr),
|
|
1168
|
+
again(&was_reset, addr),
|
|
1169
|
+
again(&sock, refused)
|
|
1170
|
+
],
|
|
1171
|
+
[
|
|
1172
|
+
Err(Errno::AlreadyConnected),
|
|
1173
|
+
Err(Errno::AlreadyConnected),
|
|
1174
|
+
Err(Errno::AlreadyConnected)
|
|
1175
|
+
],
|
|
1176
|
+
"a TCP socket's connect on a connected socket, and on one connected then reset, must \
|
|
1177
|
+
answer EISCONN, as __inet_stream_connect does, before the ruleset judges the \
|
|
1178
|
+
destination or the connection caps are asked"
|
|
1179
|
+
);
|
|
1180
|
+
}
|
|
1181
|
+
|
|
1182
|
+
// @behavior RT-364
|
|
1183
|
+
#[test]
|
|
1184
|
+
fn a_socket_whose_connect_failed_answers_the_failure_then_connects_afresh() {
|
|
1185
|
+
let closed = TcpListener::bind("127.0.0.1:0").expect("a loopback listener");
|
|
1186
|
+
let refused_at = closed.local_addr().unwrap();
|
|
1187
|
+
drop(closed);
|
|
1188
|
+
// One place, which the failed socket still holds, so connecting
|
|
1189
|
+
// afresh must reuse it rather than ask the full cap for another.
|
|
1190
|
+
let listener = TcpListener::bind("127.0.0.1:0").expect("a loopback listener");
|
|
1191
|
+
let open_at = listener.local_addr().unwrap();
|
|
1192
|
+
let net = loopback(
|
|
1193
|
+
&[refused_at.port(), open_at.port()],
|
|
1194
|
+
OpenConnections::new(Some(1)),
|
|
1195
|
+
);
|
|
1196
|
+
let sock = TcpSock::new(Arc::new(HostInet), &prepare_creds(&[], None))
|
|
1197
|
+
.expect("an unbounded socket is made");
|
|
1198
|
+
ProtoOps::connect(&*sock, &net, refused_at).expect("a socket under a cap of one connects");
|
|
1199
|
+
let file = sock_alloc_file(sock.clone(), &Arc::default());
|
|
1200
|
+
wait_for(|table| file.poll(table), PollMask::ERR);
|
|
1201
|
+
let connect = || ProtoOps::connect(&*sock, &net, open_at);
|
|
1202
|
+
let message = "a TCP socket's connect after its connect was refused must answer \
|
|
1203
|
+
ECONNREFUSED and dial nothing, then connect afresh under a cap of one, on \
|
|
1204
|
+
the place it holds, with none of the failure left, as Linux disconnects a \
|
|
1205
|
+
failed socket";
|
|
1206
|
+
let tries = (connect(), connect());
|
|
1207
|
+
assert_eq!(tries, (Err(Errno::ConnectionRefused), Ok(())), "{message}");
|
|
1208
|
+
listener
|
|
1209
|
+
.accept()
|
|
1210
|
+
.expect("the listener accepts the fresh connect");
|
|
1211
|
+
wait_for(|table| file.poll(table), PollMask::OUT);
|
|
1212
|
+
assert_eq!(
|
|
1213
|
+
(
|
|
1214
|
+
sock.take_connect_outcome(),
|
|
1215
|
+
file.poll(None).contains(PollMask::ERR)
|
|
1216
|
+
),
|
|
1217
|
+
(Ok(()), false),
|
|
1218
|
+
"{message}"
|
|
1219
|
+
);
|
|
1220
|
+
}
|
|
1221
|
+
|
|
1222
|
+
// @behavior RT-388
|
|
1223
|
+
#[test]
|
|
1224
|
+
fn a_socket_whose_connect_failed_takes_a_fresh_virtual_port() {
|
|
1225
|
+
let closed = SocketAddr::from(([127, 0, 0, 1], 1));
|
|
1226
|
+
let sock = TcpSock::new(Arc::new(HostInet), &prepare_creds(&[], None))
|
|
1227
|
+
.expect("an unbounded socket is made");
|
|
1228
|
+
let file = sock_alloc_file(sock.clone(), &Arc::default());
|
|
1229
|
+
let ports = BindHash::new();
|
|
1230
|
+
// The port is held before the dial, as a connect holds it.
|
|
1231
|
+
sock.hash_connect(&ports).expect("a port is free");
|
|
1232
|
+
let before = sock.getname(false).unwrap().port();
|
|
1233
|
+
sock.dial(closed, closed, &OpenConnections::new(None))
|
|
1234
|
+
.expect("an uncapped socket connects");
|
|
1235
|
+
wait_for(|table| file.poll(table), PollMask::ERR);
|
|
1236
|
+
let failed = sock.take_connect_outcome();
|
|
1237
|
+
let kept = sock.getname(false).unwrap().port();
|
|
1238
|
+
sock.hash_connect(&ports).expect("a port is free");
|
|
1239
|
+
assert_eq!(
|
|
1240
|
+
(failed, before, kept, sock.getname(false).unwrap().port()),
|
|
1241
|
+
(Err(Errno::ConnectionRefused), 32768, 32768, 32769),
|
|
1242
|
+
"a TCP socket whose connect failed must read its old virtual port until it connects \
|
|
1243
|
+
again, then take a fresh one, as a hash connect picks a port once __inet_put_port \
|
|
1244
|
+
cleared inet_num"
|
|
1245
|
+
);
|
|
1246
|
+
}
|
|
1247
|
+
|
|
1248
|
+
// @behavior RT-343
|
|
1249
|
+
#[test]
|
|
1250
|
+
fn a_socket_reads_what_its_peer_sent_then_the_end() {
|
|
1251
|
+
let (_sock, mut file, mut peer) = connected_socket();
|
|
1252
|
+
let mut buf = [0; 8];
|
|
1253
|
+
let before = file.read(&mut buf);
|
|
1254
|
+
peer.write_all(b"hello").unwrap();
|
|
1255
|
+
drop(peer);
|
|
1256
|
+
let mut got = Vec::new();
|
|
1257
|
+
loop {
|
|
1258
|
+
wait_for(|table| file.poll(table), PollMask::IN);
|
|
1259
|
+
match file.read(&mut buf) {
|
|
1260
|
+
Ok(0) => break,
|
|
1261
|
+
Ok(n) => got.extend_from_slice(&buf[..n]),
|
|
1262
|
+
Err(err) => panic!("a read the poll found ready answered {err:?}"),
|
|
1263
|
+
}
|
|
1264
|
+
}
|
|
1265
|
+
assert_eq!(
|
|
1266
|
+
(before, got),
|
|
1267
|
+
(Err(Errno::WouldBlock), b"hello".to_vec()),
|
|
1268
|
+
"File::read of a socket file must answer EAGAIN before anything arrived, then the \
|
|
1269
|
+
peer's bytes, then zero once it closed"
|
|
1270
|
+
);
|
|
1271
|
+
}
|
|
1272
|
+
|
|
1273
|
+
// @behavior RT-351
|
|
1274
|
+
#[test]
|
|
1275
|
+
fn a_reset_reads_as_an_error_its_poll_reports() {
|
|
1276
|
+
let (_sock, mut file, peer) = connected_socket();
|
|
1277
|
+
file.write(b"unread").unwrap();
|
|
1278
|
+
std::thread::sleep(Duration::from_millis(20));
|
|
1279
|
+
// A close with bytes unread sends a reset, as Linux's `tcp_close` does.
|
|
1280
|
+
drop(peer);
|
|
1281
|
+
wait_for(|table| file.poll(table), PollMask::ERR);
|
|
1282
|
+
assert_eq!(
|
|
1283
|
+
file.read(&mut [0; 8]),
|
|
1284
|
+
Err(Errno::ConnectionReset),
|
|
1285
|
+
"a socket file's poll after the peer reset must find ERR, as tcp_poll reads sk_err, \
|
|
1286
|
+
and its read must answer ECONNRESET"
|
|
1287
|
+
);
|
|
1288
|
+
}
|
|
1289
|
+
|
|
1290
|
+
/// A socket file whose peer reset it, as a close with bytes unread does.
|
|
1291
|
+
fn reset_socket() -> (Arc<TcpSock>, File) {
|
|
1292
|
+
let (sock, mut file, peer) = connected_socket();
|
|
1293
|
+
file.write(b"unread").unwrap();
|
|
1294
|
+
std::thread::sleep(Duration::from_millis(20));
|
|
1295
|
+
drop(peer);
|
|
1296
|
+
wait_for(|table| file.poll(table), PollMask::ERR);
|
|
1297
|
+
(sock, file)
|
|
1298
|
+
}
|
|
1299
|
+
|
|
1300
|
+
// @behavior RT-357
|
|
1301
|
+
#[test]
|
|
1302
|
+
fn a_reset_socket_answers_its_error_once_then_as_closed() {
|
|
1303
|
+
let (_sock, mut file) = reset_socket();
|
|
1304
|
+
let mut buf = [0; 8];
|
|
1305
|
+
assert_eq!(
|
|
1306
|
+
(file.read(&mut buf), file.read(&mut buf), file.write(b"x")),
|
|
1307
|
+
(Err(Errno::ConnectionReset), Ok(0), Err(Errno::BrokenPipe)),
|
|
1308
|
+
"File::read of a reset socket must answer ECONNRESET once and then zero, and \
|
|
1309
|
+
File::write then EPIPE, as sock_error clears sk_err"
|
|
1310
|
+
);
|
|
1311
|
+
}
|
|
1312
|
+
|
|
1313
|
+
// @behavior RT-376
|
|
1314
|
+
#[test]
|
|
1315
|
+
fn a_socket_its_peer_ended_reads_the_end_before_a_later_failure() {
|
|
1316
|
+
let (_sock, mut file, peer) = connected_socket();
|
|
1317
|
+
file.write(b"unread").unwrap();
|
|
1318
|
+
peer.shutdown(Shutdown::Write).unwrap();
|
|
1319
|
+
wait_for(|table| file.poll(table), PollMask::IN);
|
|
1320
|
+
std::thread::sleep(Duration::from_millis(20));
|
|
1321
|
+
drop(peer);
|
|
1322
|
+
std::thread::sleep(Duration::from_millis(20));
|
|
1323
|
+
let _ = file.write(b"after the reset");
|
|
1324
|
+
wait_for(|table| file.poll(table), PollMask::ERR);
|
|
1325
|
+
let mut buf = [0; 8];
|
|
1326
|
+
let (read, write) = (file.read(&mut buf), file.write(b"x"));
|
|
1327
|
+
assert!(
|
|
1328
|
+
read == Ok(0) && write.is_err(),
|
|
1329
|
+
"File::read of a socket whose peer sent its FIN, then reset it, must answer zero \
|
|
1330
|
+
ahead of the failure, as SOCK_DONE stops tcp_recvmsg before sk_err, and \
|
|
1331
|
+
File::write the failure; got {read:?} and {write:?}"
|
|
1332
|
+
);
|
|
1333
|
+
}
|
|
1334
|
+
|
|
1335
|
+
// @behavior RT-377
|
|
1336
|
+
#[test]
|
|
1337
|
+
fn a_socket_shut_down_while_it_connects_disconnects() {
|
|
1338
|
+
let listener = TcpListener::bind("127.0.0.1:0").expect("a loopback listener");
|
|
1339
|
+
let sock = dial(listener.local_addr().unwrap());
|
|
1340
|
+
// Hold it connecting whatever the reactor settled meanwhile, so the
|
|
1341
|
+
// shutdown meets a connect under way.
|
|
1342
|
+
sock.state().phase = Phase::Connecting;
|
|
1343
|
+
let shut = sock.shutdown(Shutdown::Both);
|
|
1344
|
+
let errored = sock.poll(None).contains(PollMask::ERR);
|
|
1345
|
+
let (first, second) = (sock.take_connect_outcome(), sock.take_connect_outcome());
|
|
1346
|
+
let (marked, placed) = {
|
|
1347
|
+
let state = sock.state();
|
|
1348
|
+
(
|
|
1349
|
+
(state.inet.rcv_shutdown, state.inet.send_shutdown),
|
|
1350
|
+
state.inet.place.is_some(),
|
|
1351
|
+
)
|
|
1352
|
+
};
|
|
1353
|
+
assert_eq!(
|
|
1354
|
+
(shut, errored, first, second, marked, placed),
|
|
1355
|
+
(
|
|
1356
|
+
Ok(()),
|
|
1357
|
+
true,
|
|
1358
|
+
Err(Errno::ConnectionReset),
|
|
1359
|
+
Err(Errno::NotConnected),
|
|
1360
|
+
(false, false),
|
|
1361
|
+
true
|
|
1362
|
+
),
|
|
1363
|
+
"a shutdown of a socket still connecting must answer success and leave it \
|
|
1364
|
+
unconnected with ECONNRESET pending, its poll showing ERR, so finishing the connect \
|
|
1365
|
+
answers ECONNRESET once and then ENOTCONN, mark neither side, and keep its place \
|
|
1366
|
+
until released, as inet_shutdown disconnects a socket in TCP_SYN_SENT and \
|
|
1367
|
+
tcp_disconnect sets sk_err"
|
|
1368
|
+
);
|
|
1369
|
+
}
|
|
1370
|
+
|
|
1371
|
+
/// Write to `file` until the socket and the host take no more, answering
|
|
1372
|
+
/// how many bytes it took.
|
|
1373
|
+
fn fill(file: &mut File) -> usize {
|
|
1374
|
+
let mut sent = 0;
|
|
1375
|
+
loop {
|
|
1376
|
+
match file.write(&[7; 16 * 1024]) {
|
|
1377
|
+
Ok(n) => sent += n,
|
|
1378
|
+
Err(Errno::WouldBlock) => return sent,
|
|
1379
|
+
Err(err) => panic!("a connected socket takes bytes until full: {err:?}"),
|
|
1380
|
+
}
|
|
1381
|
+
}
|
|
1382
|
+
}
|
|
1383
|
+
|
|
1384
|
+
// @behavior RT-378
|
|
1385
|
+
#[test]
|
|
1386
|
+
fn a_released_socket_sends_what_it_queued_then_its_fin() {
|
|
1387
|
+
let (sock, mut file, mut peer) = connected_socket();
|
|
1388
|
+
peer.set_read_timeout(Some(Duration::from_secs(10)))
|
|
1389
|
+
.unwrap();
|
|
1390
|
+
let sent = fill(&mut file);
|
|
1391
|
+
// Nothing but the socket itself holds it once its file is gone.
|
|
1392
|
+
drop((sock, file));
|
|
1393
|
+
let mut got = Vec::new();
|
|
1394
|
+
let read = peer.read_to_end(&mut got).map(|_| got.len());
|
|
1395
|
+
assert_eq!(
|
|
1396
|
+
read.ok(),
|
|
1397
|
+
Some(sent),
|
|
1398
|
+
"a socket file dropped with bytes still queued must send every one of the {sent} \
|
|
1399
|
+
bytes it took, then its FIN, as __tcp_close sends what is queued"
|
|
1400
|
+
);
|
|
1401
|
+
}
|
|
1402
|
+
|
|
1403
|
+
// @behavior RT-379
|
|
1404
|
+
#[test]
|
|
1405
|
+
fn a_released_socket_the_peer_sends_to_resets_and_lets_go() {
|
|
1406
|
+
let (sock, _file, mut peer) = connected_socket();
|
|
1407
|
+
peer.set_read_timeout(Some(Duration::from_secs(10)))
|
|
1408
|
+
.unwrap();
|
|
1409
|
+
// Released with a byte still queued, as an orphan holds itself, and
|
|
1410
|
+
// the peer's bytes already in: the host would answer them a reset.
|
|
1411
|
+
{
|
|
1412
|
+
let mut state = sock.state();
|
|
1413
|
+
state.orphan = Some(sock.clone());
|
|
1414
|
+
state.write_queue.push_back(7);
|
|
1415
|
+
state.receive_queue.extend(b"after the close");
|
|
1416
|
+
}
|
|
1417
|
+
sock.pump_and_wake(sock.state());
|
|
1418
|
+
let held = {
|
|
1419
|
+
let state = sock.state();
|
|
1420
|
+
(state.orphan.is_some(), state.host.is_some())
|
|
1421
|
+
};
|
|
1422
|
+
// The queued byte may reach the peer before the reset does.
|
|
1423
|
+
let read = loop {
|
|
1424
|
+
match peer.read(&mut [0; 8]) {
|
|
1425
|
+
Ok(0) => break Ok(0),
|
|
1426
|
+
Ok(_) => continue,
|
|
1427
|
+
Err(err) => break Err(err.kind()),
|
|
1428
|
+
}
|
|
1429
|
+
};
|
|
1430
|
+
assert_eq!(
|
|
1431
|
+
(held, read),
|
|
1432
|
+
((false, false), Err(io::ErrorKind::ConnectionReset)),
|
|
1433
|
+
"a released socket its peer sends to must reset the connection, so the peer reads a \
|
|
1434
|
+
reset, and let go of itself, bytes still queued or not, as Linux resets data \
|
|
1435
|
+
arriving after __tcp_close"
|
|
1436
|
+
);
|
|
1437
|
+
}
|
|
1438
|
+
|
|
1439
|
+
// @behavior RT-379
|
|
1440
|
+
#[test]
|
|
1441
|
+
fn a_socket_released_with_bytes_unread_resets_its_connection() {
|
|
1442
|
+
let (_sock, file, mut peer) = connected_socket();
|
|
1443
|
+
peer.set_read_timeout(Some(Duration::from_secs(10)))
|
|
1444
|
+
.unwrap();
|
|
1445
|
+
peer.write_all(b"unread").unwrap();
|
|
1446
|
+
wait_for(|table| file.poll(table), PollMask::IN);
|
|
1447
|
+
drop(file);
|
|
1448
|
+
let read = peer.read(&mut [0; 8]).map_err(|err| err.kind());
|
|
1449
|
+
assert_eq!(
|
|
1450
|
+
read,
|
|
1451
|
+
Err(io::ErrorKind::ConnectionReset),
|
|
1452
|
+
"a socket file dropped with bytes it never read must reset its connection, as \
|
|
1453
|
+
__tcp_close sends a reset when unread data is thrown away"
|
|
1454
|
+
);
|
|
1455
|
+
}
|
|
1456
|
+
|
|
1457
|
+
// @behavior RT-358
|
|
1458
|
+
#[test]
|
|
1459
|
+
fn a_reset_or_refused_socket_polls_hung_up() {
|
|
1460
|
+
let closed = TcpListener::bind("127.0.0.1:0").expect("a loopback listener");
|
|
1461
|
+
let addr = closed.local_addr().unwrap();
|
|
1462
|
+
drop(closed);
|
|
1463
|
+
let refused = sock_alloc_file(dial(addr), &Arc::default());
|
|
1464
|
+
wait_for(|table| refused.poll(table), PollMask::ERR);
|
|
1465
|
+
let every = PollMask::IN | PollMask::OUT | PollMask::ERR | PollMask::HUP;
|
|
1466
|
+
assert_eq!(
|
|
1467
|
+
(reset_socket().1.poll(None), refused.poll(None)),
|
|
1468
|
+
(every, every),
|
|
1469
|
+
"a socket file whose peer reset it, and one whose connect was refused, must each \
|
|
1470
|
+
poll IN, OUT, ERR, and HUP, as tcp_poll answers TCP_CLOSE"
|
|
1471
|
+
);
|
|
1472
|
+
}
|
|
1473
|
+
|
|
1474
|
+
// @behavior RT-359
|
|
1475
|
+
#[test]
|
|
1476
|
+
fn a_shut_down_reading_side_reads_what_arrived() {
|
|
1477
|
+
let (sock, mut file, mut peer) = connected_socket();
|
|
1478
|
+
peer.write_all(b"queued").unwrap();
|
|
1479
|
+
wait_for(|table| file.poll(table), PollMask::IN);
|
|
1480
|
+
sock.shutdown(Shutdown::Read)
|
|
1481
|
+
.expect("a connected socket shuts down");
|
|
1482
|
+
let mut buf = [0; 16];
|
|
1483
|
+
let first = file.read(&mut buf).map(|n| buf[..n].to_vec());
|
|
1484
|
+
assert_eq!(
|
|
1485
|
+
(first, file.read(&mut buf)),
|
|
1486
|
+
(Ok(b"queued".to_vec()), Ok(0)),
|
|
1487
|
+
"a socket's read after shutting its reading side down must still read the bytes \
|
|
1488
|
+
that arrived, then zero"
|
|
1489
|
+
);
|
|
1490
|
+
}
|
|
1491
|
+
|
|
1492
|
+
// @behavior RT-360
|
|
1493
|
+
#[test]
|
|
1494
|
+
fn a_zero_byte_read_of_a_tcp_socket_answers_zero() {
|
|
1495
|
+
let (_sock, mut file, _peer) = connected_socket();
|
|
1496
|
+
assert_eq!(
|
|
1497
|
+
file.read(&mut []),
|
|
1498
|
+
Ok(0),
|
|
1499
|
+
"File::read of zero bytes from a connected socket with nothing queued must answer \
|
|
1500
|
+
zero, as sock_read_iter does, not EAGAIN"
|
|
1501
|
+
);
|
|
1502
|
+
}
|
|
1503
|
+
|
|
1504
|
+
// @behavior RT-344
|
|
1505
|
+
#[test]
|
|
1506
|
+
fn a_socket_sends_what_it_was_handed_then_its_fin() {
|
|
1507
|
+
let (sock, mut file, mut peer) = connected_socket();
|
|
1508
|
+
assert_eq!(
|
|
1509
|
+
file.write(b"ping"),
|
|
1510
|
+
Ok(4),
|
|
1511
|
+
"a connected socket takes the bytes"
|
|
1512
|
+
);
|
|
1513
|
+
sock.shutdown(Shutdown::Write)
|
|
1514
|
+
.expect("a connected socket shuts down");
|
|
1515
|
+
peer.set_read_timeout(Some(Duration::from_secs(10)))
|
|
1516
|
+
.unwrap();
|
|
1517
|
+
let mut got = Vec::new();
|
|
1518
|
+
peer.read_to_end(&mut got)
|
|
1519
|
+
.expect("the peer reads until the end");
|
|
1520
|
+
assert_eq!(
|
|
1521
|
+
got,
|
|
1522
|
+
b"ping".to_vec(),
|
|
1523
|
+
"a peer of a socket written then shut down for writing must read the bytes, then \
|
|
1524
|
+
the end"
|
|
1525
|
+
);
|
|
1526
|
+
}
|
|
1527
|
+
|
|
1528
|
+
// @behavior RT-402
|
|
1529
|
+
#[test]
|
|
1530
|
+
fn a_socket_both_ends_finished_stands_closed() {
|
|
1531
|
+
let (sock, mut file, mut peer) = connected_socket();
|
|
1532
|
+
sock.shutdown(Shutdown::Write)
|
|
1533
|
+
.expect("a connected socket shuts down");
|
|
1534
|
+
peer.set_read_timeout(Some(Duration::from_secs(10)))
|
|
1535
|
+
.unwrap();
|
|
1536
|
+
peer.read_to_end(&mut Vec::new())
|
|
1537
|
+
.expect("the peer reads the socket's end");
|
|
1538
|
+
drop(peer);
|
|
1539
|
+
wait_for(|table| file.poll(table), PollMask::HUP);
|
|
1540
|
+
assert_eq!(
|
|
1541
|
+
(
|
|
1542
|
+
sock.shutdown(Shutdown::Read),
|
|
1543
|
+
sock.shutdown(Shutdown::Write),
|
|
1544
|
+
sock.getname(true),
|
|
1545
|
+
file.read(&mut [0; 8]),
|
|
1546
|
+
),
|
|
1547
|
+
(
|
|
1548
|
+
Err(Errno::NotConnected),
|
|
1549
|
+
Err(Errno::NotConnected),
|
|
1550
|
+
Err(Errno::NotConnected),
|
|
1551
|
+
Ok(0),
|
|
1552
|
+
),
|
|
1553
|
+
"a TCP socket that sent its FIN and read its peer's must answer ENOTCONN to a \
|
|
1554
|
+
shutdown and to its peer's name, and zero to a read, as inet_shutdown and \
|
|
1555
|
+
inet_getname answer one tcp_done left in TCP_CLOSE"
|
|
1556
|
+
);
|
|
1557
|
+
}
|
|
1558
|
+
|
|
1559
|
+
// @behavior RT-345
|
|
1560
|
+
#[test]
|
|
1561
|
+
fn a_refused_connect_answers_econnrefused() {
|
|
1562
|
+
let addr = TcpListener::bind("127.0.0.1:0")
|
|
1563
|
+
.and_then(|listener| listener.local_addr())
|
|
1564
|
+
.unwrap();
|
|
1565
|
+
let sock = dial(addr);
|
|
1566
|
+
let file = sock_alloc_file(sock.clone(), &Arc::default());
|
|
1567
|
+
wait_for(|table| file.poll(table), PollMask::OUT);
|
|
1568
|
+
assert_eq!(
|
|
1569
|
+
sock.take_connect_outcome(),
|
|
1570
|
+
Err(Errno::ConnectionRefused),
|
|
1571
|
+
"a non-blocking connect to a port no peer listens on must settle as ECONNREFUSED"
|
|
1572
|
+
);
|
|
1573
|
+
}
|
|
1574
|
+
|
|
1575
|
+
// @behavior RT-346
|
|
1576
|
+
#[test]
|
|
1577
|
+
fn dropping_the_socket_file_releases_the_host_socket() {
|
|
1578
|
+
let (_sock, file, mut peer) = connected_socket();
|
|
1579
|
+
drop(file);
|
|
1580
|
+
peer.set_read_timeout(Some(Duration::from_secs(10)))
|
|
1581
|
+
.unwrap();
|
|
1582
|
+
let mut rest = Vec::new();
|
|
1583
|
+
assert!(
|
|
1584
|
+
peer.read_to_end(&mut rest).is_ok_and(|n| n == 0),
|
|
1585
|
+
"the peer of a socket whose file was dropped must read the end"
|
|
1586
|
+
);
|
|
1587
|
+
}
|
|
1588
|
+
}
|