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,1003 @@
|
|
|
1
|
+
//! A UDP socket the guest holds, connected to one peer, as Linux's `udp_sock`
|
|
2
|
+
//! behind a socket file. The host socket is non-blocking and the reactor
|
|
3
|
+
//! watches it: each change reads what arrived into the receive queue, then
|
|
4
|
+
//! wakes the socket's wait queue. A send goes to the host socket at once, as
|
|
5
|
+
//! `udp_sendmsg` sends, and a read takes one datagram, as `recv` on a
|
|
6
|
+
//! datagram socket does.
|
|
7
|
+
|
|
8
|
+
use std::collections::VecDeque;
|
|
9
|
+
use std::io;
|
|
10
|
+
use std::net::{Shutdown, SocketAddr};
|
|
11
|
+
use std::sync::{Arc, Mutex, MutexGuard, PoisonError, Weak};
|
|
12
|
+
|
|
13
|
+
use super::connections::OpenConnections;
|
|
14
|
+
use super::family::ProtocolFamily;
|
|
15
|
+
use super::namespace::Namespace;
|
|
16
|
+
use super::reactor::{Reactor, Ready, Registration};
|
|
17
|
+
use crate::network::Protocol;
|
|
18
|
+
use socket2::SockRef;
|
|
19
|
+
|
|
20
|
+
use super::socket::{
|
|
21
|
+
connect4, filter, set_hop_limit, BindHash, Buffers, InetSock, ProtoOps, SkState, SockOpt,
|
|
22
|
+
MAX_SOCKET_BUFFER,
|
|
23
|
+
};
|
|
24
|
+
use crate::cred::Cred;
|
|
25
|
+
use crate::memcg::MemoryCharge;
|
|
26
|
+
use crate::vfs::PollMask;
|
|
27
|
+
use crate::wait::{poll_wait, PollTable, WaitQueueHead};
|
|
28
|
+
use crate::Errno;
|
|
29
|
+
|
|
30
|
+
/// The most one IPv4 datagram carries.
|
|
31
|
+
pub const MAX_DATAGRAM: usize = 65_507;
|
|
32
|
+
|
|
33
|
+
/// What the receive queue spends on a datagram beside its bytes, as Linux's
|
|
34
|
+
/// `skb->truesize` counts the `sk_buff` itself, so even empty datagrams fill
|
|
35
|
+
/// `rcvbuf`.
|
|
36
|
+
const DATAGRAM_OVERHEAD: usize = std::mem::size_of::<(Vec<u8>, SocketAddr)>();
|
|
37
|
+
|
|
38
|
+
/// The most datagrams one pump takes from the host socket, as
|
|
39
|
+
/// `NAPI_POLL_WEIGHT` bounds one poll, so a flooded socket holds neither the
|
|
40
|
+
/// reactor nor a guest call.
|
|
41
|
+
const MAX_PUMPED_DATAGRAMS: usize = 64;
|
|
42
|
+
|
|
43
|
+
/// What a queued datagram of `len` bytes spends of `rcvbuf`.
|
|
44
|
+
fn truesize_of(len: usize) -> usize {
|
|
45
|
+
len + DATAGRAM_OVERHEAD
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
struct State {
|
|
49
|
+
/// The host socket, and its place in the reactor, until released.
|
|
50
|
+
host: Option<(mio::net::UdpSocket, Registration)>,
|
|
51
|
+
/// The datagrams that arrived and the guest has not read, each with the
|
|
52
|
+
/// peer it came from as the guest named it, as `sk_receive_queue` keeps
|
|
53
|
+
/// each skb's source, and the bytes they hold.
|
|
54
|
+
receive_queue: VecDeque<(Vec<u8>, SocketAddr)>,
|
|
55
|
+
rmem_alloc: usize,
|
|
56
|
+
/// Whether the host socket took the last send, until the reactor next
|
|
57
|
+
/// sees it change, as `sock_writeable` reads its room.
|
|
58
|
+
writable: bool,
|
|
59
|
+
/// What every inet socket holds. A send goes to the host at once, so
|
|
60
|
+
/// `SO_SNDBUF` only reads back; once the reading side is shut, an empty
|
|
61
|
+
/// queue still answers EAGAIN, as `__skb_recv_udp` does, and once the
|
|
62
|
+
/// writing side is, a send answers `EPIPE`.
|
|
63
|
+
inet: InetSock,
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
impl State {
|
|
67
|
+
/// The `sk_state` it stands in: established once it names a peer.
|
|
68
|
+
fn sk_state(&self) -> SkState {
|
|
69
|
+
match self.inet.peer {
|
|
70
|
+
Some(_) => SkState::Established,
|
|
71
|
+
None => SkState::Close,
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
/// One UDP socket, shared by the socket file and the reactor.
|
|
77
|
+
pub struct UdpSock {
|
|
78
|
+
state: Mutex<State>,
|
|
79
|
+
wait: Arc<WaitQueueHead>,
|
|
80
|
+
this: Weak<Self>,
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
impl UdpSock {
|
|
84
|
+
/// A socket connected to nothing, as `inet_create` makes one; its receive
|
|
85
|
+
/// queue is reserved against `cred`'s memory, and past it the socket
|
|
86
|
+
/// answers `ENOMEM`. The reserve holds the whole buffer, or one datagram
|
|
87
|
+
/// of the most size, which an empty queue takes past the buffer.
|
|
88
|
+
pub(crate) fn new(cred: &Arc<Cred>) -> Result<Arc<Self>, Errno> {
|
|
89
|
+
let reserve = MAX_SOCKET_BUFFER.max(truesize_of(MAX_DATAGRAM));
|
|
90
|
+
let memory = MemoryCharge::new(cred.memory_budget(), reserve)?;
|
|
91
|
+
Ok(Arc::new_cyclic(|this| Self {
|
|
92
|
+
state: Mutex::new(State {
|
|
93
|
+
host: None,
|
|
94
|
+
receive_queue: VecDeque::new(),
|
|
95
|
+
rmem_alloc: 0,
|
|
96
|
+
writable: true,
|
|
97
|
+
inet: InetSock::new(memory, Buffers::default()),
|
|
98
|
+
}),
|
|
99
|
+
wait: Arc::default(),
|
|
100
|
+
this: this.clone(),
|
|
101
|
+
}))
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
/// Point the host socket at `addr` through `family`, the guest having
|
|
105
|
+
/// named `peer`, the host socket watched by the reactor; it counts against
|
|
106
|
+
/// `open_connections` and the process until released, and a full count
|
|
107
|
+
/// answers `EAGAIN`. Connecting again moves the peer and keeps the place,
|
|
108
|
+
/// and within one family the host socket and its port, as
|
|
109
|
+
/// `__ip4_datagram_connect` repoints a socket.
|
|
110
|
+
pub(crate) fn dial(
|
|
111
|
+
&self,
|
|
112
|
+
family: &Arc<dyn ProtocolFamily>,
|
|
113
|
+
addr: SocketAddr,
|
|
114
|
+
peer: SocketAddr,
|
|
115
|
+
open_connections: &Arc<OpenConnections>,
|
|
116
|
+
) -> Result<(), Errno> {
|
|
117
|
+
{
|
|
118
|
+
let mut state = self.state();
|
|
119
|
+
// The host socket repoints within its family, where the family
|
|
120
|
+
// routes `addr` to, or a fresh one is made.
|
|
121
|
+
let routed = match state.host.as_ref() {
|
|
122
|
+
Some((socket, _)) => {
|
|
123
|
+
let local = socket
|
|
124
|
+
.local_addr()
|
|
125
|
+
.map_err(|err| Errno::from_io_error(&err))?;
|
|
126
|
+
family
|
|
127
|
+
.route_datagram(local, addr)
|
|
128
|
+
.map_err(|err| Errno::from_io_error(&err))?
|
|
129
|
+
}
|
|
130
|
+
None => None,
|
|
131
|
+
};
|
|
132
|
+
if let Some(routed) = routed {
|
|
133
|
+
// What the old peer sent reads as its own, so it is taken in
|
|
134
|
+
// before the host socket repoints.
|
|
135
|
+
self.pump(&mut state);
|
|
136
|
+
if let Some((socket, _)) = state.host.as_ref() {
|
|
137
|
+
socket
|
|
138
|
+
.connect(routed)
|
|
139
|
+
.map_err(|err| Errno::from_io_error(&err))?;
|
|
140
|
+
}
|
|
141
|
+
state.inet.peer = Some(peer);
|
|
142
|
+
state.writable = true;
|
|
143
|
+
return Ok(());
|
|
144
|
+
}
|
|
145
|
+
}
|
|
146
|
+
let place = self.state().inet.open_place(open_connections)?;
|
|
147
|
+
let reactor = Reactor::current().map_err(|err| Errno::from_io_error(&err))?;
|
|
148
|
+
let host = family
|
|
149
|
+
.connect_datagram(addr)
|
|
150
|
+
.map_err(|err| Errno::from_io_error(&err))?;
|
|
151
|
+
// The guest's own setsockopt already took the hop limit, so a host
|
|
152
|
+
// socket refusing it as it dials is no part of the connect's
|
|
153
|
+
// outcome, as a TCP dial leaves it out.
|
|
154
|
+
let _ = set_hop_limit(SockRef::from(&host), self.state().inet.uc_ttl);
|
|
155
|
+
let mut socket = mio::net::UdpSocket::from_std(host);
|
|
156
|
+
let ready: Weak<dyn Ready> = self.this.clone();
|
|
157
|
+
let registration = reactor
|
|
158
|
+
.register(&mut socket, ready)
|
|
159
|
+
.map_err(|err| Errno::from_io_error(&err))?;
|
|
160
|
+
let mut state = self.state();
|
|
161
|
+
// What the old peer sent reads as its own, so it is taken in before
|
|
162
|
+
// the host socket it waits in goes.
|
|
163
|
+
self.pump(&mut state);
|
|
164
|
+
if let Some((mut earlier, registration)) = state.host.take() {
|
|
165
|
+
registration.deregister(&mut earlier);
|
|
166
|
+
}
|
|
167
|
+
state.host = Some((socket, registration));
|
|
168
|
+
state.inet.peer = Some(peer);
|
|
169
|
+
state.writable = true;
|
|
170
|
+
if let Some(place) = place {
|
|
171
|
+
state.inet.place = Some(place);
|
|
172
|
+
}
|
|
173
|
+
Ok(())
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
/// Hold a free port from `ports` as the guest's own, unless one is held,
|
|
177
|
+
/// as `inet_autobind` binds a socket holding none.
|
|
178
|
+
pub(crate) fn autobind(&self, ports: &Arc<BindHash>) -> Result<(), Errno> {
|
|
179
|
+
self.state().inet.hash_connect(ports)
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
fn state(&self) -> MutexGuard<'_, State> {
|
|
183
|
+
self.state.lock().unwrap_or_else(PoisonError::into_inner)
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
/// Read what arrived, without blocking and at most `MAX_PUMPED_DATAGRAMS`
|
|
187
|
+
/// at once, each labelled with the peer the guest named; one an earlier
|
|
188
|
+
/// peer sent as the socket repointed is dropped, as a datagram may be
|
|
189
|
+
/// lost. A full receive queue drops what comes, as a full `sk_rcvbuf`
|
|
190
|
+
/// does. A failure the host reports is kept pending and the queue reads
|
|
191
|
+
/// on behind it, as datagrams queue behind `sk_err`. A turn that spends
|
|
192
|
+
/// its bound asks the reactor to take another, as NAPI repolls, since no
|
|
193
|
+
/// further event may come for what already waits.
|
|
194
|
+
fn pump(&self, state: &mut State) {
|
|
195
|
+
let Some((socket, registration)) = state.host.as_ref() else {
|
|
196
|
+
return;
|
|
197
|
+
};
|
|
198
|
+
let host_peer = socket.peer_addr().ok();
|
|
199
|
+
let peer = state.inet.peer;
|
|
200
|
+
let mut datagram = vec![0; MAX_DATAGRAM];
|
|
201
|
+
let mut taken = 0;
|
|
202
|
+
while taken < MAX_PUMPED_DATAGRAMS {
|
|
203
|
+
match socket.recv_from(&mut datagram) {
|
|
204
|
+
Ok((n, from)) => {
|
|
205
|
+
taken += 1;
|
|
206
|
+
let Some(peer) = peer.filter(|_| host_peer == Some(from)) else {
|
|
207
|
+
continue;
|
|
208
|
+
};
|
|
209
|
+
// A full buffer drops it, but an empty queue takes one
|
|
210
|
+
// past the buffer, as `__udp_enqueue_schedule_skb` does.
|
|
211
|
+
let room = state.rmem_alloc + truesize_of(n) <= state.inet.buffers.rcvbuf;
|
|
212
|
+
if room || state.rmem_alloc == 0 {
|
|
213
|
+
state
|
|
214
|
+
.receive_queue
|
|
215
|
+
.push_back((datagram[..n].to_vec(), peer));
|
|
216
|
+
state.rmem_alloc += truesize_of(n);
|
|
217
|
+
}
|
|
218
|
+
}
|
|
219
|
+
Err(err) if err.kind() == io::ErrorKind::Interrupted => {}
|
|
220
|
+
Err(err) if err.kind() == io::ErrorKind::WouldBlock => break,
|
|
221
|
+
Err(err) => {
|
|
222
|
+
taken += 1;
|
|
223
|
+
state.inet.err = Some(to_udp_error(&err));
|
|
224
|
+
}
|
|
225
|
+
}
|
|
226
|
+
}
|
|
227
|
+
if taken == MAX_PUMPED_DATAGRAMS {
|
|
228
|
+
let ready: Weak<dyn Ready> = self.this.clone();
|
|
229
|
+
registration.repoll(ready);
|
|
230
|
+
}
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
fn pump_and_wake(&self, mut state: MutexGuard<'_, State>) {
|
|
234
|
+
self.pump(&mut state);
|
|
235
|
+
drop(state);
|
|
236
|
+
self.wait.wake_up();
|
|
237
|
+
}
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
impl Ready for UdpSock {
|
|
241
|
+
/// What arrived reads into the queue, and the host socket may take a send
|
|
242
|
+
/// again.
|
|
243
|
+
fn on_event(&self) {
|
|
244
|
+
let mut state = self.state();
|
|
245
|
+
state.writable = true;
|
|
246
|
+
self.pump_and_wake(state);
|
|
247
|
+
}
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
/// UDP's answers for its socket file, as `inet_dgram_ops` hands each call to
|
|
251
|
+
/// `udp_prot`.
|
|
252
|
+
impl ProtoOps for UdpSock {
|
|
253
|
+
/// `net`'s `connect4`, then within the connection caps a port, the
|
|
254
|
+
/// ruleset, and the host socket pointed at the real address it admits, as
|
|
255
|
+
/// `inet_dgram_connect` runs `connect4` and then autobinds a socket
|
|
256
|
+
/// holding no port, answering `EAGAIN` once none is free. UDP opens no
|
|
257
|
+
/// handshake, so that address is its peer; the port stays held whatever
|
|
258
|
+
/// the connect answers, as an autobind does.
|
|
259
|
+
fn connect(&self, net: &Namespace, addr: SocketAddr) -> Result<(), Errno> {
|
|
260
|
+
let dest = connect4(net, addr)?;
|
|
261
|
+
net.within_connection_budget(Errno::WouldBlock, || {
|
|
262
|
+
self.autobind(net.ports_of(Protocol::Udp))
|
|
263
|
+
.map_err(|_| Errno::WouldBlock)?;
|
|
264
|
+
let real = filter(net, &dest, Protocol::Udp)?;
|
|
265
|
+
self.dial(net.family(), real, addr, net.open_connections())
|
|
266
|
+
})
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
/// A socket connected to a peer holds its own end already, as
|
|
270
|
+
/// `inet_dgram_connect` autobinds one through `inet_autobind`.
|
|
271
|
+
fn bind(&self, net: &Namespace, addr: SocketAddr) -> Result<(), Errno> {
|
|
272
|
+
let mut state = self.state();
|
|
273
|
+
let sk_state = state.sk_state();
|
|
274
|
+
state.inet.bind(addr, sk_state, net.ports_of(Protocol::Udp))
|
|
275
|
+
}
|
|
276
|
+
|
|
277
|
+
/// One datagram, cut to `buf`, and the peer it came from as the guest
|
|
278
|
+
/// named it, as `udp_recvmsg` fills `msg_name` with each one's source. A
|
|
279
|
+
/// pending failure is answered first, once, and then cleared, as
|
|
280
|
+
/// `__skb_recv_udp` asks `sock_error` before it dequeues, so the socket
|
|
281
|
+
/// reads on. An empty queue answers `WouldBlock` even once its reading
|
|
282
|
+
/// side is shut, as a non-blocking `__skb_recv_udp` answers EAGAIN and
|
|
283
|
+
/// only a blocking wait ends on `RCV_SHUTDOWN`. A read takes only what the
|
|
284
|
+
/// queue holds, as `__skb_recv_udp` reads the socket's own queue; what a
|
|
285
|
+
/// bounded turn left in the host socket comes with the reactor's next.
|
|
286
|
+
fn recvmsg(&self, buf: &mut [u8]) -> Result<(usize, Option<SocketAddr>), Errno> {
|
|
287
|
+
let mut state = self.state();
|
|
288
|
+
if let Some(err) = state.inet.err.take() {
|
|
289
|
+
return Err(err);
|
|
290
|
+
}
|
|
291
|
+
let Some((datagram, from)) = state.receive_queue.pop_front() else {
|
|
292
|
+
return Err(Errno::WouldBlock);
|
|
293
|
+
};
|
|
294
|
+
state.rmem_alloc -= truesize_of(datagram.len());
|
|
295
|
+
let n = buf.len().min(datagram.len());
|
|
296
|
+
buf[..n].copy_from_slice(&datagram[..n]);
|
|
297
|
+
Ok((n, Some(from)))
|
|
298
|
+
}
|
|
299
|
+
|
|
300
|
+
/// One datagram, sent whole and at once, as `udp_sendmsg` sends: one past
|
|
301
|
+
/// what UDP carries answers EMSGSIZE, one with no peer to go to
|
|
302
|
+
/// EDESTADDRREQ, and a pending failure is answered once first. Once its
|
|
303
|
+
/// writing side is shut a send answers EPIPE, as `sock_alloc_send_pskb`
|
|
304
|
+
/// refuses on `SEND_SHUTDOWN`. A host socket with no room answers
|
|
305
|
+
/// `WouldBlock` and sends nothing, so no datagram is taken that a release
|
|
306
|
+
/// could lose.
|
|
307
|
+
fn sendmsg(&self, buf: &[u8]) -> Result<usize, Errno> {
|
|
308
|
+
if buf.len() > MAX_DATAGRAM {
|
|
309
|
+
return Err(Errno::MessageTooLong);
|
|
310
|
+
}
|
|
311
|
+
let mut state = self.state();
|
|
312
|
+
if let Some(err) = state.inet.err.take() {
|
|
313
|
+
return Err(err);
|
|
314
|
+
}
|
|
315
|
+
if state.inet.peer.is_none() {
|
|
316
|
+
return Err(Errno::DestinationAddressRequired);
|
|
317
|
+
}
|
|
318
|
+
if state.inet.send_shutdown {
|
|
319
|
+
return Err(Errno::BrokenPipe);
|
|
320
|
+
}
|
|
321
|
+
let Some((socket, _)) = state.host.as_ref() else {
|
|
322
|
+
return Err(Errno::WouldBlock);
|
|
323
|
+
};
|
|
324
|
+
let sent = loop {
|
|
325
|
+
match socket.send(buf) {
|
|
326
|
+
Err(err) if err.kind() == io::ErrorKind::Interrupted => continue,
|
|
327
|
+
sent => break sent,
|
|
328
|
+
}
|
|
329
|
+
};
|
|
330
|
+
match sent {
|
|
331
|
+
Ok(_) => Ok(buf.len()),
|
|
332
|
+
Err(err) if err.kind() == io::ErrorKind::WouldBlock => {
|
|
333
|
+
state.writable = false;
|
|
334
|
+
Err(Errno::WouldBlock)
|
|
335
|
+
}
|
|
336
|
+
Err(err) => Err(to_udp_error(&err)),
|
|
337
|
+
}
|
|
338
|
+
}
|
|
339
|
+
|
|
340
|
+
/// As `datagram_poll` answers: readable once a datagram waits or its
|
|
341
|
+
/// reading side is shut, writable while the host socket takes a send,
|
|
342
|
+
/// hung up once both sides are shut, and failed while a failure is
|
|
343
|
+
/// pending.
|
|
344
|
+
fn poll(&self, table: Option<&mut PollTable>) -> PollMask {
|
|
345
|
+
poll_wait(&self.wait, table);
|
|
346
|
+
let state = self.state();
|
|
347
|
+
let mut mask = PollMask::default();
|
|
348
|
+
if !state.receive_queue.is_empty() || state.inet.rcv_shutdown {
|
|
349
|
+
mask = mask | PollMask::IN;
|
|
350
|
+
}
|
|
351
|
+
if (state.host.is_some() && state.writable) || state.inet.peer.is_none() {
|
|
352
|
+
mask = mask | PollMask::OUT;
|
|
353
|
+
}
|
|
354
|
+
if state.inet.rcv_shutdown && state.inet.send_shutdown {
|
|
355
|
+
mask = mask | PollMask::HUP;
|
|
356
|
+
}
|
|
357
|
+
if state.inet.err.is_some() {
|
|
358
|
+
mask = mask | PollMask::ERR;
|
|
359
|
+
}
|
|
360
|
+
mask
|
|
361
|
+
}
|
|
362
|
+
|
|
363
|
+
/// Mark the sides `how` names shut, as `inet_shutdown` does; a socket
|
|
364
|
+
/// connected to no peer marks them and answers `ENOTCONN`.
|
|
365
|
+
fn shutdown(&self, how: Shutdown) -> Result<(), Errno> {
|
|
366
|
+
let mut state = self.state();
|
|
367
|
+
let sk_state = state.sk_state();
|
|
368
|
+
let shut = state.inet.shutdown(how, sk_state);
|
|
369
|
+
drop(state);
|
|
370
|
+
self.wait.wake_up();
|
|
371
|
+
shut
|
|
372
|
+
}
|
|
373
|
+
|
|
374
|
+
fn protocol(&self) -> Protocol {
|
|
375
|
+
Protocol::Udp
|
|
376
|
+
}
|
|
377
|
+
|
|
378
|
+
fn getname(&self, peer: bool) -> Result<SocketAddr, Errno> {
|
|
379
|
+
let state = self.state();
|
|
380
|
+
state.inet.getname(peer, state.sk_state())
|
|
381
|
+
}
|
|
382
|
+
|
|
383
|
+
/// The buffers and the hop limit; UDP has no TCP option.
|
|
384
|
+
fn getsockopt(&self, opt: SockOpt) -> Result<u32, Errno> {
|
|
385
|
+
self.state().inet.getsockopt(opt)
|
|
386
|
+
}
|
|
387
|
+
|
|
388
|
+
/// A buffer past it drops a datagram, as a full `sk_rcvbuf` does; a send
|
|
389
|
+
/// goes to the host at once, so `SO_SNDBUF` only reads back. A hop limit
|
|
390
|
+
/// reaches a host socket already there at once.
|
|
391
|
+
fn setsockopt(&self, opt: SockOpt, value: u32) -> Result<(), Errno> {
|
|
392
|
+
let mut guard = self.state();
|
|
393
|
+
let state = &mut *guard;
|
|
394
|
+
let host = state.host.as_ref().map(|(socket, _)| SockRef::from(socket));
|
|
395
|
+
state.inet.setsockopt(opt, value, host)
|
|
396
|
+
}
|
|
397
|
+
|
|
398
|
+
/// Let the host socket go, deregistered from the reactor.
|
|
399
|
+
fn release(&self) {
|
|
400
|
+
let mut state = self.state();
|
|
401
|
+
state.inet.release();
|
|
402
|
+
state.receive_queue.clear();
|
|
403
|
+
state.rmem_alloc = 0;
|
|
404
|
+
if let Some((mut socket, registration)) = state.host.take() {
|
|
405
|
+
registration.deregister(&mut socket);
|
|
406
|
+
}
|
|
407
|
+
drop(state);
|
|
408
|
+
self.wait.wake_up();
|
|
409
|
+
}
|
|
410
|
+
}
|
|
411
|
+
|
|
412
|
+
/// A host failure as Linux's UDP answers it. Windows reports an ICMP port
|
|
413
|
+
/// unreachable as `WSAECONNRESET`, where Linux's `udp_err` sets
|
|
414
|
+
/// `ECONNREFUSED`, and a datagram socket has no connection to reset.
|
|
415
|
+
fn to_udp_error(err: &io::Error) -> Errno {
|
|
416
|
+
match Errno::from_io_error(err) {
|
|
417
|
+
Errno::ConnectionReset => Errno::ConnectionRefused,
|
|
418
|
+
other => other,
|
|
419
|
+
}
|
|
420
|
+
}
|
|
421
|
+
|
|
422
|
+
#[cfg(test)]
|
|
423
|
+
mod tests {
|
|
424
|
+
use std::net::UdpSocket;
|
|
425
|
+
|
|
426
|
+
use super::*;
|
|
427
|
+
use std::thread;
|
|
428
|
+
use std::time::{Duration, Instant};
|
|
429
|
+
|
|
430
|
+
use crate::net::socket::testing::wait_for;
|
|
431
|
+
use crate::net::{HostInet, IpProtocol};
|
|
432
|
+
use crate::security::prepare_creds;
|
|
433
|
+
|
|
434
|
+
/// A socket connected to `addr` through the host.
|
|
435
|
+
fn connected_socket(addr: SocketAddr) -> Arc<UdpSock> {
|
|
436
|
+
let sock = UdpSock::new(&prepare_creds(&[], None)).expect("an unbounded socket is made");
|
|
437
|
+
let family: Arc<dyn ProtocolFamily> = Arc::new(HostInet);
|
|
438
|
+
sock.dial(&family, addr, addr, &OpenConnections::new(None))
|
|
439
|
+
.expect("an uncapped socket connects");
|
|
440
|
+
sock
|
|
441
|
+
}
|
|
442
|
+
|
|
443
|
+
/// A socket connected to a peer that has sent it one datagram.
|
|
444
|
+
fn readable_socket() -> (Arc<UdpSock>, UdpSocket) {
|
|
445
|
+
let peer = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
446
|
+
let sock = connected_socket(peer.local_addr().unwrap());
|
|
447
|
+
let host = sock
|
|
448
|
+
.state()
|
|
449
|
+
.host
|
|
450
|
+
.as_ref()
|
|
451
|
+
.map(|(socket, _)| socket.local_addr());
|
|
452
|
+
peer.send_to(b"hello", host.unwrap().unwrap()).unwrap();
|
|
453
|
+
wait_for(|table| sock.poll(table), PollMask::IN);
|
|
454
|
+
(sock, peer)
|
|
455
|
+
}
|
|
456
|
+
|
|
457
|
+
// @behavior NW-125
|
|
458
|
+
#[test]
|
|
459
|
+
fn a_udp_socket_holds_its_hop_limit_and_receive_buffer() {
|
|
460
|
+
let peer = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
461
|
+
let addr = peer.local_addr().unwrap();
|
|
462
|
+
let sock = UdpSock::new(&prepare_creds(&[], None)).expect("an unbounded socket is made");
|
|
463
|
+
let get = |opt| sock.getsockopt(opt).unwrap() as usize;
|
|
464
|
+
let defaults = (
|
|
465
|
+
get(SockOpt::Ttl),
|
|
466
|
+
get(SockOpt::RcvBuf),
|
|
467
|
+
get(SockOpt::SndBuf),
|
|
468
|
+
);
|
|
469
|
+
let zero = sock.setsockopt(SockOpt::Ttl, 0);
|
|
470
|
+
sock.setsockopt(SockOpt::Ttl, 9)
|
|
471
|
+
.expect("a hop limit Linux takes");
|
|
472
|
+
sock.setsockopt(SockOpt::RcvBuf, 1000).unwrap();
|
|
473
|
+
sock.setsockopt(SockOpt::SndBuf, 1000).unwrap();
|
|
474
|
+
let family: Arc<dyn ProtocolFamily> = Arc::new(HostInet);
|
|
475
|
+
sock.dial(&family, addr, addr, &OpenConnections::new(None))
|
|
476
|
+
.expect("an uncapped socket connects");
|
|
477
|
+
let host = sock
|
|
478
|
+
.state()
|
|
479
|
+
.host
|
|
480
|
+
.as_ref()
|
|
481
|
+
.map(|(socket, _)| (socket.ttl().unwrap(), socket.local_addr().unwrap()));
|
|
482
|
+
let (host_ttl, local) = host.expect("the socket holds its host socket");
|
|
483
|
+
for _ in 0..4 {
|
|
484
|
+
peer.send_to(&[1; 1000], local).unwrap();
|
|
485
|
+
}
|
|
486
|
+
// Loopback hands datagrams over a moment apart, so wait for the two
|
|
487
|
+
// the buffer fits, then give the rest time to arrive and be dropped.
|
|
488
|
+
let started = Instant::now();
|
|
489
|
+
while sock.state().receive_queue.len() < 2 && started.elapsed() < Duration::from_secs(5) {
|
|
490
|
+
sock.on_event();
|
|
491
|
+
thread::sleep(Duration::from_millis(1));
|
|
492
|
+
}
|
|
493
|
+
thread::sleep(Duration::from_millis(50));
|
|
494
|
+
sock.on_event();
|
|
495
|
+
let held = sock.state().receive_queue.len();
|
|
496
|
+
assert_eq!(
|
|
497
|
+
(
|
|
498
|
+
defaults,
|
|
499
|
+
zero,
|
|
500
|
+
host_ttl,
|
|
501
|
+
get(SockOpt::RcvBuf),
|
|
502
|
+
get(SockOpt::SndBuf),
|
|
503
|
+
held
|
|
504
|
+
),
|
|
505
|
+
(
|
|
506
|
+
(64, MAX_SOCKET_BUFFER, MAX_SOCKET_BUFFER),
|
|
507
|
+
Err(Errno::InvalidInput),
|
|
508
|
+
9,
|
|
509
|
+
2304,
|
|
510
|
+
4608,
|
|
511
|
+
2
|
|
512
|
+
),
|
|
513
|
+
"a UDP socket must read Linux's default hop limit, refuse zero with EINVAL, give the \
|
|
514
|
+
host socket it connects the limit set, and drop datagrams past a receive buffer \
|
|
515
|
+
doubled as Linux doubles it"
|
|
516
|
+
);
|
|
517
|
+
}
|
|
518
|
+
|
|
519
|
+
// @behavior NW-148
|
|
520
|
+
#[test]
|
|
521
|
+
fn empty_datagrams_fill_the_receive_buffer_too() {
|
|
522
|
+
let peer = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
523
|
+
let addr = peer.local_addr().unwrap();
|
|
524
|
+
let sock = UdpSock::new(&prepare_creds(&[], None)).expect("an unbounded socket is made");
|
|
525
|
+
sock.setsockopt(SockOpt::RcvBuf, 1000).unwrap();
|
|
526
|
+
let family: Arc<dyn ProtocolFamily> = Arc::new(HostInet);
|
|
527
|
+
sock.dial(&family, addr, addr, &OpenConnections::new(None))
|
|
528
|
+
.expect("an uncapped socket connects");
|
|
529
|
+
let local = sock
|
|
530
|
+
.state()
|
|
531
|
+
.host
|
|
532
|
+
.as_ref()
|
|
533
|
+
.map(|(socket, _)| socket.local_addr().unwrap())
|
|
534
|
+
.expect("the socket holds its host socket");
|
|
535
|
+
for _ in 0..200 {
|
|
536
|
+
peer.send_to(&[], local).unwrap();
|
|
537
|
+
}
|
|
538
|
+
let started = Instant::now();
|
|
539
|
+
while sock.state().receive_queue.len() < 41 && started.elapsed() < Duration::from_secs(5) {
|
|
540
|
+
sock.on_event();
|
|
541
|
+
thread::sleep(Duration::from_millis(1));
|
|
542
|
+
}
|
|
543
|
+
thread::sleep(Duration::from_millis(50));
|
|
544
|
+
sock.on_event();
|
|
545
|
+
assert_eq!(
|
|
546
|
+
sock.state().receive_queue.len(),
|
|
547
|
+
41,
|
|
548
|
+
"a UDP socket whose receive buffer reads 2304 must queue no more than 41 of 200 \
|
|
549
|
+
empty datagrams, as each spends the queue entry that holds it and its sender, as \
|
|
550
|
+
Linux's truesize counts the sk_buff"
|
|
551
|
+
);
|
|
552
|
+
}
|
|
553
|
+
|
|
554
|
+
// @behavior NW-185
|
|
555
|
+
#[test]
|
|
556
|
+
fn an_empty_queue_takes_a_datagram_past_the_receive_buffer() {
|
|
557
|
+
let peer = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
558
|
+
let addr = peer.local_addr().unwrap();
|
|
559
|
+
let sock = UdpSock::new(&prepare_creds(&[], None)).expect("an unbounded socket is made");
|
|
560
|
+
sock.setsockopt(SockOpt::RcvBuf, 1000).unwrap();
|
|
561
|
+
let family: Arc<dyn ProtocolFamily> = Arc::new(HostInet);
|
|
562
|
+
sock.dial(&family, addr, addr, &OpenConnections::new(None))
|
|
563
|
+
.expect("an uncapped socket connects");
|
|
564
|
+
let local = sock
|
|
565
|
+
.state()
|
|
566
|
+
.host
|
|
567
|
+
.as_ref()
|
|
568
|
+
.map(|(socket, _)| socket.local_addr().unwrap())
|
|
569
|
+
.expect("the socket holds its host socket");
|
|
570
|
+
for _ in 0..2 {
|
|
571
|
+
peer.send_to(&[7; 3000], local).unwrap();
|
|
572
|
+
}
|
|
573
|
+
let started = Instant::now();
|
|
574
|
+
while sock.state().receive_queue.is_empty() && started.elapsed() < Duration::from_secs(5) {
|
|
575
|
+
sock.on_event();
|
|
576
|
+
thread::sleep(Duration::from_millis(1));
|
|
577
|
+
}
|
|
578
|
+
thread::sleep(Duration::from_millis(50));
|
|
579
|
+
sock.on_event();
|
|
580
|
+
let lengths = sock
|
|
581
|
+
.state()
|
|
582
|
+
.receive_queue
|
|
583
|
+
.iter()
|
|
584
|
+
.map(|(bytes, _)| bytes.len())
|
|
585
|
+
.collect::<Vec<_>>();
|
|
586
|
+
assert_eq!(
|
|
587
|
+
lengths,
|
|
588
|
+
[3000],
|
|
589
|
+
"a UDP socket whose receive buffer reads 2304 must take one 3000-byte datagram into \
|
|
590
|
+
its empty queue and drop the next, as __udp_enqueue_schedule_skb accepts a packet \
|
|
591
|
+
past rcvbuf only while the queue is empty"
|
|
592
|
+
);
|
|
593
|
+
}
|
|
594
|
+
|
|
595
|
+
// @behavior NW-152
|
|
596
|
+
#[test]
|
|
597
|
+
fn a_udp_shutdown_keeps_reads_nonblocking_and_refuses_sends_as_linux() {
|
|
598
|
+
let peer = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
599
|
+
let sock = connected_socket(peer.local_addr().unwrap());
|
|
600
|
+
let unconnected =
|
|
601
|
+
UdpSock::new(&prepare_creds(&[], None)).expect("an unbounded socket is made");
|
|
602
|
+
let before = sock.recvmsg(&mut [0; 4]);
|
|
603
|
+
sock.shutdown(Shutdown::Read)
|
|
604
|
+
.expect("a connected socket shuts down");
|
|
605
|
+
let read = (
|
|
606
|
+
sock.recvmsg(&mut [0; 4]),
|
|
607
|
+
sock.poll(None).contains(PollMask::IN),
|
|
608
|
+
);
|
|
609
|
+
sock.shutdown(Shutdown::Write)
|
|
610
|
+
.expect("a connected socket shuts down");
|
|
611
|
+
let sent = sock.sendmsg(b"late");
|
|
612
|
+
assert_eq!(
|
|
613
|
+
(
|
|
614
|
+
before,
|
|
615
|
+
read,
|
|
616
|
+
sent,
|
|
617
|
+
sock.poll(None).contains(PollMask::HUP),
|
|
618
|
+
unconnected.shutdown(Shutdown::Both)
|
|
619
|
+
),
|
|
620
|
+
(
|
|
621
|
+
Err(Errno::WouldBlock),
|
|
622
|
+
(Err(Errno::WouldBlock), true),
|
|
623
|
+
Err(Errno::BrokenPipe),
|
|
624
|
+
true,
|
|
625
|
+
Err(Errno::NotConnected)
|
|
626
|
+
),
|
|
627
|
+
"a non-blocking UDP socket whose reading side is shut must poll readable yet still \
|
|
628
|
+
answer EAGAIN on an empty queue, answer EPIPE to a send once its writing side is \
|
|
629
|
+
shut, poll hung up once both are, and answer ENOTCONN to a shutdown with no peer, \
|
|
630
|
+
as Linux's inet_shutdown and __skb_recv_udp"
|
|
631
|
+
);
|
|
632
|
+
}
|
|
633
|
+
|
|
634
|
+
// @behavior NW-086
|
|
635
|
+
#[test]
|
|
636
|
+
fn a_zero_byte_read_keeps_the_datagram() {
|
|
637
|
+
let (sock, _peer) = readable_socket();
|
|
638
|
+
let mut file = crate::net::sock_alloc_file(sock.clone(), &Arc::default());
|
|
639
|
+
let mut buf = [0; 8];
|
|
640
|
+
let zero = file.read(&mut []);
|
|
641
|
+
let next = file.read(&mut buf).map(|n| buf[..n].to_vec());
|
|
642
|
+
assert_eq!(
|
|
643
|
+
(zero, next),
|
|
644
|
+
(Ok(0), Ok(b"hello".to_vec())),
|
|
645
|
+
"File::read of zero bytes from a UDP socket holding a datagram must answer zero and \
|
|
646
|
+
leave the datagram for the next read"
|
|
647
|
+
);
|
|
648
|
+
}
|
|
649
|
+
|
|
650
|
+
// @behavior NW-087
|
|
651
|
+
#[test]
|
|
652
|
+
fn a_failure_answers_before_the_datagram_it_holds() {
|
|
653
|
+
let (sock, _peer) = readable_socket();
|
|
654
|
+
sock.state().inet.err = Some(Errno::ConnectionRefused);
|
|
655
|
+
let polled = sock.poll(None);
|
|
656
|
+
let mut buf = [0; 8];
|
|
657
|
+
let first = sock.recvmsg(&mut buf);
|
|
658
|
+
let second = sock.recvmsg(&mut buf).map(|(n, _)| buf[..n].to_vec());
|
|
659
|
+
assert_eq!(
|
|
660
|
+
(polled, first, second),
|
|
661
|
+
(
|
|
662
|
+
PollMask::IN | PollMask::OUT | PollMask::ERR,
|
|
663
|
+
Err(Errno::ConnectionRefused),
|
|
664
|
+
Ok(b"hello".to_vec())
|
|
665
|
+
),
|
|
666
|
+
"a UDP socket holding a datagram and a failure must poll IN and ERR, then answer the \
|
|
667
|
+
failure before the datagram, as __skb_recv_udp asks sock_error first"
|
|
668
|
+
);
|
|
669
|
+
}
|
|
670
|
+
|
|
671
|
+
/// Stop the reactor taking `sock`'s datagrams in, so each stays in the
|
|
672
|
+
/// host's queue until the socket itself takes it; the host socket's own
|
|
673
|
+
/// address.
|
|
674
|
+
fn stop_reactor_for(sock: &UdpSock) -> SocketAddr {
|
|
675
|
+
let local = {
|
|
676
|
+
let mut state = sock.state();
|
|
677
|
+
let (socket, registration) = state.host.as_mut().expect("a connected socket");
|
|
678
|
+
registration.deregister(socket);
|
|
679
|
+
socket.local_addr().unwrap()
|
|
680
|
+
};
|
|
681
|
+
// An event the reactor took before the deregister may still run.
|
|
682
|
+
thread::sleep(Duration::from_millis(100));
|
|
683
|
+
local
|
|
684
|
+
}
|
|
685
|
+
|
|
686
|
+
/// Wait until a datagram waits in `sock`'s host socket.
|
|
687
|
+
fn wait_until_queued(sock: &UdpSock) {
|
|
688
|
+
let started = Instant::now();
|
|
689
|
+
while started.elapsed() < Duration::from_secs(5) {
|
|
690
|
+
let state = sock.state();
|
|
691
|
+
let (socket, _) = state.host.as_ref().expect("a connected socket");
|
|
692
|
+
if socket.peek_from(&mut [0; 8]).is_ok() {
|
|
693
|
+
return;
|
|
694
|
+
}
|
|
695
|
+
drop(state);
|
|
696
|
+
thread::sleep(Duration::from_millis(1));
|
|
697
|
+
}
|
|
698
|
+
panic!("the peer's datagram never reached the host socket's queue within 5 s");
|
|
699
|
+
}
|
|
700
|
+
|
|
701
|
+
// @behavior NW-174
|
|
702
|
+
#[test]
|
|
703
|
+
fn a_flooded_udp_socket_takes_its_datagrams_in_bounded_turns() {
|
|
704
|
+
let peer = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
705
|
+
let sock = connected_socket(peer.local_addr().unwrap());
|
|
706
|
+
let local = stop_reactor_for(&sock);
|
|
707
|
+
for i in 0..100u8 {
|
|
708
|
+
peer.send_to(&[i], local).unwrap();
|
|
709
|
+
}
|
|
710
|
+
wait_until_queued(&sock);
|
|
711
|
+
thread::sleep(Duration::from_millis(200));
|
|
712
|
+
// The turn is read under its own lock, before a repoll can take more.
|
|
713
|
+
let one_turn = {
|
|
714
|
+
let mut state = sock.state();
|
|
715
|
+
sock.pump(&mut state);
|
|
716
|
+
state.receive_queue.len()
|
|
717
|
+
};
|
|
718
|
+
let started = Instant::now();
|
|
719
|
+
while sock.state().receive_queue.len() < 100 && started.elapsed() < Duration::from_secs(5) {
|
|
720
|
+
thread::sleep(Duration::from_millis(1));
|
|
721
|
+
}
|
|
722
|
+
let mut read = Vec::new();
|
|
723
|
+
let mut buf = [0; 1];
|
|
724
|
+
while let Ok((1, _)) = sock.recvmsg(&mut buf) {
|
|
725
|
+
read.push(buf[0]);
|
|
726
|
+
}
|
|
727
|
+
assert_eq!(
|
|
728
|
+
(one_turn, read),
|
|
729
|
+
(64, (0..100u8).collect::<Vec<_>>()),
|
|
730
|
+
"a UDP socket whose peer sent 100 datagrams must take 64 in one turn, as \
|
|
731
|
+
NAPI_POLL_WEIGHT bounds one poll, and read all 100 in order once a later turn takes \
|
|
732
|
+
the rest"
|
|
733
|
+
);
|
|
734
|
+
}
|
|
735
|
+
|
|
736
|
+
// @behavior NW-174
|
|
737
|
+
#[test]
|
|
738
|
+
fn a_turn_that_spends_its_bound_is_taken_again_unread() {
|
|
739
|
+
let peer = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
740
|
+
let sock = connected_socket(peer.local_addr().unwrap());
|
|
741
|
+
let local = stop_reactor_for(&sock);
|
|
742
|
+
for i in 0..100u8 {
|
|
743
|
+
peer.send_to(&[i], local).unwrap();
|
|
744
|
+
}
|
|
745
|
+
wait_until_queued(&sock);
|
|
746
|
+
thread::sleep(Duration::from_millis(200));
|
|
747
|
+
sock.pump(&mut sock.state());
|
|
748
|
+
let started = Instant::now();
|
|
749
|
+
while sock.state().receive_queue.len() < 100 && started.elapsed() < Duration::from_secs(5) {
|
|
750
|
+
thread::sleep(Duration::from_millis(1));
|
|
751
|
+
}
|
|
752
|
+
assert_eq!(
|
|
753
|
+
sock.state().receive_queue.len(),
|
|
754
|
+
100,
|
|
755
|
+
"a UDP socket whose turn took 64 of 100 datagrams must take the rest in a later turn \
|
|
756
|
+
with no read and no further event, as NAPI repolls a device that spent its weight"
|
|
757
|
+
);
|
|
758
|
+
}
|
|
759
|
+
|
|
760
|
+
// @behavior NW-172
|
|
761
|
+
#[test]
|
|
762
|
+
fn a_datagram_reads_with_the_peer_that_sent_it() {
|
|
763
|
+
let first = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
764
|
+
let second = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
765
|
+
let (at_first, at_second) = (first.local_addr().unwrap(), second.local_addr().unwrap());
|
|
766
|
+
let sock = connected_socket(at_first);
|
|
767
|
+
let local = stop_reactor_for(&sock);
|
|
768
|
+
first.send_to(b"one", local).unwrap();
|
|
769
|
+
wait_until_queued(&sock);
|
|
770
|
+
let family: Arc<dyn ProtocolFamily> = Arc::new(HostInet);
|
|
771
|
+
sock.dial(&family, at_second, at_second, &OpenConnections::new(None))
|
|
772
|
+
.expect("an uncapped socket connects again");
|
|
773
|
+
second.send_to(b"two", local).unwrap();
|
|
774
|
+
wait_until_queued(&sock);
|
|
775
|
+
sock.pump(&mut sock.state());
|
|
776
|
+
let mut buf = [0; 8];
|
|
777
|
+
let mut read = || {
|
|
778
|
+
sock.recvmsg(&mut buf)
|
|
779
|
+
.map(|(n, from)| (buf[..n].to_vec(), from))
|
|
780
|
+
};
|
|
781
|
+
assert_eq!(
|
|
782
|
+
(read(), read()),
|
|
783
|
+
(
|
|
784
|
+
Ok((b"one".to_vec(), Some(at_first))),
|
|
785
|
+
Ok((b"two".to_vec(), Some(at_second)))
|
|
786
|
+
),
|
|
787
|
+
"a UDP socket's read after it connects to a second peer must read the first \
|
|
788
|
+
peer's datagram with the first peer and the second's with the second, as \
|
|
789
|
+
udp_recvmsg names each datagram's source"
|
|
790
|
+
);
|
|
791
|
+
}
|
|
792
|
+
|
|
793
|
+
// @behavior NW-172
|
|
794
|
+
#[test]
|
|
795
|
+
fn a_datagram_waiting_as_the_socket_moves_family_reads_with_its_peer() {
|
|
796
|
+
let first = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
797
|
+
let second = UdpSocket::bind("[::1]:0").unwrap();
|
|
798
|
+
let (at_first, at_second) = (first.local_addr().unwrap(), second.local_addr().unwrap());
|
|
799
|
+
let sock = connected_socket(at_first);
|
|
800
|
+
let local = stop_reactor_for(&sock);
|
|
801
|
+
first.send_to(b"one", local).unwrap();
|
|
802
|
+
wait_until_queued(&sock);
|
|
803
|
+
let family: Arc<dyn ProtocolFamily> = Arc::new(HostInet);
|
|
804
|
+
sock.dial(&family, at_second, at_second, &OpenConnections::new(None))
|
|
805
|
+
.expect("an uncapped socket connects to an IPv6 peer");
|
|
806
|
+
let mut buf = [0; 8];
|
|
807
|
+
let read = sock
|
|
808
|
+
.recvmsg(&mut buf)
|
|
809
|
+
.map(|(n, from)| (buf[..n].to_vec(), from));
|
|
810
|
+
assert_eq!(
|
|
811
|
+
read,
|
|
812
|
+
Ok((b"one".to_vec(), Some(at_first))),
|
|
813
|
+
"a UDP socket that connects from an IPv4 peer to an IPv6 one must still read the \
|
|
814
|
+
datagram the first peer sent before, with the first peer, as Linux's repointed \
|
|
815
|
+
socket keeps its receive queue"
|
|
816
|
+
);
|
|
817
|
+
}
|
|
818
|
+
|
|
819
|
+
// @behavior NW-227
|
|
820
|
+
#[test]
|
|
821
|
+
fn a_socket_connected_again_repoints_within_the_family_its_route_sends_in() {
|
|
822
|
+
let first = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
823
|
+
let second = UdpSocket::bind("[::1]:0").unwrap();
|
|
824
|
+
let (to_first, to_second) = (
|
|
825
|
+
SocketAddr::from(([93, 184, 216, 34], 53)),
|
|
826
|
+
SocketAddr::from(([93, 184, 216, 35], 53)),
|
|
827
|
+
);
|
|
828
|
+
let mock = Arc::new(crate::net::Mock::default());
|
|
829
|
+
mock.route(IpProtocol::Udp, to_first, first.local_addr().unwrap());
|
|
830
|
+
mock.route(IpProtocol::Udp, to_second, second.local_addr().unwrap());
|
|
831
|
+
let family: Arc<dyn ProtocolFamily> = mock.clone();
|
|
832
|
+
let sock = UdpSock::new(&prepare_creds(&[], None)).expect("an unbounded socket is made");
|
|
833
|
+
let cap = OpenConnections::new(None);
|
|
834
|
+
sock.dial(&family, to_first, to_first, &cap)
|
|
835
|
+
.expect("a routed socket connects");
|
|
836
|
+
let again = sock.dial(&family, to_second, to_second, &cap);
|
|
837
|
+
wait_for(|table| sock.poll(table), PollMask::OUT);
|
|
838
|
+
let sent = sock.sendmsg(b"ping");
|
|
839
|
+
second
|
|
840
|
+
.set_read_timeout(Some(Duration::from_secs(5)))
|
|
841
|
+
.unwrap();
|
|
842
|
+
let heard = second.recv_from(&mut [0; 8]).map(|(n, _)| n).ok();
|
|
843
|
+
sock.release();
|
|
844
|
+
assert_eq!(
|
|
845
|
+
(again, sent.is_ok(), heard, mock.dialed_addresses()),
|
|
846
|
+
(Ok(()), true, Some(4), vec![to_first, to_second]),
|
|
847
|
+
"a UDP socket under a Mock, connected again to an IPv4 address its route sends to an \
|
|
848
|
+
IPv6 peer, must connect and reach that peer, as a fresh socket of the routed \
|
|
849
|
+
family would, the Mock reading back each connect once"
|
|
850
|
+
);
|
|
851
|
+
}
|
|
852
|
+
|
|
853
|
+
// @behavior NW-227
|
|
854
|
+
#[test]
|
|
855
|
+
fn a_mock_reads_back_each_udp_connect_once() {
|
|
856
|
+
let peer = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
857
|
+
let (to_x, to_y, to_z) = (
|
|
858
|
+
SocketAddr::from(([93, 184, 216, 34], 53)),
|
|
859
|
+
SocketAddr::from(([93, 184, 216, 35], 53)),
|
|
860
|
+
SocketAddr::from(([93, 184, 216, 36], 53)),
|
|
861
|
+
);
|
|
862
|
+
let mock = Arc::new(crate::net::Mock::default());
|
|
863
|
+
mock.route(IpProtocol::Udp, to_x, peer.local_addr().unwrap());
|
|
864
|
+
mock.route(IpProtocol::Udp, to_y, peer.local_addr().unwrap());
|
|
865
|
+
mock.refuse(IpProtocol::Udp, to_z, Errno::AddressNotAvailable);
|
|
866
|
+
let family: Arc<dyn ProtocolFamily> = mock.clone();
|
|
867
|
+
let cap = OpenConnections::new(None);
|
|
868
|
+
let socket = || UdpSock::new(&prepare_creds(&[], None)).expect("an unbounded socket");
|
|
869
|
+
let (first, second, third) = (socket(), socket(), socket());
|
|
870
|
+
let answers = [
|
|
871
|
+
first.dial(&family, to_x, to_x, &cap),
|
|
872
|
+
first.dial(&family, to_y, to_y, &cap),
|
|
873
|
+
second.dial(&family, to_y, to_y, &cap),
|
|
874
|
+
first.dial(&family, to_z, to_z, &cap),
|
|
875
|
+
third.dial(&family, to_z, to_z, &cap),
|
|
876
|
+
];
|
|
877
|
+
for sock in [first, second, third] {
|
|
878
|
+
sock.release();
|
|
879
|
+
}
|
|
880
|
+
assert_eq!(
|
|
881
|
+
(answers, mock.dialed_addresses()),
|
|
882
|
+
(
|
|
883
|
+
[
|
|
884
|
+
Ok(()),
|
|
885
|
+
Ok(()),
|
|
886
|
+
Ok(()),
|
|
887
|
+
Err(Errno::AddressNotAvailable),
|
|
888
|
+
Err(Errno::AddressNotAvailable)
|
|
889
|
+
],
|
|
890
|
+
vec![to_x, to_y, to_y, to_z, to_z]
|
|
891
|
+
),
|
|
892
|
+
"a Mock must read back each UDP connect once, a socket connected again or refused \
|
|
893
|
+
as it connects again counting as one dial and a fresh socket to the same address \
|
|
894
|
+
as another"
|
|
895
|
+
);
|
|
896
|
+
}
|
|
897
|
+
|
|
898
|
+
// @behavior NW-088
|
|
899
|
+
#[test]
|
|
900
|
+
fn a_socket_connected_again_keeps_its_place() {
|
|
901
|
+
let first = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
902
|
+
let second = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
903
|
+
let family: Arc<dyn ProtocolFamily> = Arc::new(HostInet);
|
|
904
|
+
let cap = OpenConnections::new(Some(1));
|
|
905
|
+
let sock = UdpSock::new(&prepare_creds(&[], None)).expect("an unbounded socket is made");
|
|
906
|
+
let at = |peer: &UdpSocket| peer.local_addr().unwrap();
|
|
907
|
+
let heard_by = |peer: &UdpSocket| {
|
|
908
|
+
wait_for(|table| sock.poll(table), PollMask::OUT);
|
|
909
|
+
sock.sendmsg(b"ping").unwrap();
|
|
910
|
+
peer.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
911
|
+
peer.recv_from(&mut [0; 8])
|
|
912
|
+
.map(|(_, from)| from.port())
|
|
913
|
+
.ok()
|
|
914
|
+
};
|
|
915
|
+
let once = sock.dial(&family, at(&first), at(&first), &cap);
|
|
916
|
+
let first_heard = heard_by(&first);
|
|
917
|
+
let again = sock.dial(&family, at(&second), at(&second), &cap);
|
|
918
|
+
let second_heard = heard_by(&second);
|
|
919
|
+
sock.release();
|
|
920
|
+
assert_eq!(
|
|
921
|
+
(
|
|
922
|
+
once,
|
|
923
|
+
again,
|
|
924
|
+
first_heard.is_some() && first_heard == second_heard
|
|
925
|
+
),
|
|
926
|
+
(Ok(()), Ok(()), true),
|
|
927
|
+
"a UDP socket's connect to a second peer under a cap of one must keep the place the \
|
|
928
|
+
socket holds, not answer EAGAIN, and the second peer must hear from the port the \
|
|
929
|
+
first heard"
|
|
930
|
+
);
|
|
931
|
+
}
|
|
932
|
+
|
|
933
|
+
// @behavior NW-053
|
|
934
|
+
#[test]
|
|
935
|
+
fn a_datagram_round_trips_with_one_peer() {
|
|
936
|
+
let peer = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
937
|
+
let sock = connected_socket(peer.local_addr().unwrap());
|
|
938
|
+
wait_for(|table| sock.poll(table), PollMask::OUT);
|
|
939
|
+
sock.sendmsg(b"ping").unwrap();
|
|
940
|
+
let mut heard = [0; 16];
|
|
941
|
+
let (n, from) = peer.recv_from(&mut heard).unwrap();
|
|
942
|
+
peer.send_to(b"PONG", from).unwrap();
|
|
943
|
+
wait_for(|table| sock.poll(table), PollMask::IN);
|
|
944
|
+
let mut answer = [0; 2];
|
|
945
|
+
let (read, _) = sock.recvmsg(&mut answer).unwrap();
|
|
946
|
+
let rest = sock.recvmsg(&mut [0; 2]);
|
|
947
|
+
sock.release();
|
|
948
|
+
assert_eq!(
|
|
949
|
+
(&heard[..n], &answer[..read], rest),
|
|
950
|
+
(&b"ping"[..], &b"PO"[..], Err(Errno::WouldBlock)),
|
|
951
|
+
"a UDP socket must send a datagram to its peer and read one back per read, cut to the \
|
|
952
|
+
buffer, with the rest of it gone"
|
|
953
|
+
);
|
|
954
|
+
}
|
|
955
|
+
|
|
956
|
+
// @behavior NW-070
|
|
957
|
+
#[test]
|
|
958
|
+
fn a_reset_the_host_reports_on_udp_reads_as_refused() {
|
|
959
|
+
let reset = io::Error::from(io::ErrorKind::ConnectionReset);
|
|
960
|
+
assert_eq!(
|
|
961
|
+
to_udp_error(&reset),
|
|
962
|
+
Errno::ConnectionRefused,
|
|
963
|
+
"a UDP socket's failure the host reports as a reset, as Windows reports an ICMP port \
|
|
964
|
+
unreachable, must answer ECONNREFUSED, as Linux's does"
|
|
965
|
+
);
|
|
966
|
+
}
|
|
967
|
+
|
|
968
|
+
// @behavior NW-070
|
|
969
|
+
#[test]
|
|
970
|
+
fn a_udp_failure_is_answered_once() {
|
|
971
|
+
// A port no test binds, privileged where the host has such ports, so it
|
|
972
|
+
// answers unreachable and no socket, this one's own host socket among
|
|
973
|
+
// them, can be handed it meanwhile.
|
|
974
|
+
let sock = connected_socket(SocketAddr::from(([127, 0, 0, 1], 1)));
|
|
975
|
+
wait_for(|table| sock.poll(table), PollMask::OUT);
|
|
976
|
+
sock.sendmsg(b"ping").unwrap();
|
|
977
|
+
wait_for(|table| sock.poll(table), PollMask::ERR);
|
|
978
|
+
let first = sock.recvmsg(&mut [0; 4]);
|
|
979
|
+
let again = sock.recvmsg(&mut [0; 4]);
|
|
980
|
+
sock.release();
|
|
981
|
+
assert_eq!(
|
|
982
|
+
(first, again),
|
|
983
|
+
(Err(Errno::ConnectionRefused), Err(Errno::WouldBlock)),
|
|
984
|
+
"a UDP socket's read after a datagram to a closed port must answer ECONNREFUSED once \
|
|
985
|
+
and then read on, as sock_error clears sk_err"
|
|
986
|
+
);
|
|
987
|
+
}
|
|
988
|
+
|
|
989
|
+
#[test]
|
|
990
|
+
fn a_datagram_past_what_udp_carries_is_refused() {
|
|
991
|
+
let peer = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
992
|
+
let sock = connected_socket(peer.local_addr().unwrap());
|
|
993
|
+
wait_for(|table| sock.poll(table), PollMask::OUT);
|
|
994
|
+
let answer = sock.sendmsg(&vec![0; MAX_DATAGRAM + 1]);
|
|
995
|
+
sock.release();
|
|
996
|
+
assert_eq!(
|
|
997
|
+
answer,
|
|
998
|
+
Err(Errno::MessageTooLong),
|
|
999
|
+
"UdpSock::sendmsg of a datagram past what IPv4 UDP carries must answer EMSGSIZE, as \
|
|
1000
|
+
udp_sendmsg does"
|
|
1001
|
+
);
|
|
1002
|
+
}
|
|
1003
|
+
}
|